Merge from Gnus trunk.old-branches/branch-5_8

8 files changed, 5105 insertions, 2154 deletions

diff --git a/lisp/gnus/gnus-art.el b/lisp/gnus/gnus-art.el
index ac2aed4ba71..4bc1e3fe708 100644
--- a/lisp/gnus/gnus-art.el
+++ b/lisp/gnus/gnus-art.el
@@ -1,5 +1,5 @@
 ;;; gnus-art.el --- article mode commands for Gnus
-;; Copyright (C) 1996,97,98 Free Software Foundation, Inc.
+;; Copyright (C) 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
 
 ;; Author: Lars Magne Ingebrigtsen <larsi@gnus.org>
 ;; Keywords: news
@@ -27,20 +27,27 @@
 
 (eval-when-compile (require 'cl))
 
-(eval-when-compile (require 'cl))
-
-(require 'custom)
 (require 'gnus)
 (require 'gnus-sum)
 (require 'gnus-spec)
 (require 'gnus-int)
-(require 'browse-url)
+(require 'mm-bodies)
+(require 'mail-parse)
+(require 'mm-decode)
+(require 'mm-view)
+(require 'wid-edit)
+(require 'mm-uu)
 
 (defgroup gnus-article nil
   "Article display."
   :link '(custom-manual "(gnus)The Article Buffer")
   :group 'gnus)
 
+(defgroup gnus-article-treat nil
+  "Treating article parts."
+  :link '(custom-manual "(gnus)Article Hiding")
+  :group 'gnus-article)
+
 (defgroup gnus-article-hiding nil
   "Hiding article parts."
   :link '(custom-manual "(gnus)Article Hiding")
@@ -107,11 +114,19 @@
     "^Originator:" "^X-Problems-To:" "^X-Auth-User:" "^X-Post-Time:"
     "^X-Admin:" "^X-UID:" "^Resent-[-A-Za-z]+:" "^X-Mailing-List:"
     "^Precedence:" "^Original-[-A-Za-z]+:" "^X-filename:" "^X-Orcpt:"
-    "^Old-Received:" "^X-Pgp-Fingerprint:" "^X-Pgp-Key-Id:"
-    "^X-Pgp-Public-Key-Url:" "^X-Auth:" "^X-From-Line:"
+    "^Old-Received:" "^X-Pgp" "^X-Auth:" "^X-From-Line:"
     "^X-Gnus-Article-Number:" "^X-Majordomo:" "^X-Url:" "^X-Sender:"
-    "^X-Mailing-List:" "^MBOX-Line" "^Priority:" "^X-Pgp" "^X400-[-A-Za-z]+:"
-    "^Status:")
+    "^MBOX-Line" "^Priority:" "^X-Pgp" "^X400-[-A-Za-z]+:"
+    "^Status:" "^X-Gnus-Mail-Source:" "^Cancel-Lock:"
+    "^X-FTN" "^X-EXP32-SerialNo:" "^Encoding:" "^Importance:"
+    "^Autoforwarded:" "^Original-Encoded-Information-Types:" "^X-Ya-Pop3:"
+    "^X-Face-Version:" "^X-Vms-To:" "^X-ML-NAME:" "^X-ML-COUNT:"
+    "^Mailing-List:" "^X-finfo:" "^X-md5sum:" "^X-md5sum-Origin:"
+    "^X-Sun-Charset:" "^X-Accept-Language:" "^X-Envelope-Sender:"
+    "^List-[A-Za-z]+:" "^X-Listprocessor-Version:"
+    "^X-Received:" "^X-Distribute:" "^X-Sequence:" "^X-Juno-Line-Breaks:"
+    "^X-Notes-Item:" "^X-MS-TNEF-Correlator:" "^x-uunet-gateway:"
+    "^X-Received:" "^Content-length:" "X-precedence:")
   "*All headers that start with this regexp will be hidden.
 This variable can also be a list of regexps of headers to be ignored.
 If `gnus-visible-headers' is non-nil, this variable will be ignored."
@@ -121,7 +136,7 @@ If `gnus-visible-headers' is non-nil, this variable will be ignored."
   :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:\\|^[BGF]?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."
@@ -152,8 +167,8 @@ Possible values in this list are `empty', `newsgroups', `followup-to',
               (const :tag "Followup-to identical to newsgroups." followup-to)
               (const :tag "Reply-to identical to from." reply-to)
               (const :tag "Date less than four days old." date)
-              (const :tag "Very long To header." long-to)
-              (const :tag "Multiple To headers." many-to))
+              (const :tag "Very long To and/or Cc header." long-to)
+              (const :tag "Multiple To and/or Cc headers." many-to))
   :group 'gnus-article-hiding)
 
 (defcustom gnus-signature-separator '("^-- $" "^-- *$")
@@ -165,7 +180,7 @@ 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
@@ -183,12 +198,20 @@ regexp.  If it matches, the text in question is not a signature."
   :type 'sexp
   :group 'gnus-article-hiding)
 
+;; Fixme: This isn't the right thing for mixed graphical and and
+;; non-graphical frames in a session.
+;; gnus-xmas.el overrides this for XEmacs.
 (defcustom gnus-article-x-face-command
-  "{ echo '/* Width=48, Height=48 */'; uncompface; } | icontopbm | xv -quit -"
+  (if (and (fboundp 'image-type-available-p)
+           (image-type-available-p 'xbm))
+      'gnus-article-display-xface
+    "{ echo '/* Width=48, Height=48 */'; uncompface; } | icontopbm | display -")
   "*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."
-  :type 'string                         ;Leave function case to Lisp.
+  :type '(choice string
+                 (function-item gnus-article-display-xface)
+                 function)
   :group 'gnus-article-washing)
 
 (defcustom gnus-article-x-face-too-ugly nil
@@ -198,7 +221,7 @@ asynchronously.	 The compressed face will be piped to this command."
 
 (defcustom gnus-emphasis-alist
   (let ((format
-         "\\(\\s-\\|^\\|[-\"]\\|\\s(\\|\\s)\\)\\(%s\\(\\w+\\(\\s-+\\w+\\)*[.,]?\\)%s\\)\\(\\s-\\|[-?!.,;:\"]\\|\\s(\\|\\s)\\)")
+         "\\(\\s-\\|^\\|[-\"]\\|\\s(\\)\\(%s\\(\\w+\\(\\s-+\\w+\\)*[.,]?\\)%s\\)\\(\\s-\\|[-,;:\"]\\s-\\|[?!.]+\\s-\\|\\s)\\)")
         (types
          '(("_" "_" underline)
            ("/" "/" italic)
@@ -232,6 +255,14 @@ is the face used for highlighting."
                        face))
   :group 'gnus-article-emphasis)
 
+(defcustom gnus-emphasize-whitespace-regexp "^[ \t]+\\|[ \t]*\n"
+  "A regexp to describe whitespace which should not be emphasized.
+Typical values are \"^[ \\t]+\\\\|[ \\t]*\\n\" and \"[ \\t]+\\\\|[ \\t]*\\n\".
+The former avoids underlining of leading and trailing whitespace,
+and the latter avoids underlining any whitespace at all."
+  :group 'gnus-article-emphasis
+  :type 'regexp)
+
 (defface gnus-emphasis-bold '((t (:bold t)))
   "Face used for displaying strong emphasized text (*word*)."
   :group 'gnus-article-emphasis)
@@ -262,6 +293,11 @@ is the face used for highlighting."
 Esample: (_/*word*/_)."
   :group 'gnus-article-emphasis)
 
+(defface gnus-emphasis-highlight-words
+  '((t (:background "black" :foreground "yellow")))
+  "Face used for displaying highlighted words."
+  :group 'gnus-article-emphasis)
+
 (defcustom gnus-article-time-format "%a, %b %d %Y %T %Z"
   "Format for display of Date headers in article bodies.
 See `format-time-string' for the possible values.
@@ -274,8 +310,6 @@ be fed to `format-time-string'."
   :group 'gnus-article-washing)
 
 (eval-and-compile
-  (autoload 'hexl-hex-string-to-integer "hexl")
-  (autoload 'timezone-make-date-arpa-standard "timezone")
   (autoload 'mail-extract-address-components "mail-extr"))
 
 (defcustom gnus-save-all-headers t
@@ -377,34 +411,6 @@ be used as possible file names."
                          (cons :value ("" "") regexp (repeat string))
                          (sexp :value nil))))
 
-(defcustom gnus-strict-mime t
-  "*If nil, MIME-decode even if there is no Mime-Version header."
-  :group 'gnus-article-mime
-  :type 'boolean)
-
-(defcustom gnus-show-mime-method 'metamail-buffer
-  "Function to process a MIME message.
-The function is called from the article buffer."
-  :group 'gnus-article-mime
-  :type 'function)
-
-(defcustom gnus-decode-encoded-word-method 'gnus-article-de-quoted-unreadable
-  "*Function to decode MIME encoded words.
-The function is called from the article buffer."
-  :group 'gnus-article-mime
-  :type 'function)
-
-(defcustom gnus-show-traditional-method
-  (if (and (featurep 'mule)
-           (boundp 'enable-multibyte-characters))
-      (lambda ()
-        (if enable-multibyte-characters (gnus-mule-decode-article)))
-    (lambda ()))
-  "Function to decode ``localized RFC 822 messages''.
-The function is called from the article buffer."
-  :group 'gnus-article-mime
-  :type 'function)
-
 (defcustom gnus-page-delimiter "^\^L"
   "*Regexp describing what to use as article page delimiters.
 The default value is \"^\^L\", which is a form linefeed at the
@@ -412,9 +418,14 @@ beginning of a line."
   :type 'regexp
   :group 'gnus-article-various)
 
-(defcustom gnus-article-mode-line-format "Gnus: %%b %S"
+(defcustom gnus-article-mode-line-format "Gnus: %g [%w] %S%m"
   "*The format specification for the article mode line.
-See `gnus-summary-mode-line-format' for a closer description."
+See `gnus-summary-mode-line-format' for a closer description.
+
+The following additional specs are available:
+
+%w  The article washing status.
+%m  The number of MIME parts in the article."
   :type 'string
   :group 'gnus-article-various)
 
@@ -429,8 +440,7 @@ See `gnus-summary-mode-line-format' for a closer description."
   :group 'gnus-article-various)
 
 (defcustom gnus-article-prepare-hook nil
-  "*A hook called after an article has been prepared in the article buffer.
-If you want to run a special decoding program like nkf, use this hook."
+  "*A hook called after an article has been prepared in the article buffer."
   :type 'hook
   :group 'gnus-article-various)
 
@@ -559,8 +569,413 @@ displayed by the first non-nil matching CONTENT face."
                                (item :tag "skip" nil)
                                (face :value default)))))
 
+(defcustom gnus-article-decode-hook
+  '(article-decode-charset article-decode-encoded-words)
+  "*Hook run to decode charsets in articles."
+  :group 'gnus-article-headers
+  :type 'hook)
+
+(defcustom gnus-display-mime-function 'gnus-display-mime
+  "Function to display MIME articles."
+  :group 'gnus-article-mime
+  :type 'function)
+
+(defvar gnus-decode-header-function 'mail-decode-encoded-word-region
+  "Function used to decode headers.")
+
+(defvar gnus-article-dumbquotes-map
+  '(("\202" ",")
+    ("\203" "f")
+    ("\204" ",,")
+    ("\205" "...")
+    ("\213" "<")
+    ("\214" "OE")
+    ("\221" "`")
+    ("\222" "'")
+    ("\223" "``")
+    ("\224" "\"")
+    ("\225" "*")
+    ("\226" "---")
+    ("\227" "-")
+    ("\231" "(TM)")
+    ("\233" ">")
+    ("\234" "oe")
+    ("\264" "'"))
+  "Table for MS-to-Latin1 translation.")
+
+(defcustom gnus-ignored-mime-types nil
+  "List of MIME types that should be ignored by Gnus."
+  :group 'gnus-article-mime
+  :type '(repeat regexp))
+
+(defcustom gnus-unbuttonized-mime-types '(".*/.*")
+  "List of MIME types that should not be given buttons when rendered inline."
+  :group 'gnus-article-mime
+  :type '(repeat regexp))
+
+(defcustom gnus-article-mime-part-function nil
+  "Function called with a MIME handle as the argument.
+This is meant for people who want to do something automatic based
+on parts -- for instance, adding Vcard info to a database."
+  :group 'gnus-article-mime
+  :type 'function)
+
+(defcustom gnus-mime-multipart-functions nil
+  "An alist of MIME types to functions to display them.")
+
+(defcustom gnus-article-date-lapsed-new-header nil
+  "Whether the X-Sent and Date headers can coexist.
+When using `gnus-treat-date-lapsed', the \"X-Sent:\" header will
+either replace the old \"Date:\" header (if this variable is nil), or
+be added below it (otherwise)."
+  :group 'gnus-article-headers
+  :type 'boolean)
+
+(defcustom gnus-article-mime-match-handle-function 'undisplayed-alternative
+  "Function called with a MIME handle as the argument.
+This is meant for people who want to view first matched part.
+For `undisplayed-alternative' (default), the first undisplayed 
+part or alternative part is used.  For `undisplayed', the first 
+undisplayed part is used.  For a function, the first part which 
+the function return `t' is used.  For `nil', the first part is
+used."
+  :group 'gnus-article-mime
+  :type '(choice 
+          (item :tag "first" :value nil)
+          (item :tag "undisplayed" :value undisplayed)
+          (item :tag "undisplayed or alternative" 
+                :value undisplayed-alternative)
+          (function)))
+
+;;;
+;;; The treatment variables
+;;;
+
+(defvar gnus-part-display-hook nil
+  "Hook called on parts that are to receive treatment.")
+
+(defvar gnus-article-treat-custom
+  '(choice (const :tag "Off" nil)
+           (const :tag "On" t)
+           (const :tag "Header" head)
+           (const :tag "Last" last)
+           (integer :tag "Less")
+           (repeat :tag "Groups" regexp)
+           (sexp :tag "Predicate")))
+
+(defvar gnus-article-treat-head-custom
+  '(choice (const :tag "Off" nil)
+           (const :tag "Header" head)))
+
+(defvar gnus-article-treat-types '("text/plain")
+  "Parts to treat.")
+
+(defvar gnus-inhibit-treatment nil
+  "Whether to inhibit treatment.")
+
+(defcustom gnus-treat-highlight-signature '(or last (typep "text/x-vcard"))
+  "Highlight the signature.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-custom)
+(put 'gnus-treat-highlight-signature 'highlight t)
+
+(defcustom gnus-treat-buttonize 100000
+  "Add buttons.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-custom)
+(put 'gnus-treat-buttonize 'highlight t)
+
+(defcustom gnus-treat-buttonize-head 'head
+  "Add buttons to the head.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-head-custom)
+(put 'gnus-treat-buttonize-head 'highlight t)
+
+(defcustom gnus-treat-emphasize 50000
+  "Emphasize text.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-custom)
+(put 'gnus-treat-emphasize 'highlight t)
+
+(defcustom gnus-treat-strip-cr nil
+  "Remove carriage returns.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-custom)
+
+(defcustom gnus-treat-hide-headers 'head
+  "Hide headers.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-head-custom)
+
+(defcustom gnus-treat-hide-boring-headers nil
+  "Hide boring headers.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-head-custom)
+
+(defcustom gnus-treat-hide-signature nil
+  "Hide the signature.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-custom)
+
+(defcustom gnus-treat-fill-article nil
+  "Fill the article.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-custom)
+
+(defcustom gnus-treat-hide-citation nil
+  "Hide cited text.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-custom)
+
+(defcustom gnus-treat-strip-list-identifiers 'head
+  "Strip list identifiers from `gnus-list-identifiers`.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-custom)
+
+(defcustom gnus-treat-strip-pgp t
+  "Strip PGP signatures.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-custom)
+
+(defcustom gnus-treat-strip-pem nil
+  "Strip PEM signatures.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-custom)
+
+(defcustom gnus-treat-strip-banner t
+  "Strip banners from articles.
+The banner to be stripped is specified in the `banner' group parameter.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-custom)
+
+(defcustom gnus-treat-highlight-headers 'head
+  "Highlight the headers.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-head-custom)
+(put 'gnus-treat-highlight-headers 'highlight t)
+
+(defcustom gnus-treat-highlight-citation t
+  "Highlight cited text.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-custom)
+(put 'gnus-treat-highlight-citation 'highlight t)
+
+(defcustom gnus-treat-date-ut nil
+  "Display the Date in UT (GMT).
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-head-custom)
+
+(defcustom gnus-treat-date-local nil
+  "Display the Date in the local timezone.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-head-custom)
+
+(defcustom gnus-treat-date-lapsed nil
+  "Display the Date header in a way that says how much time has elapsed.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-head-custom)
+
+(defcustom gnus-treat-date-original nil
+  "Display the date in the original timezone.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-head-custom)
+
+(defcustom gnus-treat-date-iso8601 nil
+  "Display the date in the ISO8601 format.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-head-custom)
+
+(defcustom gnus-treat-date-user-defined nil
+  "Display the date in a user-defined format.
+The format is defined by the `gnus-article-time-format' variable.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-head-custom)
+
+(defcustom gnus-treat-strip-headers-in-body t
+  "Strip the X-No-Archive header line from the beginning of the body.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-custom)
+
+(defcustom gnus-treat-strip-trailing-blank-lines nil
+  "Strip trailing blank lines.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-custom)
+
+(defcustom gnus-treat-strip-leading-blank-lines nil
+  "Strip leading blank lines.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-custom)
+
+(defcustom gnus-treat-strip-multiple-blank-lines nil
+  "Strip multiple blank lines.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-custom)
+
+(defcustom gnus-treat-overstrike t
+  "Treat overstrike highlighting.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-custom)
+(put 'gnus-treat-overstrike 'highlight t)
+
+(defcustom gnus-treat-display-xface 
+  (and (or (and (fboundp 'image-type-available-p)
+                (image-type-available-p 'xbm))
+           (and gnus-xemacs (featurep 'xface)))
+       'head)
+  "Display X-Face headers.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-head-custom)
+(put 'gnus-treat-display-xface 'highlight t)
+
+(defcustom gnus-treat-display-smileys (if (and gnus-xemacs
+                                               (featurep 'xpm))
+                                          t nil)
+  "Display smileys.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-custom)
+(put 'gnus-treat-display-smileys 'highlight t)
+
+(defcustom gnus-treat-display-picons (if gnus-xemacs 'head nil)
+  "Display picons.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-head-custom)
+(put 'gnus-treat-display-picons 'highlight t)
+
+(defcustom gnus-treat-capitalize-sentences nil
+  "Capitalize sentence-starting words.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-custom)
+
+(defcustom gnus-treat-fill-long-lines nil
+  "Fill long lines.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-custom)
+
+(defcustom gnus-treat-play-sounds nil
+  "Play sounds.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-custom)
+
+(defcustom gnus-treat-translate nil
+  "Translate articles from one language to another.
+Valid values are nil, t, `head', `last', an integer or a predicate.
+See the manual for details."
+  :group 'gnus-article-treat
+  :type gnus-article-treat-custom)
+
 ;;; Internal variables
 
+(defvar article-goto-body-goes-to-point-min-p nil)
+(defvar gnus-article-wash-types nil)
+(defvar gnus-article-emphasis-alist nil)
+
+(defvar gnus-article-mime-handle-alist-1 nil)
+(defvar gnus-treatment-function-alist
+  '((gnus-treat-strip-banner gnus-article-strip-banner)
+    (gnus-treat-strip-headers-in-body gnus-article-strip-headers-in-body)
+    (gnus-treat-highlight-signature gnus-article-highlight-signature)
+    (gnus-treat-buttonize gnus-article-add-buttons)
+    (gnus-treat-fill-article gnus-article-fill-cited-article)
+    (gnus-treat-fill-long-lines gnus-article-fill-long-lines)
+    (gnus-treat-strip-cr gnus-article-remove-cr)
+    (gnus-treat-emphasize gnus-article-emphasize)
+    (gnus-treat-display-xface gnus-article-display-x-face)
+    (gnus-treat-hide-headers gnus-article-maybe-hide-headers)
+    (gnus-treat-hide-boring-headers gnus-article-hide-boring-headers)
+    (gnus-treat-hide-signature gnus-article-hide-signature)
+    (gnus-treat-hide-citation gnus-article-hide-citation)
+    (gnus-treat-strip-list-identifiers gnus-article-hide-list-identifiers)
+    (gnus-treat-strip-pgp gnus-article-hide-pgp)
+    (gnus-treat-strip-pem gnus-article-hide-pem)
+    (gnus-treat-highlight-headers gnus-article-highlight-headers)
+    (gnus-treat-highlight-citation gnus-article-highlight-citation)
+    (gnus-treat-highlight-signature gnus-article-highlight-signature)
+    (gnus-treat-date-ut gnus-article-date-ut)
+    (gnus-treat-date-local gnus-article-date-local)
+    (gnus-treat-date-lapsed gnus-article-date-lapsed)
+    (gnus-treat-date-original gnus-article-date-original)
+    (gnus-treat-date-user-defined gnus-article-date-user)
+    (gnus-treat-date-iso8601 gnus-article-date-iso8601)
+    (gnus-treat-strip-trailing-blank-lines
+     gnus-article-remove-trailing-blank-lines)
+    (gnus-treat-strip-leading-blank-lines
+     gnus-article-strip-leading-blank-lines)
+    (gnus-treat-strip-multiple-blank-lines
+     gnus-article-strip-multiple-blank-lines)
+    (gnus-treat-overstrike gnus-article-treat-overstrike)
+    (gnus-treat-buttonize-head gnus-article-add-buttons-to-head)
+    (gnus-treat-display-smileys gnus-smiley-display)
+    (gnus-treat-capitalize-sentences gnus-article-capitalize-sentences)
+    (gnus-treat-display-picons gnus-article-display-picons)
+    (gnus-treat-play-sounds gnus-earcon-display)))
+
+(defvar gnus-article-mime-handle-alist nil)
 (defvar article-lapsed-timer nil)
 (defvar gnus-article-current-summary nil)
 
@@ -576,7 +991,8 @@ Initialized from `text-mode-syntax-table.")
 (defvar gnus-save-article-buffer nil)
 
 (defvar gnus-article-mode-line-format-alist
-  (nconc '((?w (gnus-article-wash-status) ?s))
+  (nconc '((?w (gnus-article-wash-status) ?s)
+           (?m (gnus-article-mime-part-status) ?s))
          gnus-summary-mode-line-format-alist))
 
 (defvar gnus-number-of-articles-to-be-saved nil)
@@ -590,7 +1006,6 @@ Initialized from `text-mode-syntax-table.")
     (put-text-property
      (max (1- b) (point-min))
      b 'intangible (cddr (memq 'intangible props)))))
-
 (defsubst gnus-article-unhide-text (b e)
   "Remove hidden text properties from region between B and E."
   (remove-text-properties b e gnus-hidden-properties)
@@ -600,11 +1015,14 @@ Initialized from `text-mode-syntax-table.")
 
 (defun gnus-article-hide-text-type (b e type)
   "Hide text of TYPE between B and E."
+  (push type gnus-article-wash-types)
   (gnus-article-hide-text
    b e (cons 'article-type (cons type gnus-hidden-properties))))
 
 (defun gnus-article-unhide-text-type (b e type)
   "Unhide text of TYPE between B and E."
+  (setq gnus-article-wash-types
+        (delq type gnus-article-wash-types))
   (remove-text-properties
    b e (cons 'article-type (cons type gnus-hidden-properties)))
   (when (memq 'intangible gnus-hidden-properties)
@@ -653,79 +1071,60 @@ Initialized from `text-mode-syntax-table.")
     i))
 
 (defun article-hide-headers (&optional arg delete)
-  "Toggle whether to hide unwanted headers and possibly sort them as well.
-If given a negative prefix, always show; if given a positive prefix,
-always hide."
-  (interactive (gnus-article-hidden-arg))
-  (current-buffer)
-  (if (gnus-article-check-hidden-text 'headers arg)
-      ;; Show boring headers as well.
-      (gnus-article-show-hidden-text 'boring-headers)
-    ;; This function might be inhibited.
-    (unless gnus-inhibit-hiding
-      (save-excursion
-        (save-restriction
-          (let ((buffer-read-only nil)
-                (case-fold-search t)
-                (props (nconc (list 'article-type 'headers)
-                              gnus-hidden-properties))
-                (max (1+ (length gnus-sorted-header-list)))
-                (ignored (when (not gnus-visible-headers)
-                           (cond ((stringp gnus-ignored-headers)
-                                  gnus-ignored-headers)
-                                 ((listp gnus-ignored-headers)
-                                  (mapconcat 'identity gnus-ignored-headers
-                                             "\\|")))))
-                (visible
-                 (cond ((stringp gnus-visible-headers)
-                        gnus-visible-headers)
-                       ((and gnus-visible-headers
-                             (listp gnus-visible-headers))
-                        (mapconcat 'identity gnus-visible-headers "\\|"))))
-                (inhibit-point-motion-hooks t)
-                beg)
-            ;; First we narrow to just the headers.
-            (widen)
-            (goto-char (point-min))
-            ;; Hide any "From " lines at the beginning of (mail) articles.
-            (while (looking-at "From ")
-              (forward-line 1))
-            (unless (bobp)
-              (if delete
-                  (delete-region (point-min) (point))
-                (gnus-article-hide-text (point-min) (point) props)))
-            ;; Then treat the rest of the header lines.
-            (narrow-to-region
-             (point)
-             (if (search-forward "\n\n" nil t) ; if there's a body
-                 (progn (forward-line -1) (point))
-               (point-max)))
-            ;; Then we use the two regular expressions
-            ;; `gnus-ignored-headers' and `gnus-visible-headers' to
-            ;; select which header lines is to remain visible in the
-            ;; article buffer.
-            (goto-char (point-min))
-            (while (re-search-forward "^[^ \t]*:" nil t)
-              (beginning-of-line)
-              ;; Mark the rank of the header.
-              (put-text-property
-               (point) (1+ (point)) 'message-rank
-               (if (or (and visible (looking-at visible))
-                       (and ignored
-                            (not (looking-at ignored))))
-                   (gnus-article-header-rank)
-                 (+ 2 max)))
-              (forward-line 1))
-            (message-sort-headers-1)
-            (when (setq beg (text-property-any
-                             (point-min) (point-max) 'message-rank (+ 2 max)))
-              ;; We make the unwanted headers invisible.
-              (if delete
-                  (delete-region beg (point-max))
-                ;; Suggested by Sudish Joseph <joseph@cis.ohio-state.edu>.
-                (gnus-article-hide-text-type beg (point-max) 'headers))
-              ;; Work around XEmacs lossage.
-              (put-text-property (point-min) beg 'invisible nil))))))))
+  "Hide unwanted headers and possibly sort them as well."
+  (interactive)
+  ;; This function might be inhibited.
+  (unless gnus-inhibit-hiding
+    (save-excursion
+      (save-restriction
+        (let ((buffer-read-only nil)
+              (case-fold-search t)
+              (max (1+ (length gnus-sorted-header-list)))
+              (ignored (when (not gnus-visible-headers)
+                         (cond ((stringp gnus-ignored-headers)
+                                gnus-ignored-headers)
+                               ((listp gnus-ignored-headers)
+                                (mapconcat 'identity gnus-ignored-headers
+                                           "\\|")))))
+              (visible
+               (cond ((stringp gnus-visible-headers)
+                      gnus-visible-headers)
+                     ((and gnus-visible-headers
+                           (listp gnus-visible-headers))
+                      (mapconcat 'identity gnus-visible-headers "\\|"))))
+              (inhibit-point-motion-hooks t)
+              beg)
+          ;; First we narrow to just the headers.
+          (article-narrow-to-head)
+          ;; Hide any "From " lines at the beginning of (mail) articles.
+          (while (looking-at "From ")
+            (forward-line 1))
+          (unless (bobp)
+            (delete-region (point-min) (point)))
+          ;; Then treat the rest of the header lines.
+          ;; Then we use the two regular expressions
+          ;; `gnus-ignored-headers' and `gnus-visible-headers' to
+          ;; select which header lines is to remain visible in the
+          ;; article buffer.
+          (while (re-search-forward "^[^ \t]*:" nil t)
+            (beginning-of-line)
+            ;; Mark the rank of the header.
+            (put-text-property
+             (point) (1+ (point)) 'message-rank
+             (if (or (and visible (looking-at visible))
+                     (and ignored
+                          (not (looking-at ignored))))
+                 (gnus-article-header-rank)
+               (+ 2 max)))
+            (forward-line 1))
+          (message-sort-headers-1)
+          (when (setq beg (text-property-any
+                           (point-min) (point-max) 'message-rank (+ 2 max)))
+            ;; We delete the unwanted headers.
+            (push 'headers gnus-article-wash-types)
+            (add-text-properties (point-min) (+ 5 (point-min))
+                                 '(article-type headers dummy-invisible t))
+            (delete-region beg (point-max))))))))
 
 (defun article-hide-boring-headers (&optional arg)
   "Toggle hiding of headers that aren't very interesting.
@@ -740,14 +1139,14 @@ always hide."
               (list gnus-boring-article-headers)
               (inhibit-point-motion-hooks t)
               elem)
-          (nnheader-narrow-to-headers)
+          (article-narrow-to-head)
           (while list
             (setq elem (pop list))
             (goto-char (point-min))
             (cond
              ;; Hide empty headers.
              ((eq elem 'empty)
-              (while (re-search-forward "^[^:]+:[ \t]*\n[^ \t]" nil t)
+              (while (re-search-forward "^[^: \t]+:[ \t]*\n[^ \t]" nil t)
                 (forward-line -1)
                 (gnus-article-hide-text-type
                  (progn (beginning-of-line) (point))
@@ -782,15 +1181,19 @@ always hide."
              ((eq elem 'date)
               (let ((date (message-fetch-field "date")))
                 (when (and date
-                           (< (gnus-days-between (current-time-string) date)
+                           (< (days-between (current-time-string) date)
                               4))
                   (gnus-article-hide-header "date"))))
              ((eq elem 'long-to)
-              (let ((to (message-fetch-field "to")))
+              (let ((to (message-fetch-field "to"))
+                    (cc (message-fetch-field "cc")))
                 (when (> (length to) 1024)
-                  (gnus-article-hide-header "to"))))
+                  (gnus-article-hide-header "to"))
+                (when (> (length cc) 1024)
+                  (gnus-article-hide-header "cc"))))
              ((eq elem 'many-to)
-              (let ((to-count 0))
+              (let ((to-count 0)
+                    (cc-count 0))
                 (goto-char (point-min))
                 (while (re-search-forward "^to:" nil t)
                   (setq to-count (1+ to-count)))
@@ -802,7 +1205,19 @@ always hide."
                       (forward-line -1)
                       (narrow-to-region (point) (point-max))
                       (gnus-article-hide-header "to"))
-                    (setq to-count (1- to-count)))))))))))))
+                    (setq to-count (1- to-count))))
+                (goto-char (point-min))
+                (while (re-search-forward "^cc:" nil t)
+                  (setq cc-count (1+ cc-count)))
+                (when (> cc-count 1)
+                  (while (> cc-count 0)
+                    (goto-char (point-min))
+                    (save-restriction
+                      (re-search-forward "^cc:" nil nil cc-count)
+                      (forward-line -1)
+                      (narrow-to-region (point) (point-max))
+                      (gnus-article-hide-header "cc"))
+                    (setq cc-count (1- cc-count)))))))))))))
 
 (defun gnus-article-hide-header (header)
   (save-excursion
@@ -817,18 +1232,50 @@ always hide."
            (point-max)))
        'boring-headers))))
 
+(defvar gnus-article-normalized-header-length 40
+  "Length of normalized headers.")
+
+(defun article-normalize-headers ()
+  "Make all header lines 40 characters long."
+  (interactive)
+  (let ((buffer-read-only nil)
+        column)
+    (save-excursion
+      (save-restriction
+        (article-narrow-to-head)
+        (while (not (eobp))
+          (cond
+           ((< (setq column (- (gnus-point-at-eol) (point)))
+               gnus-article-normalized-header-length)
+            (end-of-line)
+            (insert (make-string
+                     (- gnus-article-normalized-header-length column)
+                     ? )))
+           ((> column gnus-article-normalized-header-length)
+            (gnus-put-text-property
+             (progn
+               (forward-char gnus-article-normalized-header-length)
+               (point))
+             (gnus-point-at-eol)
+             'invisible t))
+           (t
+            ;; Do nothing.
+            ))
+          (forward-line 1))))))
+
 (defun article-treat-dumbquotes ()
-  "Translate M******** sm*rtq**t*s into proper text."
+  "Translate M******** sm*rtq**t*s into proper text.
+Note that this function guesses whether a character is a sm*rtq**t* or
+not, so it should only be used interactively."
   (interactive)
-  (article-translate-characters "\221\222\223\223" "`'\"\""))
+  (article-translate-strings gnus-article-dumbquotes-map))
 
 (defun article-translate-characters (from to)
   "Translate all characters in the body of the article according to FROM and TO.
 FROM is a string of characters to translate from; to is a string of
 characters to translate to."
   (save-excursion
-    (goto-char (point-min))
-    (when (search-forward "\n\n" nil t)
+    (when (article-goto-body)
       (let ((buffer-read-only nil)
             (x (make-string 225 ?x))
             (i -1))
@@ -840,15 +1287,26 @@ characters to translate to."
           (incf i))
         (translate-region (point) (point-max) x)))))
 
+(defun article-translate-strings (map)
+  "Translate all string in the body of the article according to MAP.
+MAP is an alist where the elements are on the form (\"from\" \"to\")."
+  (save-excursion
+    (when (article-goto-body)
+      (let ((buffer-read-only nil)
+            elem)
+        (while (setq elem (pop map))
+          (save-excursion
+            (while (search-forward (car elem) nil t)
+              (replace-match (cadr elem)))))))))
+
 (defun article-treat-overstrike ()
   "Translate overstrikes into bold text."
   (interactive)
   (save-excursion
-    (goto-char (point-min))
-    (when (search-forward "\n\n" nil t)
+    (when (article-goto-body)
       (let ((buffer-read-only nil))
         (while (search-forward "\b" nil t)
-          (let ((next (following-char))
+          (let ((next (char-after))
                 (previous (char-after (- (point) 2))))
             ;; We do the boldification/underlining by hiding the
             ;; overstrikes and putting the proper text property
@@ -867,32 +1325,46 @@ characters to translate to."
               (put-text-property
                (point) (1+ (point)) 'face 'underline)))))))))
 
-(defun article-fill ()
-  "Format too long lines."
+(defun article-fill-long-lines ()
+  "Fill lines that are wider than the window width."
   (interactive)
   (save-excursion
-    (let ((buffer-read-only nil))
-      (widen)
-      (goto-char (point-min))
-      (search-forward "\n\n" nil t)
-      (end-of-line 1)
-      (let ((paragraph-start "^[>|#:<;* ]*[ \t]*$")
-            (adaptive-fill-regexp "[ \t]*\\([|#:<;>*]+ *\\)?")
-            (adaptive-fill-mode t))
-        (while (not (eobp))
-          (and (>= (current-column) (min fill-column (window-width)))
-               (/= (preceding-char) ?:)
-               (fill-paragraph nil))
-          (end-of-line 2))))))
+    (let ((buffer-read-only nil)
+          (width (window-width (get-buffer-window (current-buffer)))))
+      (save-restriction
+        (article-goto-body)
+        (let ((adaptive-fill-mode nil))
+          (while (not (eobp))
+            (end-of-line)
+            (when (>= (current-column) (min fill-column width))
+              (narrow-to-region (point) (gnus-point-at-bol))
+              (fill-paragraph nil)
+              (goto-char (point-max))
+              (widen))
+            (forward-line 1)))))))
+
+(defun article-capitalize-sentences ()
+  "Capitalize the first word in each sentence."
+  (interactive)
+  (save-excursion
+    (let ((buffer-read-only nil)
+          (paragraph-start "^[\n\^L]"))
+      (article-goto-body)
+      (while (not (eobp))
+        (capitalize-word 1)
+        (forward-sentence)))))
 
 (defun article-remove-cr ()
-  "Remove carriage returns from an article."
+  "Remove trailing CRs and then translate remaining CRs into LFs."
   (interactive)
   (save-excursion
     (let ((buffer-read-only nil))
       (goto-char (point-min))
+      (while (re-search-forward "\r+$" nil t)
+        (replace-match "" t t))
+      (goto-char (point-min))
       (while (search-forward "\r" nil t)
-        (replace-match "" t t)))))
+        (replace-match "\n" t t)))))
 
 (defun article-remove-trailing-blank-lines ()
   "Remove all trailing blank lines from the article."
@@ -904,7 +1376,9 @@ characters to translate to."
        (point)
        (progn
          (while (and (not (bobp))
-                     (looking-at "^[ \t]*$"))
+                     (looking-at "^[ \t]*$")
+                     (not (gnus-annotation-in-region-p
+                           (point) (gnus-point-at-eol))))
            (forward-line -1))
          (forward-line 1)
          (point))))))
@@ -920,7 +1394,8 @@ characters to translate to."
           (case-fold-search t)
           from last)
       (save-restriction
-        (nnheader-narrow-to-headers)
+        (article-narrow-to-head)
+        (goto-char (point-min))
         (setq from (message-fetch-field "from"))
         (goto-char (point-min))
         (while (and gnus-article-x-face-command
@@ -959,99 +1434,212 @@ characters to translate to."
                   (process-send-region "article-x-face" beg end)
                   (process-send-eof "article-x-face"))))))))))
 
-(defun gnus-hack-decode-rfc1522 ()
-  "Emergency hack function for avoiding problems when decoding."
-  (let ((buffer-read-only nil))
-    (goto-char (point-min))
-    ;; Remove encoded TABs.
-    (while (search-forward "=09" nil t)
-      (replace-match " " t t))
-    ;; Remove encoded newlines.
-    (goto-char (point-min))
-    (while (search-forward "=10" nil t)
-      (replace-match " " t t))))
-
-(defalias 'gnus-decode-rfc1522 'article-decode-rfc1522)
-(defalias 'gnus-article-decode-rfc1522 'article-decode-rfc1522)
-(defun article-decode-rfc1522 ()
-  "Hack to remove QP encoding from headers."
-  (let ((case-fold-search t)
-        (inhibit-point-motion-hooks t)
-        (buffer-read-only nil)
-        string)
+(defun article-decode-mime-words ()
+  "Decode all MIME-encoded words in the article."
+  (interactive)
+  (save-excursion
+    (set-buffer gnus-article-buffer)
+    (let ((inhibit-point-motion-hooks t)
+          buffer-read-only
+          (mail-parse-charset gnus-newsgroup-charset)
+          (mail-parse-ignored-charsets 
+           (save-excursion (set-buffer gnus-summary-buffer)
+                           gnus-newsgroup-ignored-charsets)))
+      (mail-decode-encoded-word-region (point-min) (point-max)))))
+
+(defun article-decode-charset (&optional prompt)
+  "Decode charset-encoded text in the article.
+If PROMPT (the prefix), prompt for a coding system to use."
+  (interactive "P")
+  (let ((inhibit-point-motion-hooks t) (case-fold-search t)
+        buffer-read-only
+        (mail-parse-charset gnus-newsgroup-charset)
+        (mail-parse-ignored-charsets 
+         (save-excursion (condition-case nil
+                             (set-buffer gnus-summary-buffer)
+                           (error))
+                         gnus-newsgroup-ignored-charsets))
+        ct cte ctl charset format)
+  (save-excursion
     (save-restriction
-      (narrow-to-region
-       (goto-char (point-min))
-       (or (search-forward "\n\n" nil t) (point-max)))
-      (goto-char (point-min))
-      (while (re-search-forward
-              "=\\?iso-8859-1\\?q\\?\\([^?\t\n]*\\)\\?=" nil t)
-        (setq string (match-string 1))
-        (save-restriction
-          (narrow-to-region (match-beginning 0) (match-end 0))
-          (delete-region (point-min) (point-max))
-          (insert string)
-          (article-mime-decode-quoted-printable
-           (goto-char (point-min)) (point-max))
-          (subst-char-in-region (point-min) (point-max) ?_ ? )
-          (goto-char (point-max)))
-        (goto-char (point-min))))))
+      (article-narrow-to-head)
+      (setq ct (message-fetch-field "Content-Type" t)
+            cte (message-fetch-field "Content-Transfer-Encoding" t)
+            ctl (and ct (ignore-errors
+                          (mail-header-parse-content-type ct)))
+            charset (cond
+                     (prompt
+                      (mm-read-coding-system "Charset to decode: "))
+                     (ctl
+                      (mail-content-type-get ctl 'charset)))
+            format (and ctl (mail-content-type-get ctl 'format)))
+      (when cte
+        (setq cte (mail-header-strip cte)))
+      (if (and ctl (not (string-match "/" (car ctl)))) 
+          (setq ctl nil))
+      (goto-char (point-max)))
+    (forward-line 1)
+    (save-restriction
+      (narrow-to-region (point) (point-max))
+      (when (and (eq mail-parse-charset 'gnus-decoded)
+                 (eq (mm-body-7-or-8) '8bit))
+        ;; The text code could have been decoded.
+        (setq charset mail-parse-charset))
+      (when (and (or (not ctl)
+                     (equal (car ctl) "text/plain"))
+                 (not format)) ;; article with format will decode later.
+        (mm-decode-body
+         charset (and cte (intern (downcase
+                                   (gnus-strip-whitespace cte))))
+         (car ctl)))))))
+
+(defun article-decode-encoded-words ()
+  "Remove encoded-word encoding from headers."
+  (let ((inhibit-point-motion-hooks t)
+        (mail-parse-charset gnus-newsgroup-charset)
+        (mail-parse-ignored-charsets 
+         (save-excursion (condition-case nil
+                             (set-buffer gnus-summary-buffer)
+                           (error))
+                         gnus-newsgroup-ignored-charsets))
+        buffer-read-only)
+    (save-restriction
+      (article-narrow-to-head)
+      (funcall gnus-decode-header-function (point-min) (point-max)))))
 
 (defun article-de-quoted-unreadable (&optional force)
-  "Do a naive translation of a quoted-printable-encoded article.
-This is in no way, shape or form meant as a replacement for real MIME
-processing, but is simply a stop-gap measure until MIME support is
-written.
+  "Translate a quoted-printable-encoded article.
 If FORCE, decode the article whether it is marked as quoted-printable
 or not."
   (interactive (list 'force))
   (save-excursion
-    (let ((case-fold-search t)
-          (buffer-read-only nil)
-          (type (gnus-fetch-field "content-transfer-encoding")))
-      (gnus-article-decode-rfc1522)
+    (let ((buffer-read-only nil) type charset)
+      (if (gnus-buffer-live-p gnus-original-article-buffer)
+          (with-current-buffer gnus-original-article-buffer
+            (setq type
+                  (gnus-fetch-field "content-transfer-encoding"))
+            (let* ((ct (gnus-fetch-field "content-type"))
+                   (ctl (and ct 
+                             (ignore-errors
+                               (mail-header-parse-content-type ct)))))
+              (setq charset (and ctl
+                                 (mail-content-type-get ctl 'charset)))
+              (if (stringp charset)
+                  (setq charset (intern (downcase charset)))))))
+      (unless charset 
+        (setq charset gnus-newsgroup-charset))
       (when (or force
                 (and type (string-match "quoted-printable" (downcase type))))
-        (goto-char (point-min))
-        (search-forward "\n\n" nil 'move)
-        (article-mime-decode-quoted-printable (point) (point-max))))))
-
-(defun article-mime-decode-quoted-printable-buffer ()
-  "Decode Quoted-Printable in the current buffer."
-  (article-mime-decode-quoted-printable (point-min) (point-max)))
-
-(defun article-mime-decode-quoted-printable (from to)
-  "Decode Quoted-Printable in the region between FROM and TO."
-  (interactive "r")
-  (goto-char from)
-  (while (search-forward "=" to t)
-    (cond ((eq (following-char) ?\n)
-           (delete-char -1)
-           (delete-char 1))
-          ((looking-at "[0-9A-F][0-9A-F]")
-           (subst-char-in-region
-            (1- (point)) (point) ?=
-            (hexl-hex-string-to-integer
-             (buffer-substring (point) (+ 2 (point)))))
-           (delete-char 2))
-          ((looking-at "=")
-           (delete-char 1))
-          ((gnus-message 3 "Malformed MIME quoted-printable message")))))
-
-(defun article-hide-pgp (&optional arg)
-  "Toggle hiding of any PGP headers and signatures in the current article.
-If given a negative prefix, always show; if given a positive prefix,
-always hide."
-  (interactive (gnus-article-hidden-arg))
-  (unless (gnus-article-check-hidden-text 'pgp arg)
-    (save-excursion
+        (article-goto-body)
+        (quoted-printable-decode-region (point) (point-max) charset)))))
+
+(defun article-de-base64-unreadable (&optional force)
+  "Translate a base64 article.
+If FORCE, decode the article whether it is marked as base64 not."
+  (interactive (list 'force))
+  (save-excursion
+    (let ((buffer-read-only nil) type charset)
+      (if (gnus-buffer-live-p gnus-original-article-buffer)
+          (with-current-buffer gnus-original-article-buffer
+            (setq type
+                  (gnus-fetch-field "content-transfer-encoding"))
+            (let* ((ct (gnus-fetch-field "content-type"))
+                   (ctl (and ct 
+                             (ignore-errors
+                               (mail-header-parse-content-type ct)))))
+              (setq charset (and ctl
+                                 (mail-content-type-get ctl 'charset)))
+              (if (stringp charset)
+                  (setq charset (intern (downcase charset)))))))
+      (unless charset 
+        (setq charset gnus-newsgroup-charset))
+      (when (or force
+                (and type (string-match "base64" (downcase type))))
+        (article-goto-body)
+        (save-restriction
+          (narrow-to-region (point) (point-max))
+          (base64-decode-region (point-min) (point-max))
+          (if (mm-coding-system-p charset)
+              (mm-decode-coding-region (point-min) (point-max) charset)))))))
+
+(eval-when-compile
+  (require 'rfc1843))
+
+(defun article-decode-HZ ()
+  "Translate a HZ-encoded article."
+  (interactive)
+  (require 'rfc1843)
+  (save-excursion
+    (let ((buffer-read-only nil))
+      (rfc1843-decode-region (point-min) (point-max)))))
+
+(defun article-wash-html ()
+  "Format an html article."
+  (interactive)
+  (save-excursion
+    (let ((buffer-read-only nil)
+          charset)
+      (if (gnus-buffer-live-p gnus-original-article-buffer)
+          (with-current-buffer gnus-original-article-buffer
+            (let* ((ct (gnus-fetch-field "content-type"))
+                   (ctl (and ct 
+                             (ignore-errors
+                               (mail-header-parse-content-type ct)))))
+              (setq charset (and ctl
+                                 (mail-content-type-get ctl 'charset)))
+              (if (stringp charset)
+                  (setq charset (intern (downcase charset)))))))
+      (unless charset 
+        (setq charset gnus-newsgroup-charset))
+      (article-goto-body)
+      (save-window-excursion
+        (save-restriction
+          (narrow-to-region (point) (point-max))
+          (mm-setup-w3)
+          (let ((w3-strict-width (window-width))
+                (url-standalone-mode t))
+            (condition-case var
+                (w3-region (point-min) (point-max))
+              (error))))))))
+
+(defun article-hide-list-identifiers ()
+  "Remove list identifies from the Subject header.
+The `gnus-list-identifiers' variable specifies what to do."
+  (interactive)
+  (save-excursion
+    (save-restriction
+      (let ((inhibit-point-motion-hooks t)
+            buffer-read-only)
+        (article-narrow-to-head)
+        (let ((regexp (if (stringp gnus-list-identifiers) gnus-list-identifiers
+                        (mapconcat 'identity gnus-list-identifiers " *\\|"))))
+          (when regexp
+            (goto-char (point-min))
+            (when (re-search-forward
+                   (concat "^Subject: +\\(\\(\\(Re: +\\)?\\(" regexp 
+                           " *\\)\\)+\\(Re: +\\)?\\)")
+                   nil t)
+              (let ((s (or (match-string 3) (match-string 5))))
+                (delete-region (match-beginning 1) (match-end 1))
+                (when s
+                  (goto-char (match-beginning 1))
+                  (insert s))))))))))
+
+(defun article-hide-pgp ()
+  "Remove any PGP headers and signatures in the current article."
+  (interactive)
+  (save-excursion
+    (save-restriction
       (let ((inhibit-point-motion-hooks t)
             buffer-read-only beg end)
-        (widen)
-        (goto-char (point-min))
+        (article-goto-body)
         ;; Hide the "header".
-        (when (search-forward "\n-----BEGIN PGP SIGNED MESSAGE-----\n" nil t)
-          (delete-region (1+ (match-beginning 0)) (match-end 0))
+        (when (re-search-forward "^-----BEGIN PGP SIGNED MESSAGE-----\n" nil t)
+          (push 'pgp gnus-article-wash-types)
+          (delete-region (match-beginning 0) (match-end 0))
+          ;; Remove armor headers (rfc2440 6.2)
+          (delete-region (point) (or (re-search-forward "^[ \t]*\n" nil t)
+                                     (point)))
           (setq beg (point))
           ;; Hide the actual signature.
           (and (search-forward "\n-----BEGIN PGP SIGNATURE-----\n" nil t)
@@ -1081,25 +1669,62 @@ always hide."
   (unless (gnus-article-check-hidden-text 'pem arg)
     (save-excursion
       (let (buffer-read-only end)
-        (widen)
         (goto-char (point-min))
-        ;; hide the horrendously ugly "header".
-        (and (search-forward "\n-----BEGIN PRIVACY-ENHANCED MESSAGE-----\n"
-                             nil
-                             t)
-             (setq end (1+ (match-beginning 0)))
-             (gnus-article-hide-text-type
-              end
-              (if (search-forward "\n\n" nil t)
-                  (match-end 0)
-                (point-max))
-              'pem))
-        ;; hide the trailer as well
-        (and (search-forward "\n-----END PRIVACY-ENHANCED MESSAGE-----\n"
-                             nil
-                             t)
-             (gnus-article-hide-text-type
-              (match-beginning 0) (match-end 0) 'pem))))))
+        ;; Hide the horrendously ugly "header".
+        (when (and (search-forward
+                    "\n-----BEGIN PRIVACY-ENHANCED MESSAGE-----\n"
+                    nil t)
+                   (setq end (1+ (match-beginning 0))))
+          (push 'pem gnus-article-wash-types)
+          (gnus-article-hide-text-type
+           end
+           (if (search-forward "\n\n" nil t)
+               (match-end 0)
+             (point-max))
+           'pem)
+          ;; Hide the trailer as well
+          (when (search-forward "\n-----END PRIVACY-ENHANCED MESSAGE-----\n"
+                                nil t)
+            (gnus-article-hide-text-type
+             (match-beginning 0) (match-end 0) 'pem)))))))
+
+(defun article-strip-banner ()
+  "Strip the banner specified by the `banner' group parameter."
+  (interactive)
+  (save-excursion
+    (save-restriction
+      (let ((inhibit-point-motion-hooks t)
+            (banner (gnus-group-get-parameter gnus-newsgroup-name 'banner))
+            (gnus-signature-limit nil)
+            buffer-read-only beg end)
+        (when banner
+          (article-goto-body)
+          (cond
+           ((eq banner 'signature)
+            (when (gnus-article-narrow-to-signature)
+              (widen)
+              (forward-line -1)
+              (delete-region (point) (point-max))))
+           ((stringp banner)
+            (while (re-search-forward banner nil t)
+              (delete-region (match-beginning 0) (match-end 0))))))))))
+
+(defun article-babel ()
+  "Translate article using an online translation service."
+  (interactive)
+  (require 'babel)
+  (save-excursion
+    (set-buffer gnus-article-buffer)
+    (when (article-goto-body)
+      (let* ((buffer-read-only nil)
+             (start (point))
+             (end (point-max))
+             (orig (buffer-substring start end))
+             (trans (babel-as-string orig)))
+        (save-restriction
+          (narrow-to-region start end)
+          (delete-region start end)
+          (insert trans))))))
 
 (defun article-hide-signature (&optional arg)
   "Hide the signature in the current article.
@@ -1114,18 +1739,50 @@ always hide."
             (gnus-article-hide-text-type
              (point-min) (point-max) 'signature)))))))
 
+(defun article-strip-headers-in-body ()
+  "Strip offensive headers from bodies."
+  (interactive)
+  (save-excursion
+    (article-goto-body)
+    (let ((case-fold-search t))
+      (when (looking-at "x-no-archive:")
+        (gnus-delete-line)))))
+
 (defun article-strip-leading-blank-lines ()
   "Remove all blank lines from the beginning of the article."
   (interactive)
   (save-excursion
     (let ((inhibit-point-motion-hooks t)
           buffer-read-only)
-      (goto-char (point-min))
-      (when (search-forward "\n\n" nil t)
+      (when (article-goto-body)
         (while (and (not (eobp))
                     (looking-at "[ \t]*$"))
           (gnus-delete-line))))))
 
+(defun article-narrow-to-head ()
+  "Narrow the buffer to the head of the message.
+Point is left at the beginning of the narrowed-to region."
+  (narrow-to-region
+   (goto-char (point-min))
+   (if (search-forward "\n\n" nil 1)
+       (1- (point))
+     (point-max)))
+  (goto-char (point-min)))
+
+(defun article-goto-body ()
+  "Place point at the start of the body."
+  (goto-char (point-min))
+  (cond
+   ;; This variable is only bound when dealing with separate
+   ;; MIME body parts.
+   (article-goto-body-goes-to-point-min-p
+    t)
+   ((search-forward "\n\n" nil t)
+    t)
+   (t
+    (goto-char (point-max))
+    nil)))
+
 (defun article-strip-multiple-blank-lines ()
   "Replace consecutive blank lines with one empty line."
   (interactive)
@@ -1133,15 +1790,17 @@ always hide."
     (let ((inhibit-point-motion-hooks t)
           buffer-read-only)
       ;; First make all blank lines empty.
-      (goto-char (point-min))
-      (search-forward "\n\n" nil t)
+      (article-goto-body)
       (while (re-search-forward "^[ \t]+$" nil t)
-        (replace-match "" nil t))
+        (unless (gnus-annotation-in-region-p
+                 (match-beginning 0) (match-end 0))
+          (replace-match "" nil t)))
       ;; Then replace multiple empty lines with a single empty line.
-      (goto-char (point-min))
-      (search-forward "\n\n" nil t)
+      (article-goto-body)
       (while (re-search-forward "\n\n\n+" nil t)
-        (replace-match "\n\n" t t)))))
+        (unless (gnus-annotation-in-region-p
+                 (match-beginning 0) (match-end 0))
+          (replace-match "\n\n" t t))))))
 
 (defun article-strip-leading-space ()
   "Remove all white space from the beginning of the lines in the article."
@@ -1149,11 +1808,20 @@ always hide."
   (save-excursion
     (let ((inhibit-point-motion-hooks t)
           buffer-read-only)
-      (goto-char (point-min))
-      (search-forward "\n\n" nil t)
+      (article-goto-body)
       (while (re-search-forward "^[ \t]+" nil t)
         (replace-match "" t t)))))
 
+(defun article-strip-trailing-space ()
+  "Remove all white space from the end of the lines in the article."
+  (interactive)
+  (save-excursion
+    (let ((inhibit-point-motion-hooks t)
+          buffer-read-only)
+      (article-goto-body)
+      (while (re-search-forward "[ \t]+$" nil t)
+        (replace-match "" t t)))))
+
 (defun article-strip-blank-lines ()
   "Strip leading, trailing and multiple blank lines."
   (interactive)
@@ -1167,26 +1835,13 @@ always hide."
   (save-excursion
     (let ((inhibit-point-motion-hooks t)
           buffer-read-only)
-      (goto-char (point-min))
-      (search-forward "\n\n" nil t)
+      (article-goto-body)
       (while (re-search-forward "^[ \t]*\n" nil t)
         (replace-match "" t t)))))
 
-(defvar mime::preview/content-list)
-(defvar mime::preview-content-info/point-min)
 (defun gnus-article-narrow-to-signature ()
   "Narrow to the signature; return t if a signature is found, else nil."
-  (widen)
   (let ((inhibit-point-motion-hooks t))
-    (when (and (boundp 'mime::preview/content-list)
-               mime::preview/content-list)
-      ;; We have a MIMEish article, so we use the MIME data to narrow.
-      (let ((pcinfo (car (last mime::preview/content-list))))
-        (ignore-errors
-          (narrow-to-region
-           (funcall (intern "mime::preview-content-info/point-min") pcinfo)
-           (point-max)))))
-
     (when (gnus-article-search-signature)
       (forward-line 1)
       ;; Check whether we have some limits to what we consider
@@ -1226,38 +1881,6 @@ Put point at the beginning of the signature separator."
       (goto-char cur)
       nil)))
 
-(eval-and-compile
-  (autoload 'w3-display "w3-parse")
-  (autoload 'w3-do-setup "w3" "" t)
-  (autoload 'w3-region "w3-display" "" t))
-
-(defun gnus-article-treat-html ()
-  "Render HTML."
-  (interactive)
-  (let ((cbuf (current-buffer)))
-    (set-buffer gnus-article-buffer)
-    (let (buf buffer-read-only b e)
-      (w3-do-setup)
-      (goto-char (point-min))
-      (narrow-to-region
-       (if (search-forward "\n\n" nil t)
-           (setq b (point))
-         (point-max))
-       (setq e (point-max)))
-      (nnheader-temp-write nil
-        (insert-buffer-substring gnus-article-buffer b e)
-        (require 'url)
-        (save-window-excursion
-          (w3-region (point-min) (point-max))
-          (setq buf (buffer-substring-no-properties (point-min) (point-max)))))
-      (when buf
-        (delete-region (point-min) (point-max))
-        (insert buf))
-      (widen)
-      (goto-char (point-min))
-      (set-window-start (get-buffer-window (current-buffer)) (point-min))
-      (set-buffer cbuf))))
-
 (defun gnus-article-hidden-arg ()
   "Return the current prefix arg as a number, or 0 if no prefix."
   (list (if current-prefix-arg
@@ -1270,7 +1893,6 @@ Arg can be nil or a number.  Nil and positive means hide, negative
 means show, 0 means toggle."
   (save-excursion
     (save-restriction
-      (widen)
       (let ((hide (gnus-article-hidden-text-p type)))
         (cond
          ((or (null arg)
@@ -1287,12 +1909,13 @@ means show, 0 means toggle."
   "Say whether the current buffer contains hidden text of type TYPE."
   (let ((pos (text-property-any (point-min) (point-max) 'article-type type)))
     (while (and pos
-                (not (get-text-property pos 'invisible)))
+                (not (get-text-property pos 'invisible))
+                (not (get-text-property pos 'dummy-invisible)))
       (setq pos
             (text-property-any (1+ pos) (point-max) 'article-type type)))
     (if pos
         'hidden
-      'shown)))
+      nil)))
 
 (defun gnus-article-show-hidden-text (type &optional hide)
   "Show all hidden text of type TYPE.
@@ -1325,144 +1948,158 @@ If HIDE, hide the text instead."
 (defun article-date-ut (&optional type highlight header)
   "Convert DATE date to universal time in the current article.
 If TYPE is `local', convert to local time; if it is `lapsed', output
-how much time has lapsed since DATE."
+how much time has lapsed since DATE.  For `lapsed', the value of
+`gnus-article-date-lapsed-new-header' says whether the \"X-Sent:\" header
+should replace the \"Date:\" one, or should be added below it."
   (interactive (list 'ut t))
   (let* ((header (or header
-                     (mail-header-date gnus-current-headers)
                      (message-fetch-field "date")
                      ""))
+         (tdate-regexp "^Date:[ \t]\\|^X-Sent:[ \t]")
+         (date-regexp
+          (cond
+           ((not gnus-article-date-lapsed-new-header)
+            tdate-regexp)
+           ((eq type 'lapsed)
+            "^X-Sent:[ \t]")
+           (t
+            "^Date:[ \t]")))
          (date (if (vectorp header) (mail-header-date header)
                  header))
-         (date-regexp "^Date:[ \t]\\|^X-Sent:[ \t]")
          (inhibit-point-motion-hooks t)
-         bface eface newline)
-    (when (and date (not (string= date "")))
-      (save-excursion
-        (save-restriction
-          (nnheader-narrow-to-headers)
+         pos
+         bface eface)
+    (save-excursion
+      (save-restriction
+        (article-narrow-to-head)
+        (when (re-search-forward tdate-regexp nil t)
+          (setq bface (get-text-property (gnus-point-at-bol) 'face)
+                date (or (get-text-property (gnus-point-at-bol)
+                                            'original-date)
+                         date)
+                eface (get-text-property (1- (gnus-point-at-eol)) 'face))
+          (forward-line 1))
+        (when (and date (not (string= date "")))
+          (goto-char (point-min))
           (let ((buffer-read-only nil))
-            ;; Delete any old Date headers.
-            (if (re-search-forward date-regexp nil t)
-                (progn
-                  (setq bface (get-text-property (gnus-point-at-bol) 'face)
-                        eface (get-text-property (1- (gnus-point-at-eol))
-                                                 'face))
+            ;; Delete any old Date headers.
+            (while (re-search-forward date-regexp nil t)
+              (if pos
                   (delete-region (progn (beginning-of-line) (point))
-                                 (progn (end-of-line) (point)))
-                  (beginning-of-line))
-              (goto-char (point-max))
-              (setq newline t))
-            (insert (article-make-date-line date type))
+                                 (progn (forward-line 1) (point)))
+                (delete-region (progn (beginning-of-line) (point))
+                               (progn (end-of-line) (point)))
+                (setq pos (point))))
+            (when (and (not pos) (re-search-forward tdate-regexp nil t))
+              (forward-line 1))
+            (if pos (goto-char pos))
+            (insert (article-make-date-line date (or type 'ut)))
+            (when (not pos)
+              (insert "\n")
+              (forward-line -1))
             ;; Do highlighting.
             (beginning-of-line)
             (when (looking-at "\\([^:]+\\): *\\(.*\\)$")
               (put-text-property (match-beginning 1) (1+ (match-end 1))
+                                 'original-date date)
+              (put-text-property (match-beginning 1) (1+ (match-end 1))
                                  'face bface)
               (put-text-property (match-beginning 2) (match-end 2)
-                                 'face eface))
-            (when newline
-              (end-of-line)
-              (insert "\n"))))))))
+                                 'face eface))))))))
 
 (defun article-make-date-line (date type)
   "Return a DATE line of TYPE."
-  (cond
-   ;; Convert to the local timezone.  We have to slap a
-   ;; `condition-case' round the calls to the timezone
-   ;; functions since they aren't particularly resistant to
-   ;; buggy dates.
-   ((eq type 'local)
-    (concat "Date: " (condition-case ()
-                         (timezone-make-date-arpa-standard date)
-                       (error date))))
-   ;; Convert to Universal Time.
-   ((eq type 'ut)
-    (concat "Date: "
-            (condition-case ()
-                (timezone-make-date-arpa-standard date nil "UT")
-              (error date))))
-   ;; Get the original date from the article.
-   ((eq type 'original)
-    (concat "Date: " date))
-   ;; Let the user define the format.
-   ((eq type 'user)
-    (if (gnus-functionp gnus-article-time-format)
-        (funcall
-         gnus-article-time-format
-         (ignore-errors
-           (gnus-encode-date
-            (timezone-make-date-arpa-standard
-             date nil "UT"))))
-      (concat
-       "Date: "
-       (format-time-string gnus-article-time-format
-                           (ignore-errors
-                             (gnus-encode-date
-                              (timezone-make-date-arpa-standard
-                               date nil "UT")))))))
-   ;; ISO 8601.
-   ((eq type 'iso8601)
-    (concat
-     "Date: "
-     (format-time-string "%Y%M%DT%h%m%s"
-                         (ignore-errors
-                           (gnus-encode-date
-                            (timezone-make-date-arpa-standard
-                             date nil "UT"))))))
-   ;; Do an X-Sent lapsed format.
-   ((eq type 'lapsed)
-    ;; If the date is seriously mangled, the timezone functions are
-    ;; liable to bug out, so we ignore all errors.
-    (let* ((now (current-time))
-           (real-time
-            (ignore-errors
-              (gnus-time-minus
-               (gnus-encode-date
-                (timezone-make-date-arpa-standard
-                 (current-time-string now)
-                 (current-time-zone now) "UT"))
-               (gnus-encode-date
-                (timezone-make-date-arpa-standard
-                 date nil "UT")))))
-           (real-sec (and real-time
-                          (+ (* (float (car real-time)) 65536)
-                             (cadr real-time))))
-           (sec (and real-time (abs real-sec)))
-           num prev)
-      (cond
-       ((null real-time)
-        "X-Sent: Unknown")
-       ((zerop sec)
-        "X-Sent: Now")
-       (t
+  (let ((time (condition-case ()
+                  (date-to-time date)
+                (error '(0 0)))))
+    (cond
+     ;; Convert to the local timezone.  We have to slap a
+     ;; `condition-case' round the calls to the timezone
+     ;; functions since they aren't particularly resistant to
+     ;; buggy dates.
+     ((eq type 'local)
+      (let ((tz (car (current-time-zone time))))
+        (format "Date: %s %s%02d%02d" (current-time-string time)
+                (if (> tz 0) "+" "-") (/ (abs tz) 3600) 
+                (/ (% (abs tz) 3600) 60))))
+     ;; Convert to Universal Time.
+     ((eq type 'ut)
+      (concat "Date: "
+              (current-time-string
+               (let* ((e (parse-time-string date))
+                      (tm (apply 'encode-time e))
+                      (ms (car tm))
+                      (ls (- (cadr tm) (car (current-time-zone time)))))
+                 (cond ((< ls 0) (list (1- ms) (+ ls 65536)))
+                       ((> ls 65535) (list (1+ ms) (- ls 65536)))
+                       (t (list ms ls)))))
+              " UT"))
+     ;; Get the original date from the article.
+     ((eq type 'original)
+      (concat "Date: " (if (string-match "\n+$" date)
+                           (substring date 0 (match-beginning 0))
+                         date)))
+     ;; Let the user define the format.
+     ((eq type 'user)
+      (if (gnus-functionp gnus-article-time-format)
+          (funcall gnus-article-time-format time)
         (concat
-         "X-Sent: "
-         ;; This is a bit convoluted, but basically we go
-         ;; through the time units for years, weeks, etc,
-         ;; and divide things to see whether that results
-         ;; in positive answers.
-         (mapconcat
-          (lambda (unit)
-            (if (zerop (setq num (ffloor (/ sec (cdr unit)))))
-                ;; The (remaining) seconds are too few to
-                ;; be divided into this time unit.
-                ""
-              ;; It's big enough, so we output it.
-              (setq sec (- sec (* num (cdr unit))))
-              (prog1
-                  (concat (if prev ", " "") (int-to-string
-                                             (floor num))
-                          " " (symbol-name (car unit))
-                          (if (> num 1) "s" ""))
-                (setq prev t))))
-          article-time-units "")
-         ;; If dates are odd, then it might appear like the
-         ;; article was sent in the future.
-         (if (> real-sec 0)
-             " ago"
-           " in the future"))))))
-   (t
-    (error "Unknown conversion type: %s" type))))
+         "Date: "
+         (format-time-string gnus-article-time-format time))))
+     ;; ISO 8601.
+     ((eq type 'iso8601)
+      (let ((tz (car (current-time-zone time))))
+        (concat
+         "Date: "
+         (format-time-string "%Y%m%dT%H%M%S" time)
+         (format "%s%02d%02d"
+                 (if (> tz 0) "+" "-") (/ (abs tz) 3600) 
+                 (/ (% (abs tz) 3600) 60)))))
+     ;; Do an X-Sent lapsed format.
+     ((eq type 'lapsed)
+      ;; If the date is seriously mangled, the timezone functions are
+      ;; liable to bug out, so we ignore all errors.
+      (let* ((now (current-time))
+             (real-time (subtract-time now time))
+             (real-sec (and real-time
+                            (+ (* (float (car real-time)) 65536)
+                               (cadr real-time))))
+             (sec (and real-time (abs real-sec)))
+             num prev)
+        (cond
+         ((null real-time)
+          "X-Sent: Unknown")
+         ((zerop sec)
+          "X-Sent: Now")
+         (t
+          (concat
+           "X-Sent: "
+           ;; This is a bit convoluted, but basically we go
+           ;; through the time units for years, weeks, etc,
+           ;; and divide things to see whether that results
+           ;; in positive answers.
+           (mapconcat
+            (lambda (unit)
+              (if (zerop (setq num (ffloor (/ sec (cdr unit)))))
+                  ;; The (remaining) seconds are too few to
+                  ;; be divided into this time unit.
+                  ""
+                ;; It's big enough, so we output it.
+                (setq sec (- sec (* num (cdr unit))))
+                (prog1
+                    (concat (if prev ", " "") (int-to-string
+                                               (floor num))
+                            " " (symbol-name (car unit))
+                            (if (> num 1) "s" ""))
+                  (setq prev t))))
+            article-time-units "")
+           ;; If dates are odd, then it might appear like the
+           ;; article was sent in the future.
+           (if (> real-sec 0)
+               " ago"
+             " in the future"))))))
+     (t
+      (error "Unknown conversion type: %s" type)))))
 
 (defun article-date-local (&optional highlight)
   "Convert the current article date to the local timezone."
@@ -1486,11 +2123,14 @@ function and want to see what the date was before converting."
   (let (deactivate-mark)
     (save-excursion
       (ignore-errors
-        (when (gnus-buffer-live-p gnus-article-buffer)
-          (set-buffer gnus-article-buffer)
-          (goto-char (point-min))
-          (when (re-search-forward "^X-Sent:" nil t)
-            (article-date-lapsed t)))))))
+        (walk-windows
+         (lambda (w)
+           (set-buffer (window-buffer w))
+           (when (eq major-mode 'gnus-article-mode)
+             (goto-char (point-min))
+             (when (re-search-forward "^X-Sent:" nil t)
+               (article-date-lapsed t))))
+         nil 'visible)))))
 
 (defun gnus-start-date-timer (&optional n)
   "Start a timer to update the X-Sent header in the article buffers.
@@ -1533,13 +2173,17 @@ This format is defined by the `gnus-article-time-format' variable."
   (interactive (gnus-article-hidden-arg))
   (unless (gnus-article-check-hidden-text 'emphasis arg)
     (save-excursion
-      (let ((alist gnus-emphasis-alist)
+      (let ((alist (or 
+                    (condition-case nil
+                        (with-current-buffer gnus-summary-buffer 
+                          gnus-article-emphasis-alist) 
+                      (error))
+                    gnus-emphasis-alist))
             (buffer-read-only nil)
             (props (append '(article-type emphasis)
                            gnus-hidden-properties))
             regexp elem beg invisible visible face)
-        (goto-char (point-min))
-        (search-forward "\n\n" nil t)
+        (article-goto-body)
         (setq beg (point))
         (while (setq elem (pop alist))
           (goto-char beg)
@@ -1549,6 +2193,7 @@ This format is defined by the `gnus-article-time-format' variable."
                 face (nth 3 elem))
           (while (re-search-forward regexp nil t)
             (when (and (match-beginning visible) (match-beginning invisible))
+              (push 'emphasis gnus-article-wash-types)
               (gnus-article-hide-text
                (match-beginning invisible) (match-end invisible) props)
               (gnus-article-unhide-text-type
@@ -1557,6 +2202,26 @@ This format is defined by the `gnus-article-time-format' variable."
                (match-beginning visible) (match-end visible) 'face face)
               (goto-char (match-end invisible)))))))))
 
+(defun gnus-article-setup-highlight-words (&optional highlight-words)
+  "Setup newsgroup emphasis alist."
+  (unless gnus-article-emphasis-alist
+    (let ((name (and gnus-newsgroup-name
+                     (gnus-group-real-name gnus-newsgroup-name))))
+      (make-local-variable 'gnus-article-emphasis-alist)
+      (setq gnus-article-emphasis-alist 
+            (nconc 
+             (let ((alist gnus-group-highlight-words-alist) elem highlight)
+               (while (setq elem (pop alist))
+                 (when (and name (string-match (car elem) name))
+                   (setq alist nil
+                         highlight (copy-sequence (cdr elem)))))
+               highlight)
+             (copy-sequence highlight-words)
+             (if gnus-newsgroup-name
+                 (copy-sequence (gnus-group-find-parameter 
+                                 gnus-newsgroup-name 'highlight-words t)))
+             gnus-emphasis-alist)))))
+
 (defvar gnus-summary-article-menu)
 (defvar gnus-summary-post-menu)
 
@@ -1576,7 +2241,7 @@ This format is defined by the `gnus-article-time-format' variable."
     (if (not gnus-default-article-saver)
         (error "No default saver is defined")
       ;; !!! Magic!  The saving functions all save
-      ;; `gnus-original-article-buffer' (or so they think), but we
+      ;; `gnus-save-article-buffer' (or so they think), but we
       ;; bind that variable to our save-buffer.
       (set-buffer gnus-article-buffer)
       (let* ((gnus-save-article-buffer save-buffer)
@@ -1662,8 +2327,8 @@ This format is defined by the `gnus-article-time-format' variable."
          (gnus-make-directory (file-name-directory file))
          ;; If we have read a directory, we append the default file name.
          (when (file-directory-p file)
-           (setq file (concat (file-name-as-directory file)
-                              (file-name-nondirectory default-name))))
+           (setq file (expand-file-name (file-name-nondirectory default-name)
+                                        (file-name-as-directory file))))
          ;; Possibly translate some characters.
          (nnheader-translate-file-chars file)))))
     (gnus-make-directory (file-name-directory result))
@@ -1710,7 +2375,7 @@ Directory to save to is default to `gnus-article-save-directory'."
         (widen)
         (if (and (file-readable-p filename)
                  (mail-file-babyl-p filename))
-            (gnus-output-to-rmail filename t)
+            (rmail-output-to-rmail-file filename t)
           (gnus-output-to-mail filename)))))
   filename)
 
@@ -1750,8 +2415,7 @@ The directory to save in defaults to `gnus-article-save-directory'."
     (save-excursion
       (save-restriction
         (widen)
-        (goto-char (point-min))
-        (when (search-forward "\n\n" nil t)
+        (when (article-goto-body)
           (narrow-to-region (point) (point-max)))
         (gnus-output-to-file filename))))
   filename)
@@ -1759,7 +2423,8 @@ The directory to save in defaults to `gnus-article-save-directory'."
 (defun gnus-summary-save-in-pipe (&optional command)
   "Pipe this article to subprocess."
   (setq command
-        (cond ((eq command 'default)
+        (cond ((and (eq command 'default)
+                    gnus-last-shell-command)
                gnus-last-shell-command)
               (command command)
               (t (read-string
@@ -1823,17 +2488,6 @@ If variable `gnus-use-long-file-name' is non-nil, it is
         default
       (or last-file default))))
 
-(defun gnus-Plain-save-name (newsgroup headers &optional last-file)
-  "Generate file name from NEWSGROUP, HEADERS, and optional LAST-FILE.
-If variable `gnus-use-long-file-name' is non-nil, it is
-~/News/News.group.  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"))
-       gnus-article-save-directory)))
-
 (defun gnus-plain-save-name (newsgroup headers &optional last-file)
   "Generate file name from NEWSGROUP, HEADERS, and optional LAST-FILE.
 If variable `gnus-use-long-file-name' is non-nil, it is
@@ -1842,7 +2496,7 @@ If variable `gnus-use-long-file-name' is non-nil, it is
       (expand-file-name
        (if (gnus-use-long-file-name 'not-save)
            newsgroup
-         (concat (gnus-newsgroup-directory-form newsgroup) "/news"))
+         (expand-file-name "news" (gnus-newsgroup-directory-form newsgroup)))
        gnus-article-save-directory)))
 
 (eval-and-compile
@@ -1854,42 +2508,53 @@ If variable `gnus-use-long-file-name' is non-nil, it is
                  gfunc (cdr func))
          (setq afunc func
                gfunc (intern (format "gnus-%s" func))))
-       (fset gfunc
-             (if (not (fboundp afunc))
-                 nil
-               `(lambda (&optional interactive &rest args)
-                  ,(documentation afunc t)
-                  (interactive (list t))
-                  (save-excursion
-                    (set-buffer gnus-article-buffer)
-                    (if interactive
-                        (call-interactively ',afunc)
-                      (apply ',afunc args))))))))
+       (defalias gfunc
+         (if (fboundp afunc)
+           `(lambda (&optional interactive &rest args)
+              ,(documentation afunc t)
+              (interactive (list t))
+              (save-excursion
+                (set-buffer gnus-article-buffer)
+                (if interactive
+                    (call-interactively ',afunc)
+                  (apply ',afunc args))))))))
    '(article-hide-headers
      article-hide-boring-headers
      article-treat-overstrike
-     (article-fill . gnus-article-word-wrap)
+     article-fill-long-lines
+     article-capitalize-sentences
      article-remove-cr
      article-display-x-face
      article-de-quoted-unreadable
-     article-mime-decode-quoted-printable
+     article-de-base64-unreadable
+     article-decode-HZ
+     article-wash-html
+     article-hide-list-identifiers
      article-hide-pgp
+     article-strip-banner
+     article-babel
      article-hide-pem
      article-hide-signature
+     article-strip-headers-in-body
      article-remove-trailing-blank-lines
      article-strip-leading-blank-lines
      article-strip-multiple-blank-lines
      article-strip-leading-space
+     article-strip-trailing-space
      article-strip-blank-lines
      article-strip-all-blank-lines
      article-date-local
      article-date-iso8601
      article-date-original
      article-date-ut
+     article-decode-mime-words
+     article-decode-charset
+     article-decode-encoded-words
      article-date-user
      article-date-lapsed
      article-emphasize
      article-treat-dumbquotes
+     article-normalize-headers
      (article-show-all . gnus-article-show-all-headers))))
 
 ;;;
@@ -1898,20 +2563,19 @@ If variable `gnus-use-long-file-name' is non-nil, it is
 
 (put 'gnus-article-mode 'mode-class 'special)
 
+(set-keymap-parent gnus-article-mode-map widget-keymap)
+
 (gnus-define-keys gnus-article-mode-map
   " " gnus-article-goto-next-page
   "\177" gnus-article-goto-prev-page
   [delete] gnus-article-goto-prev-page
+  [backspace] gnus-article-goto-prev-page
   "\C-c^" gnus-article-refer-article
   "h" gnus-article-show-summary
   "s" gnus-article-show-summary
   "\C-c\C-m" gnus-article-mail
   "?" gnus-article-describe-briefly
-  gnus-mouse-2 gnus-article-push-button
-  "\r" gnus-article-press-button
-  "\t" gnus-article-next-button
-  "\M-\t" gnus-article-prev-button
-  "e" gnus-article-edit
+  "e" gnus-summary-edit-article
   "<" beginning-of-buffer
   ">" end-of-buffer
   "\C-c\C-i" gnus-info-find-node
@@ -1947,7 +2611,10 @@ If variable `gnus-use-long-file-name' is non-nil, it is
        ["Hide citation" gnus-article-hide-citation t]
        ["Treat overstrike" gnus-article-treat-overstrike t]
        ["Remove carriage return" gnus-article-remove-cr t]
-       ["Remove quoted-unreadable" gnus-article-de-quoted-unreadable t]))
+       ["Remove quoted-unreadable" gnus-article-de-quoted-unreadable t]
+       ["Remove base64" gnus-article-de-base64-unreadable t]
+       ["Treat html" gnus-article-wash-html t]
+       ["Decode HZ" gnus-article-decode-HZ t]))
 
     ;; Note "Commands" menu is defined in gnus-sum.el for consistency
 
@@ -1979,18 +2646,21 @@ commands:
   (setq mode-name "Article")
   (setq major-mode 'gnus-article-mode)
   (make-local-variable 'minor-mode-alist)
-  (unless (assq 'gnus-show-mime minor-mode-alist)
-    (push (list 'gnus-show-mime " MIME") minor-mode-alist))
   (use-local-map gnus-article-mode-map)
   (gnus-update-format-specifications nil 'article-mode)
   (set (make-local-variable 'page-delimiter) gnus-page-delimiter)
   (make-local-variable 'gnus-page-broken)
   (make-local-variable 'gnus-button-marker-list)
   (make-local-variable 'gnus-article-current-summary)
+  (make-local-variable 'gnus-article-mime-handles)
+  (make-local-variable 'gnus-article-decoded-p)
+  (make-local-variable 'gnus-article-mime-handle-alist)
+  (make-local-variable 'gnus-article-wash-types)
   (gnus-set-default-directory)
-  (buffer-disable-undo (current-buffer))
+  (buffer-disable-undo)
   (setq buffer-read-only t)
   (set-syntax-table gnus-article-mode-syntax-table)
+  (mm-enable-multibyte)
   (gnus-run-hooks 'gnus-article-mode-hook))
 
 (defun gnus-article-setup-buffer ()
@@ -2003,6 +2673,7 @@ commands:
                          (substring name (match-end 0))))))
     (setq gnus-article-buffer name)
     (setq gnus-original-article-buffer original)
+    (setq gnus-article-mime-handle-alist nil)
     ;; This might be a variable local to the summary buffer.
     (unless gnus-single-article-buffer
       (save-excursion
@@ -2010,16 +2681,22 @@ commands:
         (setq gnus-article-buffer name)
         (setq gnus-original-article-buffer original)
         (gnus-set-global-variables)))
+    (gnus-article-setup-highlight-words)
     ;; Init original article buffer.
     (save-excursion
       (set-buffer (gnus-get-buffer-create gnus-original-article-buffer))
-      (buffer-disable-undo (current-buffer))
+      (mm-enable-multibyte)
       (setq major-mode 'gnus-original-article-mode)
       (make-local-variable 'gnus-original-article))
     (if (get-buffer name)
         (save-excursion
           (set-buffer name)
-          (buffer-disable-undo (current-buffer))
+          (when gnus-article-mime-handles
+            (mm-destroy-parts gnus-article-mime-handles)
+            (setq gnus-article-mime-handles nil))
+          ;; Set it to nil in article-buffer!
+          (setq gnus-article-mime-handle-alist nil) 
+          (buffer-disable-undo)
           (setq buffer-read-only t)
           (unless (eq major-mode 'gnus-article-mode)
             (gnus-article-mode))
@@ -2028,6 +2705,7 @@ commands:
         (set-buffer (gnus-get-buffer-create name))
         (gnus-article-mode)
         (make-local-variable 'gnus-summary-buffer)
+        (gnus-summary-set-local-parameters gnus-newsgroup-name)
         (current-buffer)))))
 
 ;; Set article window start at LINE, where LINE is the number of lines
@@ -2084,8 +2762,7 @@ If ALL-HEADERS is non-nil, no headers are hidden."
                       (message "Message marked for downloading"))
                   (gnus-summary-mark-article article gnus-canceled-mark)
                   (unless (memq article gnus-newsgroup-sparse)
-                    (gnus-error 1
-                     "No such article (may have expired or been canceled)")))))
+                    (gnus-error 1 "No such article (may have expired or been canceled)")))))
           (if (or (eq result 'pseudo)
                   (eq result 'nneething))
               (progn
@@ -2100,7 +2777,9 @@ If ALL-HEADERS is non-nil, no headers are hidden."
                       (gnus-configure-windows 'summary)
                     (gnus-configure-windows 'article))
                   (gnus-set-global-variables))
-                (gnus-set-mode-line 'article))
+                (let ((gnus-article-mime-handle-alist-1
+                       gnus-article-mime-handle-alist))
+                  (gnus-set-mode-line 'article)))
             ;; The result from the `request' was an actual article -
             ;; or at least some text that is now displayed in the
             ;; article buffer.
@@ -2131,85 +2810,723 @@ If ALL-HEADERS is non-nil, no headers are hidden."
                 (when (gnus-visual-p 'article-highlight 'highlight)
                   (gnus-run-hooks 'gnus-visual-mark-article-hook))
                 ;; Set the global newsgroup variables here.
-                ;; Suggested by Jim Sisolak
-                ;; <sisolak@trans4.neep.wisc.edu>.
                 (gnus-set-global-variables)
                 (setq gnus-have-all-headers
                       (or all-headers gnus-show-all-headers))))
             (when (or (numberp article)
                       (stringp article))
-              ;; Hooks for getting information from the article.
-              ;; This hook must be called before being narrowed.
-              (let (buffer-read-only)
-                (gnus-run-hooks 'gnus-tmp-internal-hook)
-                (gnus-run-hooks 'gnus-article-prepare-hook)
-                ;; Decode MIME message.
-                (if gnus-show-mime
-                    (if (or (not gnus-strict-mime)
-                            (gnus-fetch-field "Mime-Version"))
-                      (let ((coding-system-for-write 'binary)
-                            (coding-system-for-read 'binary))
-                        (funcall gnus-show-mime-method))
-                      (funcall gnus-decode-encoded-word-method))
-                  (funcall gnus-show-traditional-method))
-                ;; Perform the article display hooks.
-                (gnus-run-hooks 'gnus-article-display-hook))
+              (gnus-article-prepare-display)
               ;; Do page break.
               (goto-char (point-min))
               (setq gnus-page-broken
                     (when gnus-break-pages
                       (gnus-narrow-to-page)
                       t)))
-            (gnus-set-mode-line 'article)
-            (gnus-configure-windows 'article)
-            (goto-char (point-min))
-            (search-forward "\n\n" nil t)
+            (let ((gnus-article-mime-handle-alist-1
+                   gnus-article-mime-handle-alist))
+              (gnus-set-mode-line 'article))
+            (article-goto-body)
             (set-window-point (get-buffer-window (current-buffer)) (point))
+            (gnus-configure-windows 'article)
             t))))))
 
+;;;###autoload
+(defun gnus-article-prepare-display ()
+  "Make the current buffer look like a nice article."
+  ;; Hooks for getting information from the article.
+  ;; This hook must be called before being narrowed.
+  (let ((gnus-article-buffer (current-buffer))
+        buffer-read-only)
+    (unless (eq major-mode 'gnus-article-mode)
+      (gnus-article-mode))
+    (setq buffer-read-only nil
+          gnus-article-wash-types nil)
+    (gnus-run-hooks 'gnus-tmp-internal-hook)
+    (when gnus-display-mime-function
+      (funcall gnus-display-mime-function))
+    (gnus-run-hooks 'gnus-article-prepare-hook)))
+
+;;;
+;;; Gnus MIME viewing functions
+;;;
+
+(defvar gnus-mime-button-line-format "%{%([%p. %d%T]%)%}%e\n"
+  "The following specs can be used:
+%t  The MIME type
+%T  MIME type, along with additional info
+%n  The `name' parameter
+%d  The description, if any
+%l  The length of the encoded part
+%p  The part identifier number
+%e  Dots if the part isn't displayed")
+
+(defvar gnus-mime-button-line-format-alist
+  '((?t gnus-tmp-type ?s)
+    (?T gnus-tmp-type-long ?s)
+    (?n gnus-tmp-name ?s)
+    (?d gnus-tmp-description ?s)
+    (?p gnus-tmp-id ?s)
+    (?l gnus-tmp-length ?d)
+    (?e gnus-tmp-dots ?s)))
+
+(defvar gnus-mime-button-commands
+  '((gnus-article-press-button "\r" "Toggle Display")
+    (gnus-mime-view-part "v" "View Interactively...")
+    (gnus-mime-view-part-as-type "t" "View As Type...")
+    (gnus-mime-save-part "o" "Save...")
+    (gnus-mime-copy-part "c" "View As Text, In Other Buffer")
+    (gnus-mime-inline-part "i" "View As Text, In This Buffer")
+    (gnus-mime-internalize-part "E" "View Internally")
+    (gnus-mime-externalize-part "e" "View Externally")
+    (gnus-mime-pipe-part "|" "Pipe To Command...")))
+
+(defun gnus-article-mime-part-status ()
+  (if gnus-article-mime-handle-alist-1
+      (format " (%d parts)" (length gnus-article-mime-handle-alist-1))
+    ""))
+
+(defvar gnus-mime-button-map
+  (let ((map (make-sparse-keymap)))
+    (set-keymap-parent map gnus-article-mode-map)
+    (define-key map gnus-mouse-2 'gnus-article-push-button)
+    (define-key map gnus-down-mouse-3 'gnus-mime-button-menu)
+    (dolist (c gnus-mime-button-commands)
+      (define-key map (cadr c) (car c)))
+    map))
+
+(defun gnus-mime-button-menu (event)
+  "Construct a context-sensitive menu of MIME commands."
+  (interactive "e")
+  (save-excursion
+    (let ((pos (event-start event)))
+      (set-buffer (window-buffer (posn-window pos)))
+      (goto-char (posn-point pos))
+      (gnus-article-check-buffer)
+      (let ((response (x-popup-menu
+                       t `("MIME Part"
+                           ("" ,@(mapcar (lambda (c)
+                                           (cons (caddr c) (car c)))
+                                         gnus-mime-button-commands))))))
+        (if response
+            (call-interactively response))))))
+
+(defun gnus-mime-view-all-parts (&optional handles)
+  "View all the MIME parts."
+  (interactive)
+  (save-current-buffer
+    (set-buffer gnus-article-buffer)
+    (let ((handles (or handles gnus-article-mime-handles))
+          (mail-parse-charset gnus-newsgroup-charset)
+          (mail-parse-ignored-charsets 
+           (save-excursion (set-buffer gnus-summary-buffer)
+                           gnus-newsgroup-ignored-charsets)))
+      (if (stringp (car handles))
+          (gnus-mime-view-all-parts (cdr handles))
+        (mapcar 'mm-display-part handles)))))
+
+(defun gnus-mime-save-part ()
+  "Save the MIME part under point."
+  (interactive)
+  (gnus-article-check-buffer)
+  (let ((data (get-text-property (point) 'gnus-data)))
+    (mm-save-part data)))
+
+(defun gnus-mime-pipe-part ()
+  "Pipe the MIME part under point to a process."
+  (interactive)
+  (gnus-article-check-buffer)
+  (let ((data (get-text-property (point) 'gnus-data)))
+    (mm-pipe-part data)))
+
+(defun gnus-mime-view-part ()
+  "Interactively choose a viewing method for the MIME part under point."
+  (interactive)
+  (gnus-article-check-buffer)
+  (let ((data (get-text-property (point) 'gnus-data)))
+    (mm-interactively-view-part data)))
+
+(defun gnus-mime-view-part-as-type-internal ()
+  (gnus-article-check-buffer)
+  (let* ((name (mail-content-type-get
+                (mm-handle-type (get-text-property (point) 'gnus-data))
+                'name))
+         (def-type (and name (mm-default-file-encoding name))))
+    (and def-type (cons def-type 0))))
+
+(defun gnus-mime-view-part-as-type (mime-type)
+  "Choose a MIME media type, and view the part as such."
+  (interactive
+   (list (completing-read
+          "View as MIME type: "
+          (mapcar #'list (mailcap-mime-types))
+          nil nil
+          (gnus-mime-view-part-as-type-internal))))
+  (gnus-article-check-buffer)
+  (let ((handle (get-text-property (point) 'gnus-data)))
+    (gnus-mm-display-part
+     (mm-make-handle (mm-handle-buffer handle)
+                     (cons mime-type (cdr (mm-handle-type handle)))
+                     (mm-handle-encoding handle)
+                     (mm-handle-undisplayer handle)
+                     (mm-handle-disposition handle)
+                     (mm-handle-description handle)
+                     (mm-handle-cache handle)
+                     (mm-handle-id handle)))))
+
+(defun gnus-mime-copy-part (&optional handle)
+  "Put the the MIME part under point into a new buffer."
+  (interactive)
+  (gnus-article-check-buffer)
+  (let* ((handle (or handle (get-text-property (point) 'gnus-data)))
+         (contents (mm-get-part handle))|
+         (base (file-name-nondirectory
+                (or
+                 (mail-content-type-get (mm-handle-type handle) 'name)
+                 (mail-content-type-get (mm-handle-type handle)
+                                        'filename)
+                 "*decoded*")))
+         (buffer (generate-new-buffer base)))
+    (switch-to-buffer buffer)
+    (insert contents)
+    ;; We do it this way to make `normal-mode' set the appropriate mode.
+    (unwind-protect
+        (progn
+          (setq buffer-file-name (expand-file-name base))
+          (normal-mode))
+      (setq buffer-file-name nil))
+    (goto-char (point-min))))
+
+(defun gnus-mime-inline-part (&optional handle)
+  "Insert the MIME part under point into the current buffer."
+  (interactive)
+  (gnus-article-check-buffer)
+  (let* ((handle (or handle (get-text-property (point) 'gnus-data)))
+         contents
+         (b (point))
+         buffer-read-only)
+    (if (mm-handle-undisplayer handle)
+        (mm-remove-part handle)
+      (setq contents (mm-get-part handle))
+      (forward-line 2)
+      (mm-insert-inline handle contents)
+      (goto-char b))))
+
+(defun gnus-mime-externalize-part (&optional handle)
+  "View the MIME part under point with an external viewer."
+  (interactive)
+  (gnus-article-check-buffer)
+  (let* ((handle (or handle (get-text-property (point) 'gnus-data)))
+         (mm-user-display-methods nil)
+         (mm-inlined-types nil)
+         (mail-parse-charset gnus-newsgroup-charset)
+         (mail-parse-ignored-charsets 
+          (save-excursion (set-buffer gnus-summary-buffer)
+                          gnus-newsgroup-ignored-charsets)))
+    (if (mm-handle-undisplayer handle)
+        (mm-remove-part handle)
+      (mm-display-part handle))))
+
+(defun gnus-mime-internalize-part (&optional handle)
+  "View the MIME part under point with an internal viewer.
+In no internal viewer is available, use an external viewer."
+  (interactive)
+  (gnus-article-check-buffer)
+  (let* ((handle (or handle (get-text-property (point) 'gnus-data)))
+         (mm-inlined-types '(".*"))
+         (mm-inline-large-images t)
+         (mail-parse-charset gnus-newsgroup-charset)
+         (mail-parse-ignored-charsets 
+          (save-excursion (set-buffer gnus-summary-buffer)
+                          gnus-newsgroup-ignored-charsets)))
+    (if (mm-handle-undisplayer handle)
+        (mm-remove-part handle)
+      (mm-display-part handle))))
+
+(defun gnus-article-part-wrapper (n function)
+  (save-current-buffer
+    (set-buffer gnus-article-buffer)
+    (when (> n (length gnus-article-mime-handle-alist))
+      (error "No such part"))
+    (gnus-article-goto-part n)
+    (let ((handle (cdr (assq n gnus-article-mime-handle-alist))))
+      (funcall function handle))))
+
+(defun gnus-article-pipe-part (n)
+  "Pipe MIME part N, which is the numerical prefix."
+  (interactive "p")
+  (gnus-article-part-wrapper n 'mm-pipe-part))
+
+(defun gnus-article-save-part (n)
+  "Save MIME part N, which is the numerical prefix."
+  (interactive "p")
+  (gnus-article-part-wrapper n 'mm-save-part))
+
+(defun gnus-article-interactively-view-part (n)
+  "View MIME part N interactively, which is the numerical prefix."
+  (interactive "p")
+  (gnus-article-part-wrapper n 'mm-interactively-view-part))
+
+(defun gnus-article-copy-part (n)
+  "Copy MIME part N, which is the numerical prefix."
+  (interactive "p")
+  (gnus-article-part-wrapper n 'gnus-mime-copy-part))
+
+(defun gnus-article-externalize-part (n)
+  "View MIME part N externally, which is the numerical prefix."
+  (interactive "p")
+  (gnus-article-part-wrapper n 'gnus-mime-externalize-part))
+
+(defun gnus-article-inline-part (n)
+  "Inline MIME part N, which is the numerical prefix."
+  (interactive "p")
+  (gnus-article-part-wrapper n 'gnus-mime-inline-part))
+
+(defun gnus-article-mime-match-handle-first (condition)
+  (if condition
+      (let ((alist gnus-article-mime-handle-alist) ihandle n)
+        (while (setq ihandle (pop alist))
+          (if (and (cond 
+                    ((functionp condition)
+                     (funcall condition (cdr ihandle)))
+                    ((eq condition 'undisplayed) 
+                     (not (or (mm-handle-undisplayer (cdr ihandle))
+                              (equal (mm-handle-media-type (cdr ihandle))
+                                     "multipart/alternative"))))
+                    ((eq condition 'undisplayed-alternative)
+                     (not (mm-handle-undisplayer (cdr ihandle))))
+                    (t t))
+                   (gnus-article-goto-part (car ihandle))
+                   (or (not n) (< (car ihandle) n)))
+              (setq n (car ihandle))))
+        (or n 1))
+    1))
+
+(defun gnus-article-view-part (&optional n)
+  "View MIME part N, which is the numerical prefix."
+  (interactive "P")
+  (save-current-buffer
+    (set-buffer gnus-article-buffer)
+    (or (numberp n) (setq n (gnus-article-mime-match-handle-first 
+                             gnus-article-mime-match-handle-function)))
+    (when (> n (length gnus-article-mime-handle-alist))
+      (error "No such part"))
+    (let ((handle (cdr (assq n gnus-article-mime-handle-alist))))
+      (when (gnus-article-goto-part n)
+        (if (equal (car handle) "multipart/alternative")
+            (gnus-article-press-button)
+          (when (eq (gnus-mm-display-part handle) 'internal)
+            (gnus-set-window-start)))))))
+
+(defun gnus-mm-display-part (handle)
+  "Display HANDLE and fix MIME button."
+  (let ((id (get-text-property (point) 'gnus-part))
+        (point (point))
+        buffer-read-only)
+    (forward-line 1)
+    (prog1
+        (let ((window (selected-window))
+              (mail-parse-charset gnus-newsgroup-charset)
+              (mail-parse-ignored-charsets 
+               (save-excursion (set-buffer gnus-summary-buffer)
+                               gnus-newsgroup-ignored-charsets)))
+          (save-excursion
+            (unwind-protect
+                (let ((win (get-buffer-window (current-buffer) t))
+                      (beg (point)))
+                  (when win
+                    (select-window win))
+                  (goto-char point)
+                  (forward-line)
+                  (if (mm-handle-displayed-p handle)
+                      ;; This will remove the part.
+                      (mm-display-part handle)
+                    (save-restriction
+                      (narrow-to-region (point) (1+ (point)))
+                      (mm-display-part handle)
+                      ;; We narrow to the part itself and
+                      ;; then call the treatment functions.
+                      (goto-char (point-min))
+                      (forward-line 1)
+                      (narrow-to-region (point) (point-max))
+                      (gnus-treat-article
+                       nil id
+                       (1- (length gnus-article-mime-handles))
+                       (mm-handle-media-type handle)))))
+              (select-window window))))
+      (goto-char point)
+      (delete-region (gnus-point-at-bol) (progn (forward-line 1) (point)))
+      (gnus-insert-mime-button
+       handle id (list (mm-handle-displayed-p handle)))
+      (goto-char point))))
+
+(defun gnus-article-goto-part (n)
+  "Go to MIME part N."
+  (let ((point (text-property-any (point-min) (point-max) 'gnus-part n)))
+    (when point
+      (goto-char point))))
+
+(defun gnus-insert-mime-button (handle gnus-tmp-id &optional displayed)
+  (let ((gnus-tmp-name
+         (or (mail-content-type-get (mm-handle-type handle)
+                                    'name)
+             (mail-content-type-get (mm-handle-disposition handle)
+                                    'filename)
+             ""))
+        (gnus-tmp-type (mm-handle-media-type handle))
+        (gnus-tmp-description
+         (mail-decode-encoded-word-string (or (mm-handle-description handle)
+                                              "")))
+        (gnus-tmp-dots
+         (if (if displayed (car displayed)
+               (mm-handle-displayed-p handle))
+             "" "..."))
+        (gnus-tmp-length (with-current-buffer (mm-handle-buffer handle)
+                           (buffer-size)))
+        gnus-tmp-type-long b e)
+    (when (string-match ".*/" gnus-tmp-name)
+      (setq gnus-tmp-name (replace-match "" t t gnus-tmp-name)))
+    (setq gnus-tmp-type-long (concat gnus-tmp-type
+                                     (and (not (equal gnus-tmp-name ""))
+                                          (concat "; " gnus-tmp-name))))
+    (or (equal gnus-tmp-description "")
+        (setq gnus-tmp-type-long (concat " --- " gnus-tmp-type-long)))
+    (unless (bolp)
+      (insert "\n"))
+    (setq b (point))
+    (gnus-eval-format
+     gnus-mime-button-line-format gnus-mime-button-line-format-alist
+     `(local-map ,gnus-mime-button-map
+                 keymap ,gnus-mime-button-map
+                 gnus-callback gnus-mm-display-part
+                 gnus-part ,gnus-tmp-id
+                 article-type annotation
+                 gnus-data ,handle))
+    (setq e (point))
+    (widget-convert-button
+     'link b e
+     :mime-handle handle
+     :action 'gnus-widget-press-button
+     :button-keymap gnus-mime-button-map
+     :help-echo
+     (lambda (widget/window &optional overlay pos)
+       ;; Needed to properly clear the message due to a bug in
+       ;; wid-edit (XEmacs only).
+       (if (boundp 'help-echo-owns-message)
+           (setq help-echo-owns-message t))
+       (format
+        "%S: %s the MIME part; %S: more options"
+        (aref gnus-mouse-2 0)
+        ;; XEmacs will get a single widget arg; Emacs 21 will get
+        ;; window, overlay, position.
+        (if (mm-handle-displayed-p
+             (if overlay
+                 (with-current-buffer (overlay-buffer overlay)
+                   (widget-get (widget-at (overlay-start overlay))
+                               :mime-handle))
+               (widget-get widget/window :mime-handle)))
+            "hide" "show")
+        (aref gnus-down-mouse-3 0))))))
+
+(defun gnus-widget-press-button (elems el)
+  (goto-char (widget-get elems :from))
+  (gnus-article-press-button))
+
+(defvar gnus-displaying-mime nil)
+
+(defun gnus-display-mime (&optional ihandles)
+  "Display the MIME parts."
+  (save-excursion
+    (save-selected-window
+      (let ((window (get-buffer-window gnus-article-buffer))
+            (point (point)))
+        (when window
+          (select-window window)
+          ;; We have to do this since selecting the window
+          ;; may change the point.  So we set the window point.
+          (set-window-point window point)))
+      (let* ((handles (or ihandles (mm-dissect-buffer) (mm-uu-dissect)))
+             buffer-read-only handle name type b e display)
+        (when (and (not ihandles)
+                   (not gnus-displaying-mime))
+          ;; Top-level call; we clean up.
+          (when gnus-article-mime-handles
+            (mm-destroy-parts gnus-article-mime-handles)
+            (setq gnus-article-mime-handle-alist nil));; A trick.
+          (setq gnus-article-mime-handles handles)
+          ;; We allow users to glean info from the handles.
+          (when gnus-article-mime-part-function
+            (gnus-mime-part-function handles)))
+        (if (and handles
+                 (or (not (stringp (car handles)))
+                     (cdr handles)))
+            (progn
+              (when (and (not ihandles)
+                         (not gnus-displaying-mime))
+                ;; Clean up for mime parts.
+                (article-goto-body)
+                (delete-region (point) (point-max)))
+              (let ((gnus-displaying-mime t))
+                (gnus-mime-display-part handles)))
+          (save-restriction
+            (article-goto-body)
+            (narrow-to-region (point) (point-max))
+            (gnus-treat-article nil 1 1)
+            (widen)))
+        (unless ihandles
+          ;; Highlight the headers.
+          (save-excursion
+            (save-restriction
+              (article-goto-body)
+              (narrow-to-region (point-min) (point))
+              (gnus-treat-article 'head))))))))
+
+(defvar gnus-mime-display-multipart-as-mixed nil)
+
+(defun gnus-mime-display-part (handle)
+  (cond
+   ;; Single part.
+   ((not (stringp (car handle)))
+    (gnus-mime-display-single handle))
+   ;; User-defined multipart
+   ((cdr (assoc (car handle) gnus-mime-multipart-functions))
+    (funcall (cdr (assoc (car handle) gnus-mime-multipart-functions))
+             handle))
+   ;; multipart/alternative
+   ((and (equal (car handle) "multipart/alternative")
+         (not gnus-mime-display-multipart-as-mixed))
+    (let ((id (1+ (length gnus-article-mime-handle-alist))))
+      (push (cons id handle) gnus-article-mime-handle-alist)
+      (gnus-mime-display-alternative (cdr handle) nil nil id)))
+   ;; multipart/related
+   ((and (equal (car handle) "multipart/related")
+         (not gnus-mime-display-multipart-as-mixed))
+    ;;;!!!We should find the start part, but we just default
+    ;;;!!!to the first part.
+    (gnus-mime-display-part (cadr handle)))
+   ;; Other multiparts are handled like multipart/mixed.
+   (t
+    (gnus-mime-display-mixed (cdr handle)))))
+
+(defun gnus-mime-part-function (handles)
+  (if (stringp (car handles))
+      (mapcar 'gnus-mime-part-function (cdr handles))
+    (funcall gnus-article-mime-part-function handles)))
+
+(defun gnus-mime-display-mixed (handles)
+  (mapcar 'gnus-mime-display-part handles))
+
+(defun gnus-mime-display-single (handle)
+  (let ((type (mm-handle-media-type handle))
+        (ignored gnus-ignored-mime-types)
+        (not-attachment t)
+        (move nil)
+        display text)
+    (catch 'ignored
+      (progn
+        (while ignored
+          (when (string-match (pop ignored) type)
+            (throw 'ignored nil)))
+        (if (and (setq not-attachment
+                       (and (not (mm-inline-override-p handle))
+                            (or (not (mm-handle-disposition handle))
+                                (equal (car (mm-handle-disposition handle))
+                                       "inline")
+                                (mm-attachment-override-p handle))))
+                 (mm-automatic-display-p handle)
+                 (or (mm-inlined-p handle)
+                     (mm-automatic-external-display-p type)))
+            (setq display t)
+          (when (equal (mm-handle-media-supertype handle) "text")
+            (setq text t)))
+        (let ((id (1+ (length gnus-article-mime-handle-alist))))
+          (push (cons id handle) gnus-article-mime-handle-alist)
+          (when (or (not display)
+                    (not (gnus-unbuttonized-mime-type-p type)))
+            ;(gnus-article-insert-newline)
+            (gnus-insert-mime-button
+             handle id (list (or display (and not-attachment text))))
+            (gnus-article-insert-newline)
+            ;(gnus-article-insert-newline)
+            (setq move t)))
+        (let ((beg (point)))
+          (cond
+           (display
+            (when move
+              (forward-line -2)
+              (setq beg (point)))
+            (let ((mail-parse-charset gnus-newsgroup-charset)
+                  (mail-parse-ignored-charsets 
+                   (save-excursion (condition-case ()
+                                       (set-buffer gnus-summary-buffer)
+                                     (error))
+                                   gnus-newsgroup-ignored-charsets)))
+              (mm-display-part handle t))
+            (goto-char (point-max)))
+           ((and text not-attachment)
+            (when move
+              (forward-line -2)
+              (setq beg (point)))
+            (gnus-article-insert-newline)
+            (mm-insert-inline handle (mm-get-part handle))
+            (goto-char (point-max))))
+          ;; Do highlighting.
+          (save-excursion
+            (save-restriction
+              (narrow-to-region beg (point))
+              (gnus-treat-article
+               nil (length gnus-article-mime-handle-alist)
+               (1- (length gnus-article-mime-handles))
+               (mm-handle-media-type handle)))))))))
+
+(defun gnus-unbuttonized-mime-type-p (type)
+  "Say whether TYPE is to be unbuttonized."
+  (unless gnus-inhibit-mime-unbuttonizing
+    (catch 'found
+      (let ((types gnus-unbuttonized-mime-types))
+        (while types
+          (when (string-match (pop types) type)
+            (throw 'found t)))))))
+
+(defun gnus-article-insert-newline ()
+  "Insert a newline, but mark it as undeletable."
+  (gnus-put-text-property
+   (point) (progn (insert "\n") (point)) 'gnus-undeletable t))
+
+(defun gnus-mime-display-alternative (handles &optional preferred ibegend id)
+  (let* ((preferred (or preferred (mm-preferred-alternative handles)))
+         (ihandles handles)
+         (point (point))
+         handle buffer-read-only from props begend not-pref)
+    (save-window-excursion
+      (save-restriction
+        (when ibegend
+          (narrow-to-region (car ibegend)
+                            (or (cdr ibegend)
+                                (progn
+                                  (goto-char (car ibegend))
+                                  (forward-line 2)
+                                  (point))))
+          (delete-region (point-min) (point-max))
+          (mm-remove-parts handles))
+        (setq begend (list (point-marker)))
+        ;; Do the toggle.
+        (unless (setq not-pref (cadr (member preferred ihandles)))
+          (setq not-pref (car ihandles)))
+        (when (or ibegend
+                  (not (gnus-unbuttonized-mime-type-p
+                        "multipart/alternative")))
+          (gnus-add-text-properties
+           (setq from (point))
+           (progn
+             (insert (format "%d.  " id))
+             (point))
+           `(gnus-callback
+             (lambda (handles)
+               (unless ,(not ibegend)
+                 (setq gnus-article-mime-handle-alist
+                       ',gnus-article-mime-handle-alist))
+               (gnus-mime-display-alternative
+                ',ihandles ',not-pref ',begend ,id))
+             local-map ,gnus-mime-button-map
+             ,gnus-mouse-face-prop ,gnus-article-mouse-face
+             face ,gnus-article-button-face
+             keymap ,gnus-mime-button-map
+             gnus-part ,id
+             gnus-data ,handle))
+          (widget-convert-button 'link from (point)
+                                 :action 'gnus-widget-press-button
+                                 :button-keymap gnus-widget-button-keymap)
+          ;; Do the handles
+          (while (setq handle (pop handles))
+            (gnus-add-text-properties
+             (setq from (point))
+             (progn
+               (insert (format "(%c) %-18s"
+                               (if (equal handle preferred) ?* ? )
+                               (mm-handle-media-type handle)))
+               (point))
+             `(gnus-callback
+               (lambda (handles)
+                 (unless ,(not ibegend)
+                   (setq gnus-article-mime-handle-alist
+                         ',gnus-article-mime-handle-alist))
+                 (gnus-mime-display-alternative
+                  ',ihandles ',handle ',begend ,id))
+               local-map ,gnus-mime-button-map
+               ,gnus-mouse-face-prop ,gnus-article-mouse-face
+               face ,gnus-article-button-face
+               keymap ,gnus-mime-button-map
+               gnus-part ,id
+               gnus-data ,handle))
+            (widget-convert-button 'link from (point)
+                                   :action 'gnus-widget-press-button
+                                   :button-keymap gnus-widget-button-keymap)
+            (insert "  "))
+          (insert "\n\n"))
+        (when preferred
+          (if (stringp (car preferred))
+              (gnus-display-mime preferred)
+            (let ((mail-parse-charset gnus-newsgroup-charset)
+                  (mail-parse-ignored-charsets 
+                   (save-excursion (set-buffer gnus-summary-buffer)
+                                   gnus-newsgroup-ignored-charsets)))
+              (mm-display-part preferred)
+              ;; Do highlighting.
+              (save-excursion
+                (save-restriction
+                  (narrow-to-region (car begend) (point-max))
+                  (gnus-treat-article
+                   nil (length gnus-article-mime-handle-alist)
+                   (1- (length gnus-article-mime-handles))
+                   (mm-handle-media-type handle))))))
+          (goto-char (point-max))
+          (setcdr begend (point-marker)))))
+    (when ibegend
+      (goto-char point))))
+
 (defun gnus-article-wash-status ()
   "Return a string which display status of article washing."
   (save-excursion
     (set-buffer gnus-article-buffer)
-    (let ((cite (gnus-article-hidden-text-p 'cite))
-          (headers (gnus-article-hidden-text-p 'headers))
-          (boring (gnus-article-hidden-text-p 'boring-headers))
-          (pgp (gnus-article-hidden-text-p 'pgp))
-          (pem (gnus-article-hidden-text-p 'pem))
-          (signature (gnus-article-hidden-text-p 'signature))
-          (overstrike (gnus-article-hidden-text-p 'overstrike))
-          (emphasis (gnus-article-hidden-text-p 'emphasis))
-          (mime gnus-show-mime))
-      (format "%c%c%c%c%c%c%c"
+    (let ((cite (memq 'cite gnus-article-wash-types))
+          (headers (memq 'headers gnus-article-wash-types))
+          (boring (memq 'boring-headers gnus-article-wash-types))
+          (pgp (memq 'pgp gnus-article-wash-types))
+          (pem (memq 'pem gnus-article-wash-types))
+          (signature (memq 'signature gnus-article-wash-types))
+          (overstrike (memq 'overstrike gnus-article-wash-types))
+          (emphasis (memq 'emphasis gnus-article-wash-types)))
+      (format "%c%c%c%c%c%c"
               (if cite ?c ? )
               (if (or headers boring) ?h ? )
               (if (or pgp pem) ?p ? )
               (if signature ?s ? )
               (if overstrike ?o ? )
-              (if mime ?m ? )
               (if emphasis ?e ? )))))
 
-(fset 'gnus-article-hide-headers-if-wanted 'gnus-article-maybe-hide-headers)
+(defalias 'gnus-article-hide-headers-if-wanted 'gnus-article-maybe-hide-headers)
 
 (defun gnus-article-maybe-hide-headers ()
   "Hide unwanted headers if `gnus-have-all-headers' is nil.
 Provided for backwards compatibility."
-  (or (save-excursion (set-buffer gnus-summary-buffer) gnus-have-all-headers)
-      gnus-inhibit-hiding
-      (gnus-article-hide-headers)))
+  (when (and (or (not (gnus-buffer-live-p gnus-summary-buffer))
+                 (not (save-excursion (set-buffer gnus-summary-buffer)
+                                      gnus-have-all-headers)))
+             (not gnus-inhibit-hiding))
+    (gnus-article-hide-headers)))
 
 ;;; Article savers.
 
 (defun gnus-output-to-file (file-name)
   "Append the current article to a file named FILE-NAME."
   (let ((artbuf (current-buffer)))
-    (nnheader-temp-write nil
+    (with-temp-buffer
       (insert-buffer-substring artbuf)
       ;; Append newline at end of the buffer as separator, and then
       ;; save it to file.
       (goto-char (point-max))
       (insert "\n")
-      (append-to-file (point-min) (point-max) file-name)
+      (mm-append-to-file (point-min) (point-max) file-name)
       t)))
 
 (defun gnus-narrow-to-page (&optional arg)
@@ -2337,8 +3654,7 @@ Argument LINES specifies lines to be scrolled down."
 (defun gnus-article-describe-briefly ()
   "Describe article mode commands briefly."
   (interactive)
-  (gnus-message 6
-                (substitute-command-keys "\\<gnus-article-mode-map>\\[gnus-article-goto-next-page]:Next page     \\[gnus-article-goto-prev-page]:Prev page  \\[gnus-article-show-summary]:Show summary  \\[gnus-info-find-node]:Run Info  \\[gnus-article-describe-briefly]:This help")))
+  (gnus-message 6 (substitute-command-keys "\\<gnus-article-mode-map>\\[gnus-article-goto-next-page]:Next page   \\[gnus-article-goto-prev-page]:Prev page  \\[gnus-article-show-summary]:Show summary  \\[gnus-info-find-node]:Run Info  \\[gnus-article-describe-briefly]:This help")))
 
 (defun gnus-article-summary-command ()
   "Execute the last keystroke in the summary buffer."
@@ -2361,9 +3677,15 @@ Argument LINES specifies lines to be scrolled down."
     (setq func (lookup-key (current-local-map) (this-command-keys)))
     (call-interactively func)))
 
+(defun gnus-article-check-buffer ()
+  "Beep if not in an article buffer."
+  (unless (equal major-mode 'gnus-article-mode)
+    (error "Command invoked outside of a Gnus article buffer")))
+
 (defun gnus-article-read-summary-keys (&optional arg key not-restore-window)
   "Read a summary buffer key sequence and execute it from the article buffer."
   (interactive "P")
+  (gnus-article-check-buffer)
   (let ((nosaves
          '("q" "Q"  "c" "r" "R" "\C-c\C-f" "m"  "a" "f" "F"
            "Zc" "ZC" "ZE" "ZQ" "ZZ" "Zn" "ZR" "ZG" "ZN" "ZP"
@@ -2379,7 +3701,10 @@ Argument LINES specifies lines to be scrolled down."
       (set-buffer gnus-article-current-summary)
       (let (gnus-pick-mode)
         (push (or key last-command-event) unread-command-events)
-        (setq keys (read-key-sequence nil))))
+        (setq keys (if gnus-xemacs
+                       (events-to-keys (read-key-sequence nil))
+                     (read-key-sequence nil)))))
+                     
     (message "")
 
     (if (or (member keys nosaves)
@@ -2391,7 +3716,8 @@ Argument LINES specifies lines to be scrolled down."
             ;; We disable the pick minor mode commands.
             (let (gnus-pick-mode)
               (setq func (lookup-key (current-local-map) keys))))
-          (if (not func)
+          (if (or (not func)
+                  (numberp func))
               (ding)
             (unless (member keys nosave-in-article)
               (set-buffer gnus-article-current-summary))
@@ -2421,9 +3747,12 @@ Argument LINES specifies lines to be scrolled down."
           (set-buffer obuf)
           (unless not-restore-window
             (set-window-configuration owin))
-          (unless (or (not (eq selected 'old)) (member keys up-to-top))
+          (when (eq selected 'old)
+            (article-goto-body)
+            (set-window-start (get-buffer-window (current-buffer))
+                              1)
             (set-window-point (get-buffer-window (current-buffer))
-                              opoint))
+                              (point)))
           (let ((win (get-buffer-window gnus-article-current-summary)))
             (when win
               (set-window-point win new-sum-point))))))))
@@ -2435,6 +3764,7 @@ headers will be hidden.
 If given a prefix, show the hidden text instead."
   (interactive (append (gnus-article-hidden-arg) (list 'force)))
   (gnus-article-hide-headers arg)
+  (gnus-article-hide-list-identifiers arg)
   (gnus-article-hide-pgp arg)
   (gnus-article-hide-citation-maybe arg force)
   (gnus-article-hide-signature arg))
@@ -2467,8 +3797,7 @@ If given a prefix, show the hidden text instead."
           ;; We only request an article by message-id when we do not have the
           ;; headers for it, so we'll have to get those.
           (when (stringp article)
-            (let ((gnus-override-method gnus-refer-article-method))
-              (gnus-read-header article)))
+            (gnus-read-header article))
 
           ;; If the article number is negative, that means that this article
           ;; doesn't belong in this newsgroup (possibly), so we find its
@@ -2486,8 +3815,7 @@ If given a prefix, show the hidden text instead."
                     ;; This is a sparse gap article.
                     (setq do-update-line article)
                     (setq article (mail-header-id header))
-                    (let ((gnus-override-method gnus-refer-article-method))
-                      (setq sparse-header (gnus-read-header article)))
+                    (setq sparse-header (gnus-read-header article))
                     (setq gnus-newsgroup-sparse
                           (delq article gnus-newsgroup-sparse)))
                    ((vectorp header)
@@ -2502,11 +3830,11 @@ If given a prefix, show the hidden text instead."
                                gnus-newsgroup-name)))
                   (when (and (eq (car method) 'nneething)
                              (vectorp header))
-                    (let ((dir (concat
+                    (let ((dir (expand-file-name
+                                (mail-header-subject header)
                                 (file-name-as-directory
                                  (or (cadr (assq 'nneething-address method))
-                                     (nth 1 method)))
-                                (mail-header-subject header))))
+                                     (nth 1 method))))))
                       (when (file-directory-p dir)
                         (setq article 'nneething)
                         (gnus-group-enter-directory dir))))))))
@@ -2547,20 +3875,40 @@ If given a prefix, show the hidden text instead."
                  (gnus-cache-request-article article group))
             'article)
            ;; Get the article and put into the article buffer.
-           ((or (stringp article) (numberp article))
-            (let ((gnus-override-method
-                   (and (stringp article) gnus-refer-article-method))
+           ((or (stringp article)
+                (numberp article))
+            (let ((gnus-override-method gnus-override-method)
+                  (methods (and (stringp article) 
+                                gnus-refer-article-method))
+                  result
                   (buffer-read-only nil))
-              (erase-buffer)
-              (gnus-kill-all-overlays)
-              (gnus-check-group-server)
-              (when (gnus-request-article article group (current-buffer))
-                (when (numberp article)
-                  (gnus-async-prefetch-next group article gnus-summary-buffer)
-                  (when gnus-keep-backlog
-                    (gnus-backlog-enter-article
-                     group article (current-buffer))))
-                'article)))
+              (setq methods
+                    (if (listp methods)
+                        methods
+                      (list methods)))
+              (when (and (null gnus-override-method)
+                         methods)
+                (setq gnus-override-method (pop methods)))
+              (while (not result)
+                (when (eq gnus-override-method 'current)
+                  (setq gnus-override-method gnus-current-select-method))
+                (erase-buffer)
+                (gnus-kill-all-overlays)
+                (let ((gnus-newsgroup-name group))
+                  (gnus-check-group-server))
+                (when (gnus-request-article article group (current-buffer))
+                  (when (numberp article)
+                    (gnus-async-prefetch-next group article 
+                                              gnus-summary-buffer)
+                    (when gnus-keep-backlog
+                      (gnus-backlog-enter-article
+                       group article (current-buffer))))
+                  (setq result 'article))
+                (if (not result)
+                    (if methods
+                        (setq gnus-override-method (pop methods))
+                      (setq result 'done))))
+              (and (eq result 'article) 'article)))
            ;; It was a pseudo.
            (t article)))
 
@@ -2576,13 +3924,18 @@ If given a prefix, show the hidden text instead."
           (if (get-buffer gnus-original-article-buffer)
               (set-buffer gnus-original-article-buffer)
             (set-buffer (gnus-get-buffer-create gnus-original-article-buffer))
-            (buffer-disable-undo (current-buffer))
+            (buffer-disable-undo)
             (setq major-mode 'gnus-original-article-mode)
             (setq buffer-read-only t))
           (let (buffer-read-only)
             (erase-buffer)
             (insert-buffer-substring gnus-article-buffer))
-          (setq gnus-original-article (cons group article))))
+          (setq gnus-original-article (cons group article)))
+
+        ;; Decode charsets.
+        (run-hooks 'gnus-article-decode-hook)
+        ;; Mark article as decoded or not.
+        (setq gnus-article-decoded-p gnus-article-decode-hook))
 
       ;; Update sparse articles.
       (when (and do-update-line
@@ -2609,8 +3962,10 @@ If given a prefix, show the hidden text instead."
 
 (defvar gnus-article-edit-mode-map nil)
 
+;; Should we be using derived.el for this?
 (unless gnus-article-edit-mode-map
-  (setq gnus-article-edit-mode-map (copy-keymap text-mode-map))
+  (setq gnus-article-edit-mode-map (make-sparse-keymap))
+  (set-keymap-parent gnus-article-edit-mode-map text-mode-map)
 
   (gnus-define-keys gnus-article-edit-mode-map
     "\C-c\C-c" gnus-article-edit-done
@@ -2647,18 +4002,19 @@ groups."
     (error "The current newsgroup does not support article editing"))
   (gnus-article-date-original)
   (gnus-article-edit-article
+   'ignore
    `(lambda (no-highlight)
+      'ignore
       (gnus-summary-edit-article-done
        ,(or (mail-header-references gnus-current-headers) "")
        ,(gnus-group-read-only-p) ,gnus-summary-buffer no-highlight))))
 
-(defun gnus-article-edit-article (exit-func)
+(defun gnus-article-edit-article (start-func exit-func)
   "Start editing the contents of the current article buffer."
   (let ((winconf (current-window-configuration)))
     (set-buffer gnus-article-buffer)
     (gnus-article-edit-mode)
-    (gnus-article-delete-text-of-type 'annotation)
-    (gnus-set-text-properties (point-min) (point-max) nil)
+    (funcall start-func)
     (gnus-configure-windows 'edit-article)
     (setq gnus-article-edit-done-function exit-func)
     (setq gnus-prev-winconf winconf)
@@ -2670,8 +4026,7 @@ groups."
   (save-excursion
     (save-restriction
       (widen)
-      (goto-char (point-min))
-      (when (search-forward "\n\n" nil 1)
+      (when (article-goto-body)
         (let ((lines (count-lines (point) (point-max)))
               (length (- (point-max) (point)))
               (case-fold-search t)
@@ -2696,7 +4051,19 @@ groups."
     (save-excursion
       (set-buffer buf)
       (let ((buffer-read-only nil))
-        (funcall func arg)))
+        (funcall func arg))
+      ;; The cache and backlog have to be flushed somewhat.
+      (when gnus-keep-backlog
+        (gnus-backlog-remove-article
+         (car gnus-article-current) (cdr gnus-article-current)))
+      ;; Flush original article as well.
+      (save-excursion
+        (when (get-buffer gnus-original-article-buffer)
+          (set-buffer gnus-original-article-buffer)
+          (setq gnus-original-article nil)))
+      (when gnus-use-cache
+        (gnus-cache-update-article
+         (car gnus-article-current) (cdr gnus-article-current))))
     (set-buffer buf)
     (set-window-start (get-buffer-window buf) start)
     (set-window-point (get-buffer-window buf) (point))))
@@ -2705,7 +4072,7 @@ groups."
   "Exit the article editing without updating."
   (interactive)
   ;; We remove all text props from the article buffer.
-  (let ((buf (format "%s" (buffer-string)))
+  (let ((buf (buffer-substring-no-properties (point-min) (point-max)))
         (curbuf (current-buffer))
         (p (point))
         (window-start (window-start)))
@@ -2713,25 +4080,12 @@ groups."
     (insert buf)
     (let ((winconf gnus-prev-winconf))
       (gnus-article-mode)
-      ;; The cache and backlog have to be flushed somewhat.
-      (when gnus-use-cache
-        (gnus-cache-update-article
-         (car gnus-article-current) (cdr gnus-article-current)))
-      (when gnus-keep-backlog
-        (gnus-backlog-remove-article
-         (car gnus-article-current) (cdr gnus-article-current)))
-      ;; Flush original article as well.
-      (save-excursion
-        (when (get-buffer gnus-original-article-buffer)
-          (set-buffer gnus-original-article-buffer)
-          (setq gnus-original-article nil)))
       (set-window-configuration winconf)
       ;; Tippy-toe some to make sure that point remains where it was.
-      (let ((buf (current-buffer)))
+      (save-current-buffer
         (set-buffer curbuf)
         (set-window-start (get-buffer-window (current-buffer)) window-start)
-        (goto-char p)
-        (set-buffer buf)))))
+        (goto-char p)))))
 
 (defun gnus-article-edit-full-stops ()
   "Interactively repair spacing at end of sentences."
@@ -2750,15 +4104,15 @@ groups."
 
 ;;; 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\\)"
+(defcustom gnus-button-url-regexp "\\b\\(\\(www\\.\\|\\(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."
   :group 'gnus-article-buttons
   :type 'regexp)
 
 (defcustom gnus-button-alist
-  `(("<\\(url:[>\n\t ]*?\\)?news:[>\n\t ]*\\([^>\n\t ]*@[^>\n\t ]*\\)>" 0 t
-     gnus-button-message-id 2)
-    ("\\bnews:\\([^>\n\t ]*@[^>\n\t ]*\\)" 0 t gnus-button-message-id 1)
+  `(("<\\(url:[>\n\t ]*?\\)?news:[>\n\t ]*\\([^>\n\t ]*@[^>\n\t ]*\\)>"
+     0 t gnus-button-message-id 2)
+    ("\\bnews:\\([^>\n\t ]*@[^>)!;:,\n\t ]*\\)" 0 t gnus-button-message-id 1)
     ("\\(\\b<\\(url:[>\n\t ]*\\)?news:[>\n\t ]*\\(//\\)?\\([^>\n\t ]*\\)>\\)"
      1 t
      gnus-button-fetch-group 4)
@@ -2766,12 +4120,12 @@ groups."
     ("\\bin\\( +article\\| +message\\)? +\\(<\\([^\n @<>]+@[^\n @<>]+\\)>\\)" 2
      t gnus-button-message-id 3)
     ("\\(<URL: *\\)mailto: *\\([^> \n\t]+\\)>" 0 t gnus-url-mailto 2)
-    ("mailto:\\([a-zA-Z.-@_+0-9%]+\\)" 0 t gnus-url-mailto 1)
+    ("mailto:\\([-a-zA-Z.@_+0-9%]+\\)" 0 t gnus-url-mailto 1)
     ("\\bmailto:\\([^ \n\t]+\\)" 0 t gnus-url-mailto 1)
     ;; This is how URLs _should_ be embedded in text...
-    ("<URL: *\\([^>]*\\)>" 0 t gnus-button-embedded-url 1)
+    ("<URL: *\\([^<>]*\\)>" 0 t gnus-button-embedded-url 1)
     ;; Raw URLs.
-    (,gnus-button-url-regexp 0 t gnus-button-url 0))
+    (,gnus-button-url-regexp 0 t browse-url 0))
   "*Alist of regexps matching buttons in article bodies.
 
 Each entry has the form (REGEXP BUTTON FORM CALLBACK PAR...), where
@@ -2799,9 +4153,9 @@ variable it the real callback function."
     ("^\\(From\\|Reply-To\\):" ": *\\(.+\\)$" 1 t gnus-button-reply 1)
     ("^\\(Cc\\|To\\):" "[^ \t\n<>,()\"]+@[^ \t\n<>,()\"]+"
      0 t gnus-button-mailto 0)
-    ("^X-[Uu][Rr][Ll]:" ,gnus-button-url-regexp 0 t gnus-button-url 0)
-    ("^Subject:" ,gnus-button-url-regexp 0 t gnus-button-url 0)
-    ("^[^:]+:" ,gnus-button-url-regexp 0 t gnus-button-url 0)
+    ("^X-[Uu][Rr][Ll]:" ,gnus-button-url-regexp 0 t browse-url 0)
+    ("^Subject:" ,gnus-button-url-regexp 0 t browse-url 0)
+    ("^[^:]+:" ,gnus-button-url-regexp 0 t browse-url 0)
     ("^[^:]+:" "\\(<\\(url: \\)?news:\\([^>\n ]*\\)>\\)" 1 t
      gnus-button-message-id 3))
   "*Alist of headers and regexps to match buttons in article heads.
@@ -2856,40 +4210,6 @@ call it with the value of the `gnus-data' text property."
     (when fun
       (funcall fun data))))
 
-(defun gnus-article-prev-button (n)
-  "Move point to N buttons backward.
-If N is negative, move forward instead."
-  (interactive "p")
-  (gnus-article-next-button (- n)))
-
-(defun gnus-article-next-button (n)
-  "Move point to N buttons forward.
-If N is negative, move backward instead."
-  (interactive "p")
-  (let ((function (if (< n 0) 'previous-single-property-change
-                    'next-single-property-change))
-        (inhibit-point-motion-hooks t)
-        (backward (< n 0))
-        (limit (if (< n 0) (point-min) (point-max))))
-    (setq n (abs n))
-    (while (and (not (= limit (point)))
-                (> n 0))
-      ;; Skip past the current button.
-      (when (get-text-property (point) 'gnus-callback)
-        (goto-char (funcall function (point) 'gnus-callback nil limit)))
-      ;; Go to the next (or previous) button.
-      (gnus-goto-char (funcall function (point) 'gnus-callback nil limit))
-      ;; Put point at the start of the button.
-      (when (and backward (not (get-text-property (point) 'gnus-callback)))
-        (goto-char (funcall function (point) 'gnus-callback nil limit)))
-      ;; Skip past intangible buttons.
-      (when (get-text-property (point) 'intangible)
-        (incf n))
-      (decf n))
-    (unless (zerop n)
-      (gnus-message 5 "No more buttons"))
-    n))
-
 (defun gnus-article-highlight (&optional force)
   "Highlight current article.
 This function calls `gnus-article-highlight-headers',
@@ -2924,7 +4244,7 @@ do the highlighting.  See the documentation for those functions."
             (case-fold-search t)
             (inhibit-point-motion-hooks t)
             entry regexp header-face field-face from hpoints fpoints)
-        (message-narrow-to-head)
+        (article-narrow-to-head)
         (while (setq entry (pop alist))
           (goto-char (point-min))
           (setq regexp (concat "^\\("
@@ -2990,18 +4310,19 @@ specified by `gnus-button-alist'."
           (alist gnus-button-alist)
           beg entry regexp)
       ;; Remove all old markers.
-      (let (marker entry)
+      (let (marker entry new-list)
         (while (setq marker (pop gnus-button-marker-list))
-          (goto-char marker)
-          (when (setq entry (gnus-button-entry))
-            (put-text-property (match-beginning (nth 1 entry))
-                               (match-end (nth 1 entry))
-                               'gnus-callback nil))
-          (set-marker marker nil)))
+          (if (or (< marker (point-min)) (>= marker (point-max)))
+              (push marker new-list)
+            (goto-char marker)
+            (when (setq entry (gnus-button-entry))
+              (put-text-property (match-beginning (nth 1 entry))
+                                 (match-end (nth 1 entry))
+                                 'gnus-callback nil))
+            (set-marker marker nil)))
+        (setq gnus-button-marker-list new-list))
       ;; We skip the headers.
-      (goto-char (point-min))
-      (unless (search-forward "\n\n" nil t)
-        (goto-char (point-max)))
+      (article-goto-body)
       (setq beg (point))
       (while (setq entry (pop alist))
         (setq regexp (car entry))
@@ -3027,38 +4348,38 @@ specified by `gnus-button-alist'."
   (interactive)
   (save-excursion
     (set-buffer gnus-article-buffer)
-    (let ((buffer-read-only nil)
-          (inhibit-point-motion-hooks t)
-          (case-fold-search t)
-          (alist gnus-header-button-alist)
-          entry beg end)
-      (nnheader-narrow-to-headers)
-      (while alist
-        ;; Each alist entry.
-        (setq entry (car alist)
-              alist (cdr alist))
-        (goto-char (point-min))
-        (while (re-search-forward (car entry) nil t)
-          ;; Each header matching the entry.
-          (setq beg (match-beginning 0))
-          (setq end (or (and (re-search-forward "^[^ \t]" nil t)
-                             (match-beginning 0))
-                        (point-max)))
-          (goto-char beg)
-          (while (re-search-forward (nth 1 entry) end t)
-            ;; Each match within a header.
-            (let* ((entry (cdr entry))
-                   (start (match-beginning (nth 1 entry)))
-                   (end (match-end (nth 1 entry)))
-                   (form (nth 2 entry)))
-              (goto-char (match-end 0))
-              (when (eval form)
-                (gnus-article-add-button
-                 start end (nth 3 entry)
-                 (buffer-substring (match-beginning (nth 4 entry))
-                                   (match-end (nth 4 entry)))))))
-          (goto-char end))))
-    (widen)))
+    (save-restriction
+      (let ((buffer-read-only nil)
+            (inhibit-point-motion-hooks t)
+            (case-fold-search t)
+            (alist gnus-header-button-alist)
+            entry beg end)
+        (article-narrow-to-head)
+        (while alist
+          ;; Each alist entry.
+          (setq entry (car alist)
+                alist (cdr alist))
+          (goto-char (point-min))
+          (while (re-search-forward (car entry) nil t)
+            ;; Each header matching the entry.
+            (setq beg (match-beginning 0))
+            (setq end (or (and (re-search-forward "^[^ \t]" nil t)
+                               (match-beginning 0))
+                          (point-max)))
+            (goto-char beg)
+            (while (re-search-forward (nth 1 entry) end t)
+              ;; Each match within a header.
+              (let* ((entry (cdr entry))
+                     (start (match-beginning (nth 1 entry)))
+                     (end (match-end (nth 1 entry)))
+                     (form (nth 2 entry)))
+                (goto-char (match-end 0))
+                (when (eval form)
+                  (gnus-article-add-button
+                   start end (nth 3 entry)
+                   (buffer-substring (match-beginning (nth 4 entry))
+                                     (match-end (nth 4 entry)))))))
+            (goto-char end)))))))
 
 ;;; External functions:
 
@@ -3072,7 +4393,9 @@ specified by `gnus-button-alist'."
    (nconc (and gnus-article-mouse-face
                (list gnus-mouse-face-prop gnus-article-mouse-face))
           (list 'gnus-callback fun)
-          (and data (list 'gnus-data data)))))
+          (and data (list 'gnus-data data))))
+  (widget-convert-button 'link from to :action 'gnus-widget-press-button
+                         :button-keymap gnus-widget-button-keymap))
 
 ;;; Internal functions:
 
@@ -3104,7 +4427,6 @@ specified by `gnus-button-alist'."
 (defun gnus-button-push (marker)
   ;; Push button starting at MARKER.
   (save-excursion
-    (set-buffer gnus-article-buffer)
     (goto-char marker)
     (let* ((entry (gnus-button-entry))
            (inhibit-point-motion-hooks t)
@@ -3149,7 +4471,7 @@ specified by `gnus-button-alist'."
 
 (defun gnus-url-parse-query-string (query &optional downcase)
   (let (retval pairs cur key val)
-    (setq pairs (gnus-split-string query "&"))
+    (setq pairs (split-string query "&"))
     (while pairs
       (setq cur (car pairs)
             pairs (cdr pairs))
@@ -3230,13 +4552,8 @@ forbidden in URL encoding."
   ;; Reply to ADDRESS.
   (message-reply address))
 
-(defun gnus-button-url (address)
-  "Browse ADDRESS."
-  (browse-url address))
-
 (defun gnus-button-embedded-url (address)
   "Browse ADDRESS."
-  ;; In Emacs 20, `browse-url-browser-function' may be an alist.
   (browse-url (gnus-strip-whitespace address)))
 
 ;;; Next/prev buttons in the article buffer.
@@ -3256,7 +4573,7 @@ forbidden in URL encoding."
      gnus-prev-page-line-format nil
      `(gnus-prev t local-map ,gnus-prev-page-map
                  gnus-callback gnus-article-button-prev-page
-                 gnus-type annotation))))
+                 article-type annotation))))
 
 (defvar gnus-next-page-map nil)
 (unless gnus-next-page-map
@@ -3287,7 +4604,7 @@ forbidden in URL encoding."
                       `(gnus-next
                         t local-map ,gnus-next-page-map
                         gnus-callback gnus-article-button-next-page
-                        gnus-type annotation))))
+                        article-type annotation))))
 
 (defun gnus-article-button-next-page (arg)
   "Go to the next page."
@@ -3305,6 +4622,117 @@ forbidden in URL encoding."
     (gnus-article-prev-page)
     (select-window win)))
 
+(defvar gnus-decode-header-methods
+  '(mail-decode-encoded-word-region)
+  "List of methods used to decode headers.
+
+This variable is a list of FUNCTION or (REGEXP . FUNCTION).  If item
+is FUNCTION, FUNCTION will be apply to all newsgroups.  If item is a
+(REGEXP . FUNCTION), FUNCTION will be only apply to thes newsgroups
+whose names match REGEXP.
+
+For example:
+((\"chinese\" . gnus-decode-encoded-word-region-by-guess)
+ mail-decode-encoded-word-region
+ (\"chinese\" . rfc1843-decode-region))
+")
+
+(defvar gnus-decode-header-methods-cache nil)
+
+(defun gnus-multi-decode-header (start end)
+  "Apply the functions from `gnus-encoded-word-methods' that match."
+  (unless (and gnus-decode-header-methods-cache
+               (eq gnus-newsgroup-name
+                   (car gnus-decode-header-methods-cache)))
+    (setq gnus-decode-header-methods-cache (list gnus-newsgroup-name))
+    (mapcar (lambda (x)
+              (if (symbolp x)
+                  (nconc gnus-decode-header-methods-cache (list x))
+                (if (and gnus-newsgroup-name
+                         (string-match (car x) gnus-newsgroup-name))
+                    (nconc gnus-decode-header-methods-cache
+                           (list (cdr x))))))
+          gnus-decode-header-methods))
+  (let ((xlist gnus-decode-header-methods-cache))
+    (pop xlist)
+    (save-restriction
+      (narrow-to-region start end)
+      (while xlist
+        (funcall (pop xlist) (point-min) (point-max))))))
+
+;;;
+;;; Treatment top-level handling.
+;;;
+
+(defun gnus-treat-article (condition &optional part-number total-parts type)
+  (let ((length (- (point-max) (point-min)))
+        (alist gnus-treatment-function-alist)
+        (article-goto-body-goes-to-point-min-p t)
+        (treated-type
+         (or (not type)
+             (catch 'found
+               (let ((list gnus-article-treat-types))
+                 (while list
+                   (when (string-match (pop list) type)
+                     (throw 'found t)))))))
+        (highlightp (gnus-visual-p 'article-highlight 'highlight))
+        val elem)
+    (gnus-run-hooks 'gnus-part-display-hook)
+    (while (setq elem (pop alist))
+      (setq val
+            (save-excursion
+              (if (gnus-buffer-live-p gnus-summary-buffer)
+                  (set-buffer gnus-summary-buffer))
+              (symbol-value (car elem))))
+      (when (and (or (consp val)
+                     treated-type)
+                 (gnus-treat-predicate val)
+                 (or (not (get (car elem) 'highlight))
+                     highlightp))
+        (save-restriction
+          (funcall (cadr elem)))))))
+
+;; Dynamic variables.
+(defvar part-number)
+(defvar total-parts)
+(defvar type)
+(defvar condition)
+(defvar length)
+(defun gnus-treat-predicate (val)
+  (cond
+   ((null val)
+    nil)
+   ((and (listp val)
+         (stringp (car val)))
+    (apply 'gnus-or (mapcar `(lambda (s)
+                               (string-match s ,(or gnus-newsgroup-name "")))
+                            val)))
+   ((listp val)
+    (let ((pred (pop val)))
+      (cond
+       ((eq pred 'or)
+        (apply 'gnus-or (mapcar 'gnus-treat-predicate val)))
+       ((eq pred 'and)
+        (apply 'gnus-and (mapcar 'gnus-treat-predicate val)))
+       ((eq pred 'not)
+        (not (gnus-treat-predicate (car val))))
+       ((eq pred 'typep)
+        (equal (car val) type))
+       (t
+        (error "%S is not a valid predicate" pred)))))
+   (condition
+    (eq condition val))
+   ((eq val t)
+    t)
+   ((eq val 'head)
+    nil)
+   ((eq val 'last)
+    (eq part-number total-parts))
+   ((numberp val)
+    (< length val))
+   (t
+    (error "%S is not a valid value" val))))
+
 (gnus-ems-redefine)
 
 (provide 'gnus-art)
diff --git a/lisp/gnus/gnus-group.el b/lisp/gnus/gnus-group.el
index c881f5976d9..0aead88df25 100644
--- a/lisp/gnus/gnus-group.el
+++ b/lisp/gnus/gnus-group.el
@@ -1,5 +1,6 @@
 ;;; gnus-group.el --- group mode commands for Gnus
-;; Copyright (C) 1996,97,98 Free Software Foundation, Inc.
+;; Copyright (C) 1996, 1997, 1998, 1999, 2000
+;;        Free Software Foundation, Inc.
 
 ;; Author: Lars Magne Ingebrigtsen <larsi@gnus.org>
 ;; Keywords: news
@@ -27,8 +28,6 @@
 
 (eval-when-compile (require 'cl))
 
-(eval-when-compile (require 'cl))
-
 (require 'gnus)
 (require 'gnus-start)
 (require 'nnmail)
@@ -37,6 +36,7 @@
 (require 'gnus-range)
 (require 'gnus-win)
 (require 'gnus-undo)
+(require 'time-date)
 
 (defcustom gnus-group-archive-directory
   "*ftp@ftp.hpc.uh.edu:/pub/emacs/ding-list/"
@@ -50,7 +50,7 @@
   :group 'gnus-group-foreign
   :type 'directory)
 
-(defcustom gnus-no-groups-message "No news is no news"
+(defcustom gnus-no-groups-message "No gnus is bad news"
   "*Message displayed by Gnus when no groups are available."
   :group 'gnus-start
   :type 'string)
@@ -162,6 +162,7 @@ with some simple extensions.
 %n    Select from where (string)
 %z    A string that look like `<%s:%n>' if a foreign select method is used
 %d    The date the group was last entered.
+%E    Icon as defined by `gnus-group-icon-list'.
 %u    User defined specifier.  The next character in the format string should
       be a letter.  Gnus will call the function gnus-user-format-function-X,
       where X is the letter following %u.  The function will be passed the
@@ -300,6 +301,18 @@ variable."
      gnus-group-news-3-empty-face)
     ((and (not mailp) (eq level 3)) .
      gnus-group-news-3-face)
+    ((and (= unread 0) (not mailp) (eq level 4)) .
+     gnus-group-news-4-empty-face)
+    ((and (not mailp) (eq level 4)) .
+     gnus-group-news-4-face)
+    ((and (= unread 0) (not mailp) (eq level 5)) .
+     gnus-group-news-5-empty-face)
+    ((and (not mailp) (eq level 5)) .
+     gnus-group-news-5-face)
+    ((and (= unread 0) (not mailp) (eq level 6)) .
+     gnus-group-news-6-empty-face)
+    ((and (not mailp) (eq level 6)) .
+     gnus-group-news-6-face)
     ((and (= unread 0) (not mailp)) .
      gnus-group-news-low-empty-face)
     ((and (not mailp)) .
@@ -320,7 +333,7 @@ variable."
     ((= unread 0) .
      gnus-group-mail-low-empty-face)
     (t .
-     gnus-group-mail-low-face))
+       gnus-group-mail-low-face))
   "*Controls the highlighting of group buffer lines.
 
 Below is a list of `Form'/`Face' pairs.  When deciding how a a
@@ -349,6 +362,56 @@ ticked: The number of ticked articles."
   :group 'gnus-group-visual
   :type 'character)
 
+(defgroup gnus-group-icons nil
+  "Add Icons to your group buffer.  "
+  :group 'gnus-group-visual)
+
+(defcustom gnus-group-icon-list
+  nil
+  "*Controls the insertion of icons into group buffer lines.
+
+Below is a list of `Form'/`File' pairs.  When deciding how a
+particular group line should be displayed, each form is evaluated.
+The icon from the file field after the first true form is used.  You
+can change how those group lines are displayed by editing the file
+field.  The File will either be found in the
+`gnus-group-glyph-directory' or by designating absolute path to the
+file.
+
+It is also possible to change and add form fields, but currently that
+requires an understanding of Lisp expressions.  Hopefully this will
+change in a future release.  For now, you can use the following
+variables in the Lisp expression:
+
+group: The name of the group.
+unread: The number of unread articles in the group.
+method: The select method used.
+mailp: Whether it's a mail group or not.
+newsp: Whether it's a news group or not
+level: The level of the group.
+score: The score of the group.
+ticked: The number of ticked articles."
+  :group 'gnus-group-icons
+  :type '(repeat (cons (sexp :tag "Form") file)))
+
+(defcustom gnus-group-name-charset-method-alist nil
+  "*Alist of method and the charset for group names.
+
+For example:
+    (((nntp \"news.com.cn\") . cn-gb-2312))
+"
+  :group 'gnus-charset
+  :type '(repeat (cons (sexp :tag "Method") (symbol :tag "Charset"))))
+
+(defcustom gnus-group-name-charset-group-alist nil
+  "*Alist of group regexp and the charset for group names.
+
+For example:
+    ((\"\\.com\\.cn:\" . cn-gb-2312))
+"
+  :group 'gnus-charset
+  :type '(repeat (cons (regexp :tag "Group") (symbol :tag "Charset"))))
+
 ;;; Internal variables
 
 (defvar gnus-group-sort-alist-function 'gnus-group-sort-flat
@@ -393,6 +456,7 @@ ticked: The number of ticked articles."
     (?s gnus-tmp-news-server ?s)
     (?n gnus-tmp-news-method ?s)
     (?P gnus-group-indentation ?s)
+    (?E gnus-tmp-group-icon ?s)
     (?l gnus-tmp-grouplens ?s)
     (?z gnus-tmp-news-method-string ?s)
     (?m (gnus-group-new-mail gnus-tmp-group) ?c)
@@ -415,6 +479,9 @@ ticked: The number of ticked articles."
 
 (defvar gnus-group-list-mode nil)
 
+
+(defvar gnus-group-icon-cache nil)
+
 ;;;
 ;;; Gnus group mode
 ;;;
@@ -427,6 +494,7 @@ ticked: The number of ticked articles."
     "=" gnus-group-select-group
     "\r" gnus-group-select-group
     "\M-\r" gnus-group-quick-select-group
+    "\M- " gnus-group-visible-select-group
     [(meta control return)] gnus-group-select-group-ephemerally
     "j" gnus-group-jump-to-group
     "n" gnus-group-next-unread-group
@@ -503,6 +571,7 @@ ticked: The number of ticked articles."
     "u" gnus-group-make-useful-group
     "a" gnus-group-make-archive-group
     "k" gnus-group-make-kiboze-group
+    "l" gnus-group-nnimap-edit-acl
     "m" gnus-group-make-group
     "E" gnus-group-edit-group
     "e" gnus-group-edit-group-method
@@ -514,6 +583,7 @@ ticked: The number of ticked articles."
     "w" gnus-group-make-web-group
     "r" gnus-group-rename-group
     "c" gnus-group-customize
+    "x" gnus-group-nnimap-expunge
     "\177" gnus-group-delete-group
     [delete] gnus-group-delete-group)
 
@@ -552,7 +622,9 @@ ticked: The number of ticked articles."
     "d" gnus-group-description-apropos
     "m" gnus-group-list-matching
     "M" gnus-group-list-all-matching
-    "l" gnus-group-list-level)
+    "l" gnus-group-list-level
+    "c" gnus-group-list-cached
+    "?" gnus-group-list-dormant)
 
   (gnus-define-keys (gnus-group-score-map "W" gnus-group-mode-map)
     "f" gnus-score-flush-cache)
@@ -628,7 +700,9 @@ ticked: The number of ticked articles."
         ["Group and description apropos..." gnus-group-description-apropos t]
         ["List groups matching..." gnus-group-list-matching t]
         ["List all groups matching..." gnus-group-list-all-matching t]
-        ["List active file" gnus-group-list-active t])
+        ["List active file" gnus-group-list-active t]
+        ["List groups with cached" gnus-group-list-cached t]
+        ["List groups with dormant" gnus-group-list-dormant t])
        ("Sort"
         ["Default sort" gnus-group-sort-groups t]
         ["Sort by method" gnus-group-sort-groups-by-method t]
@@ -714,7 +788,6 @@ ticked: The number of ticked articles."
         ["Pack packet" gnus-soup-pack-packet (fboundp 'gnus-soup-pack-packet)]
         ["Save areas" gnus-soup-save-areas (fboundp 'gnus-soup-pack-packet)]
         ["Brew SOUP" gnus-group-brew-soup (fboundp 'gnus-soup-pack-packet)])
-       ["Send a bug report" gnus-bug t]
        ["Send a mail" gnus-group-mail t]
        ["Post an article..." gnus-group-post-news t]
        ["Check for new news" gnus-group-get-new-news t]
@@ -765,14 +838,12 @@ The following commands are available:
   (gnus-group-set-mode-line)
   (setq mode-line-process nil)
   (use-local-map gnus-group-mode-map)
-  (buffer-disable-undo (current-buffer))
+  (buffer-disable-undo)
   (setq truncate-lines t)
   (setq buffer-read-only t)
   (gnus-set-default-directory)
   (gnus-update-format-specifications nil 'group 'group-mode)
   (gnus-update-group-mark-positions)
-  (make-local-hook 'post-command-hook)
-  (add-hook 'post-command-hook 'gnus-clear-inboxes-moved nil t)
   (when gnus-use-undo
     (gnus-undo-mode 1))
   (when gnus-slave
@@ -793,9 +864,6 @@ The following commands are available:
             (list (cons 'process (and (search-forward "\200" nil t)
                                       (- (point) 2))))))))
 
-(defun gnus-clear-inboxes-moved ()
-  (setq nnmail-moved-inboxes nil))
-
 (defun gnus-mouse-pick-group (e)
   "Enter the group under the mouse pointer."
   (interactive "e")
@@ -826,6 +894,29 @@ The following commands are available:
     (when gnus-carpal
       (gnus-carpal-setup-buffer 'group))))
 
+(defsubst gnus-group-name-charset (method group)
+  (if (null method)
+      (setq method (gnus-find-method-for-group group)))
+  (let ((item (assoc method gnus-group-name-charset-method-alist))
+        (alist gnus-group-name-charset-group-alist)
+        result)
+    (if item 
+        (cdr item)
+      (while (setq item (pop alist))
+        (if (string-match (car item) group)
+            (setq alist nil
+                  result (cdr item))))
+      result)))
+
+(defsubst gnus-group-name-decode (string charset)
+  (if (and string charset (featurep 'mule))
+      (mm-decode-coding-string string charset)
+    string))
+
+(defun gnus-group-decoded-name (string)
+  (let ((charset (gnus-group-name-charset nil string)))
+    (gnus-group-name-decode string charset)))
+
 (defun gnus-group-list-groups (&optional level unread lowest)
   "List newsgroups with level LEVEL or lower that have unread articles.
 Default is all subscribed groups.
@@ -840,8 +931,6 @@ Also see the `gnus-group-use-permanent-levels' variable."
             (gnus-group-default-level nil t)
             gnus-group-default-list-level
             gnus-level-subscribed))))
-  ;; Just do this here, for no particular good reason.
-  (gnus-clear-inboxes-moved)
   (unless level
     (setq level (car gnus-group-list-mode)
           unread (cdr gnus-group-list-mode)))
@@ -920,7 +1009,7 @@ If REGEXP, only list groups matching REGEXP."
               params (gnus-info-params info)
               newsrc (cdr newsrc)
               unread (car (gnus-gethash group gnus-newsrc-hashtb)))
-        (and unread                     ; This group might be bogus
+        (and unread                     ; This group might be unchecked
              (or (not regexp)
                  (string-match regexp group))
              (<= (setq clevel (gnus-info-level info)) level)
@@ -971,16 +1060,24 @@ If REGEXP, only list groups matching REGEXP."
           (when (string-match regexp group)
             (gnus-add-text-properties
              (point) (prog1 (1+ (point))
-                       (insert " " mark "     *: " group "\n"))
+                       (insert " " mark "     *: "
+                               (gnus-group-name-decode group 
+                                                       (gnus-group-name-charset
+                                                        nil group)) 
+                               "\n"))
              (list 'gnus-group (gnus-intern-safe group gnus-active-hashtb)
                    'gnus-unread t
                    'gnus-level level))))
       ;; This loop is used when listing all groups.
       (while groups
+        (setq group (pop groups))
         (gnus-add-text-properties
          (point) (prog1 (1+ (point))
                    (insert " " mark "     *: "
-                           (setq group (pop groups)) "\n"))
+                           (gnus-group-name-decode group 
+                                                   (gnus-group-name-charset
+                                                    nil group)) 
+                           "\n"))
          (list 'gnus-group (gnus-intern-safe group gnus-active-hashtb)
                'gnus-unread t
                'gnus-level level))))))
@@ -1032,7 +1129,11 @@ If REGEXP, only list groups matching REGEXP."
                                                     gnus-tmp-marked number
                                                     gnus-tmp-method)
   "Insert a group line in the group buffer."
-  (let* ((gnus-tmp-active (gnus-active gnus-tmp-group))
+  (let* ((gnus-tmp-method
+          (gnus-server-get-method gnus-tmp-group gnus-tmp-method)) 
+         (group-name-charset (gnus-group-name-charset gnus-tmp-method
+                                                      gnus-tmp-group))
+         (gnus-tmp-active (gnus-active gnus-tmp-group))
          (gnus-tmp-number-total
           (if gnus-tmp-active
               (1+ (- (cdr gnus-tmp-active) (car gnus-tmp-active)))
@@ -1049,10 +1150,14 @@ If REGEXP, only list groups matching REGEXP."
                 ((<= gnus-tmp-level gnus-level-unsubscribed) ?U)
                 ((= gnus-tmp-level gnus-level-zombie) ?Z)
                 (t ?K)))
-         (gnus-tmp-qualified-group (gnus-group-real-name gnus-tmp-group))
+         (gnus-tmp-qualified-group 
+          (gnus-group-name-decode (gnus-group-real-name gnus-tmp-group)
+                                  group-name-charset))
          (gnus-tmp-newsgroup-description
           (if gnus-description-hashtb
-              (or (gnus-gethash gnus-tmp-group gnus-description-hashtb) "")
+              (or (gnus-group-name-decode
+                   (gnus-gethash gnus-tmp-group gnus-description-hashtb) 
+                   group-name-charset) "")
             ""))
          (gnus-tmp-moderated
           (if (and gnus-moderated-hashtb
@@ -1060,8 +1165,7 @@ If REGEXP, only list groups matching REGEXP."
               ?m ? ))
          (gnus-tmp-moderated-string
           (if (eq gnus-tmp-moderated ?m) "(m)" ""))
-         (gnus-tmp-method
-          (gnus-server-get-method gnus-tmp-group gnus-tmp-method)) ;
+         (gnus-tmp-group-icon "==&&==")
          (gnus-tmp-news-server (or (cadr gnus-tmp-method) ""))
          (gnus-tmp-news-method (or (car gnus-tmp-method) ""))
          (gnus-tmp-news-method-string
@@ -1095,10 +1199,10 @@ If REGEXP, only list groups matching REGEXP."
                   gnus-marked ,gnus-tmp-marked-mark
                   gnus-indentation ,gnus-group-indentation
                   gnus-level ,gnus-tmp-level))
+    (forward-line -1)
     (when (inline (gnus-visual-p 'group-highlight 'highlight))
-      (forward-line -1)
-      (gnus-run-hooks 'gnus-group-update-hook)
-      (forward-line))
+      (gnus-run-hooks 'gnus-group-update-hook))
+    (forward-line)
     ;; Allow XEmacs to remove front-sticky text properties.
     (gnus-group-remove-excess-properties)))
 
@@ -1317,6 +1421,12 @@ If FIRST-TOO, the current line is also eligible as a target."
 
 ;; Group marking.
 
+(defun gnus-group-mark-line-p ()
+  (save-excursion
+    (beginning-of-line)
+    (forward-char (or (cdr (assq 'process gnus-group-mark-positions)) 2))
+    (eq (char-after) gnus-process-mark)))
+
 (defun gnus-group-mark-group (n &optional unmark no-advance)
   "Mark the current group."
   (interactive "p")
@@ -1329,7 +1439,7 @@ If FIRST-TOO, the current line is also eligible as a target."
         (beginning-of-line)
         (forward-char (or (cdr (assq 'process gnus-group-mark-positions)) 2))
         (subst-char-in-region
-         (point) (1+ (point)) (following-char)
+         (point) (1+ (point)) (char-after)
          (if unmark
              (progn
                (setq gnus-group-marked (delete group gnus-group-marked))
@@ -1383,10 +1493,10 @@ If UNMARK, remove the mark instead."
         (gnus-group-set-mark group))))
   (gnus-group-position-point))
 
-(defun gnus-group-remove-mark (group)
+(defun gnus-group-remove-mark (group &optional test-marked)
   "Remove the process mark from GROUP and move point there.
 Return nil if the group isn't displayed."
-  (if (gnus-group-goto-group group)
+  (if (gnus-group-goto-group group nil test-marked)
       (save-excursion
         (gnus-group-mark-group 1 'unmark t)
         t)
@@ -1465,12 +1575,14 @@ Take into consideration N (the prefix) and the list of marked groups."
     (eval
      `(defun gnus-group-iterate (arg ,function)
         "Iterate FUNCTION over all process/prefixed groups.
-FUNCTION will be called with the group name as the paremeter
+FUNCTION will be called with the group name as the parameter
 and with point over the group in question."
         (let ((,groups (gnus-group-process-prefix arg))
               (,window (selected-window))
               ,group)
-          (while (setq ,group (pop ,groups))
+          (while ,groups
+            (setq ,group (car ,groups)
+                  ,groups (cdr ,groups))
             (select-window ,window)
             (gnus-group-remove-mark ,group)
             (save-selected-window
@@ -1565,7 +1677,7 @@ be permanent."
 (defun gnus-fetch-group (group)
   "Start Gnus if necessary and enter GROUP.
 Returns whether the fetching was successful or not."
-  (interactive "sGroup name: ")
+  (interactive (list (completing-read "Group name: " gnus-active-hashtb)))
   (unless (get-buffer gnus-group-buffer)
     (gnus-no-server))
   (gnus-group-read-group nil nil group))
@@ -1597,7 +1709,7 @@ ephemeral group.
 If REQUEST-ONLY, don't actually read the group; just request it.
 If SELECT-ARTICLES, only select those articles.
 
-Return the name of the group is selection was successful."
+Return the name of the group if selection was successful."
   ;; Transform the select method into a unique server.
   (when (stringp method)
     (setq method (gnus-server-to-method method)))
@@ -1654,41 +1766,56 @@ Return the name of the group is selection was successful."
   ;; Adjust cursor point.
   (gnus-group-position-point))
 
-(defun gnus-group-goto-group (group &optional far)
+(defun gnus-group-goto-group (group &optional far test-marked)
   "Goto to newsgroup GROUP.
-If FAR, it is likely that the group is not on the current line."
+If FAR, it is likely that the group is not on the current line.
+If TEST-MARKED, the line must be marked."
   (when group
-    (if far
-        (gnus-goto-char
-         (text-property-any
-          (point-min) (point-max)
-          'gnus-group (gnus-intern-safe group gnus-active-hashtb)))
-      (beginning-of-line)
-      (cond
-       ;; It's quite likely that we are on the right line, so
-       ;; we check the current line first.
-       ((eq (get-text-property (point) 'gnus-group)
-            (gnus-intern-safe group gnus-active-hashtb))
-        (point))
-       ;; Previous and next line are also likely, so we check them as well.
-       ((save-excursion
-          (forward-line -1)
-          (eq (get-text-property (point) 'gnus-group)
-              (gnus-intern-safe group gnus-active-hashtb)))
-        (forward-line -1)
-        (point))
-       ((save-excursion
-          (forward-line 1)
-          (eq (get-text-property (point) 'gnus-group)
-              (gnus-intern-safe group gnus-active-hashtb)))
-        (forward-line 1)
-        (point))
-       (t
-        ;; Search through the entire buffer.
-        (gnus-goto-char
-         (text-property-any
-          (point-min) (point-max)
-          'gnus-group (gnus-intern-safe group gnus-active-hashtb))))))))
+    (beginning-of-line)
+    (cond
+     ;; It's quite likely that we are on the right line, so
+     ;; we check the current line first.
+     ((and (not far)
+           (eq (get-text-property (point) 'gnus-group)
+               (gnus-intern-safe group gnus-active-hashtb))
+           (or (not test-marked) (gnus-group-mark-line-p)))
+      (point))
+     ;; Previous and next line are also likely, so we check them as well.
+     ((and (not far)
+           (save-excursion
+             (forward-line -1)
+             (and (eq (get-text-property (point) 'gnus-group)
+                      (gnus-intern-safe group gnus-active-hashtb))
+                  (or (not test-marked) (gnus-group-mark-line-p)))))
+      (forward-line -1)
+      (point))
+     ((and (not far)
+           (save-excursion
+             (forward-line 1)
+             (and (eq (get-text-property (point) 'gnus-group)
+                      (gnus-intern-safe group gnus-active-hashtb))
+                  (or (not test-marked) (gnus-group-mark-line-p)))))
+      (forward-line 1)
+      (point))
+     (test-marked
+      (goto-char (point-min))
+      (let (found)
+        (while (and (not found) 
+                    (gnus-goto-char
+                     (text-property-any
+                      (point) (point-max)
+                      'gnus-group 
+                      (gnus-intern-safe group gnus-active-hashtb))))
+          (if (gnus-group-mark-line-p)
+              (setq found t)
+            (forward-line 1)))
+        found))
+     (t
+      ;; Search through the entire buffer.
+      (gnus-goto-char
+       (text-property-any
+        (point-min) (point-max)
+        'gnus-group (gnus-intern-safe group gnus-active-hashtb)))))))
 
 (defun gnus-group-next-group (n &optional silent)
   "Go to next N'th newsgroup.
@@ -1804,11 +1931,12 @@ ADDRESS."
     (gnus-read-method "From method: ")))
 
   (when (stringp method)
-    (setq method (gnus-server-to-method method)))
-  (let* ((meth (when (and method
-                          (not (gnus-server-equal method gnus-select-method)))
-                 (if address (list (intern method) address)
-                   method)))
+    (setq method (or (gnus-server-to-method method) method)))
+  (let* ((meth (gnus-method-simplify
+                (when (and method
+                           (not (gnus-server-equal method gnus-select-method)))
+                  (if address (list (intern method) address)
+                    method))))
          (nname (if method (gnus-group-prefixed-name name meth) name))
          backend info)
     (when (gnus-gethash nname gnus-newsrc-hashtb)
@@ -1843,8 +1971,20 @@ ADDRESS."
       (gnus-request-create-group nname nil args))
     t))
 
-(defun gnus-group-delete-group (group &optional force)
-  "Delete the current group.  Only meaningful with mail groups.
+(defun gnus-group-delete-groups (&optional arg)
+  "Delete the current group.  Only meaningful with editable groups."
+  (interactive "P")
+  (let ((n (length (gnus-group-process-prefix arg))))
+    (when (gnus-yes-or-no-p
+           (if (= n 1)
+               "Delete this 1 group? "
+             (format "Delete these %d groups? " n)))
+      (gnus-group-iterate arg
+        (lambda (group)
+          (gnus-group-delete-group group nil t))))))
+
+(defun gnus-group-delete-group (group &optional force no-prompt)
+  "Delete the current group.  Only meaningful with editable groups.
 If FORCE (the prefix) is non-nil, all the articles in the group will
 be deleted.  This is \"deleted\" as in \"removed forever from the face
 of the Earth\".  There is no undo.  The user will be prompted before
@@ -1857,10 +1997,11 @@ doing the deletion."
   (unless (gnus-check-backend-function 'request-delete-group group)
     (error "This backend does not support group deletion"))
   (prog1
-      (if (not (gnus-yes-or-no-p
-                (format
-                 "Do you really want to delete %s%s? "
-                 group (if force " and all its contents" ""))))
+      (if (and (not no-prompt)
+               (not (gnus-yes-or-no-p
+                     (format
+                      "Do you really want to delete %s%s? "
+                      group (if force " and all its contents" "")))))
           ()                            ; Whew!
         (gnus-message 6 "Deleting group %s..." group)
         (if (not (gnus-request-delete-group group force))
@@ -1905,10 +2046,12 @@ and NEW-NAME will be prompted for."
 
   (gnus-message 6 "Renaming group %s to %s..." group new-name)
   (prog1
-      (if (not (gnus-request-rename-group group new-name))
+      (if (progn
+            (gnus-group-goto-group group)
+            (not (when (< (gnus-group-group-level) gnus-level-zombie)
+                   (gnus-request-rename-group group new-name))))
           (gnus-error 3 "Couldn't rename group %s to %s" group new-name)
         ;; We rename the group internally by killing it...
-        (gnus-group-goto-group group)
         (gnus-group-kill-group)
         ;; ... changing its name ...
         (setcar (cdar gnus-list-of-killed-groups) new-name)
@@ -1947,7 +2090,7 @@ and NEW-NAME will be prompted for."
        ((eq part 'method) "select method")
        ((eq part 'params) "group parameters")
        (t "group info"))
-      group)
+      (gnus-group-decoded-name group))
      `(lambda (form)
         (gnus-group-edit-group-done ',part ,group form)))))
 
@@ -2043,6 +2186,7 @@ and NEW-NAME will be prompted for."
                           ((= char ?d) 'digest)
                           ((= char ?f) 'forward)
                           ((= char ?a) 'mmfd)
+                          ((= char ?g) 'guess)
                           (t (setq err (format "%c unknown. " char))
                              nil))))
       (setq type found)))
@@ -2093,6 +2237,42 @@ If SOLID (the prefix), create a solid group."
        (cons (current-buffer)
              (if (eq major-mode 'gnus-summary-mode) 'summary 'group))))))
 
+(defvar nnwarchive-type-definition)
+(defvar gnus-group-warchive-type-history nil)
+(defvar gnus-group-warchive-login-history nil)
+(defvar gnus-group-warchive-address-history nil)
+
+(defun gnus-group-make-warchive-group ()
+  "Create a nnwarchive group."
+  (interactive)
+  (require 'nnwarchive)
+  (let* ((group (gnus-read-group "Group name: "))
+         (default-type (or (car gnus-group-warchive-type-history)
+                           (symbol-name (caar nnwarchive-type-definition))))
+         (type
+          (gnus-string-or
+           (completing-read
+            (format "Warchive type (default %s): " default-type)
+            (mapcar (lambda (elem) (list (symbol-name (car elem))))
+                    nnwarchive-type-definition)
+            nil t nil 'gnus-group-warchive-type-history)
+           default-type))
+         (address (read-string "Warchive address: "
+                               nil 'gnus-group-warchive-address-history))
+         (default-login (or (car gnus-group-warchive-login-history)
+                            user-mail-address))
+         (login
+          (gnus-string-or
+           (read-string
+            (format "Warchive login (default %s): " user-mail-address)
+            default-login 'gnus-group-warchive-login-history)
+           user-mail-address))
+         (method
+          `(nnwarchive ,address 
+                       (nnwarchive-type ,(intern type))
+                       (nnwarchive-login ,login))))
+    (gnus-group-make-group group method)))
+
 (defun gnus-group-make-archive-group (&optional all)
   "Create the (ding) Gnus archive group of the most recent articles.
 Given a prefix, create a full group."
@@ -2157,9 +2337,13 @@ score file entries for articles to include in the group."
         (push (cons header regexps) scores))
       scores)))
   (gnus-group-make-group group "nnkiboze" address)
-  (nnheader-temp-write (gnus-score-file-name (concat "nnkiboze:" group))
-    (let (emacs-lisp-mode-hook)
-      (pp scores (current-buffer)))))
+  (let* ((score-file (gnus-score-file-name (concat "nnkiboze:" group)))
+         (score-dir (file-name-directory score-file)))
+    (unless (file-exists-p score-dir)
+      (make-directory score-dir))
+    (with-temp-file score-file
+      (let (emacs-lisp-mode-hook)
+        (pp scores (current-buffer))))))
 
 (defun gnus-group-add-to-virtual (n vgroup)
   "Add the current group to a virtual group."
@@ -2211,6 +2395,62 @@ score file entries for articles to include in the group."
                        'summary 'group)))
       (error "Couldn't enter %s" dir))))
 
+(eval-and-compile
+  (autoload 'nnimap-expunge "nnimap")
+  (autoload 'nnimap-acl-get "nnimap")
+  (autoload 'nnimap-acl-edit "nnimap"))
+
+(defun gnus-group-nnimap-expunge (group)
+  "Expunge deleted articles in current nnimap GROUP."
+  (interactive (list (gnus-group-group-name)))
+  (let ((mailbox (gnus-group-real-name group)) method)
+    (unless group
+      (error "No group on current line"))
+    (unless (gnus-get-info group)
+      (error "Killed group; can't be edited"))
+    (unless (eq 'nnimap (car (setq method (gnus-find-method-for-group group))))
+      (error "%s is not an nnimap group" group))
+    (nnimap-expunge mailbox (cadr method))))
+
+(defun gnus-group-nnimap-edit-acl (group)
+  "Edit the Access Control List of current nnimap GROUP."
+  (interactive (list (gnus-group-group-name)))
+  (let ((mailbox (gnus-group-real-name group)) method acl)
+    (unless group
+      (error "No group on current line"))
+    (unless (gnus-get-info group)
+      (error "Killed group; can't be edited"))
+    (unless (eq (car (setq method (gnus-find-method-for-group group))) 'nnimap)
+      (error "%s is not an nnimap group" group))
+    (gnus-edit-form (setq acl (nnimap-acl-get mailbox (cadr method)))
+                    (format "Editing the access control list for `%s'.
+
+   An access control list is a list of (identifier . rights) elements.
+
+   The identifier string specifies the corresponding user.  The
+   identifier \"anyone\" is reserved to refer to the universal identity.
+
+   Rights is a string listing a (possibly empty) set of alphanumeric
+   characters, each character listing a set of operations which is being
+   controlled.  Letters are reserved for ``standard'' rights, listed
+   below.  Digits are reserved for implementation or site defined rights.
+
+   l - lookup (mailbox is visible to LIST/LSUB commands)
+   r - read (SELECT the mailbox, perform CHECK, FETCH, PARTIAL,
+       SEARCH, COPY from mailbox)
+   s - keep seen/unseen information across sessions (STORE \\SEEN flag)
+   w - write (STORE flags other than \\SEEN and \\DELETED)
+   i - insert (perform APPEND, COPY into mailbox)
+   p - post (send mail to submission address for mailbox,
+       not enforced by IMAP4 itself)
+   c - create and delete mailbox (CREATE new sub-mailboxes in any
+       implementation-defined hierarchy, RENAME or DELETE mailbox)
+   d - delete messages (STORE \\DELETED flag, perform EXPUNGE)
+   a - administer (perform SETACL)" group)
+                    `(lambda (form)
+                       (nnimap-acl-edit
+                        ,mailbox ',method ',acl form)))))
+
 ;; Group sorting commands
 ;; Suggested by Joe Hildebrand <hildjj@idaho.fuentez.com>.
 
@@ -2302,46 +2542,52 @@ If REVERSE, sort in reverse order."
     ;; Go through all the infos and replace the old entries
     ;; with the new infos.
     (while infos
-      (setcar entries (pop infos))
+      (setcar (car entries) (pop infos))
       (pop entries))
     ;; Update the hashtable.
     (gnus-make-hashtable-from-newsrc-alist)))
 
-(defun gnus-group-sort-selected-groups-by-alphabet (&optional reverse)
+(defun gnus-group-sort-selected-groups-by-alphabet (&optional n reverse)
   "Sort the group buffer alphabetically by group name.
-If REVERSE, sort in reverse order."
-  (interactive "P")
-  (gnus-group-sort-selected-groups 'gnus-group-sort-by-alphabet reverse))
+Obeys the process/prefix convention.  If REVERSE (the symbolic prefix),
+sort in reverse order."
+  (interactive (gnus-interactive "P\ny"))
+  (gnus-group-sort-selected-groups n 'gnus-group-sort-by-alphabet reverse))
 
-(defun gnus-group-sort-selected-groups-by-unread (&optional reverse)
+(defun gnus-group-sort-selected-groups-by-unread (&optional n reverse)
   "Sort the group buffer by number of unread articles.
-If REVERSE, sort in reverse order."
-  (interactive "P")
-  (gnus-group-sort-selected-groups 'gnus-group-sort-by-unread reverse))
+Obeys the process/prefix convention.  If REVERSE (the symbolic prefix),
+sort in reverse order."
+  (interactive (gnus-interactive "P\ny"))
+  (gnus-group-sort-selected-groups n 'gnus-group-sort-by-unread reverse))
 
-(defun gnus-group-sort-selected-groups-by-level (&optional reverse)
+(defun gnus-group-sort-selected-groups-by-level (&optional n reverse)
   "Sort the group buffer by group level.
-If REVERSE, sort in reverse order."
-  (interactive "P")
-  (gnus-group-sort-selected-groups 'gnus-group-sort-by-level reverse))
+Obeys the process/prefix convention.  If REVERSE (the symbolic prefix),
+sort in reverse order."
+  (interactive (gnus-interactive "P\ny"))
+  (gnus-group-sort-selected-groups n 'gnus-group-sort-by-level reverse))
 
-(defun gnus-group-sort-selected-groups-by-score (&optional reverse)
+(defun gnus-group-sort-selected-groups-by-score (&optional n reverse)
   "Sort the group buffer by group score.
-If REVERSE, sort in reverse order."
-  (interactive "P")
-  (gnus-group-sort-selected-groups 'gnus-group-sort-by-score reverse))
+Obeys the process/prefix convention.  If REVERSE (the symbolic prefix),
+sort in reverse order."
+  (interactive (gnus-interactive "P\ny"))
+  (gnus-group-sort-selected-groups n 'gnus-group-sort-by-score reverse))
 
-(defun gnus-group-sort-selected-groups-by-rank (&optional reverse)
+(defun gnus-group-sort-selected-groups-by-rank (&optional n reverse)
   "Sort the group buffer by group rank.
-If REVERSE, sort in reverse order."
-  (interactive "P")
-  (gnus-group-sort-selected-groups 'gnus-group-sort-by-rank reverse))
+Obeys the process/prefix convention.  If REVERSE (the symbolic prefix),
+sort in reverse order."
+  (interactive (gnus-interactive "P\ny"))
+  (gnus-group-sort-selected-groups n 'gnus-group-sort-by-rank reverse))
 
-(defun gnus-group-sort-selected-groups-by-method (&optional reverse)
+(defun gnus-group-sort-selected-groups-by-method (&optional n reverse)
   "Sort the group buffer alphabetically by backend name.
-If REVERSE, sort in reverse order."
-  (interactive "P")
-  (gnus-group-sort-selected-groups 'gnus-group-sort-by-method reverse))
+Obeys the process/prefix convention.  If REVERSE (the symbolic prefix),
+sort in reverse order."
+  (interactive (gnus-interactive "P\ny"))
+  (gnus-group-sort-selected-groups n 'gnus-group-sort-by-method reverse))
 
 ;;; Sorting predicates.
 
@@ -2428,7 +2674,7 @@ If REVERSE, sort in reverse order."
 ;; Group catching up.
 
 (defun gnus-group-catchup-current (&optional n all)
-  "Mark all articles not marked as unread in current newsgroup as read.
+  "Mark all unread articles in the current newsgroup as read.
 If prefix argument N is numeric, the next N newsgroups will be
 caught up.  If ALL is non-nil, marked articles will also be marked as
 read.  Cross references (Xref: header) of articles are ignored.
@@ -2436,7 +2682,8 @@ The number of newsgroups that this function was unable to catch
 up is returned."
   (interactive "P")
   (let ((groups (gnus-group-process-prefix n))
-        (ret 0))
+        (ret 0)
+        group)
     (unless groups (error "No groups selected"))
     (if (not
          (or (not gnus-interactive-catchup) ;Without confirmation?
@@ -2450,21 +2697,20 @@ up is returned."
                    (car groups)
                  (format "these %d groups" (length groups)))))))
         n
-      (while groups
+      (while (setq group (pop groups))
+        (gnus-group-remove-mark group)
         ;; Virtual groups have to be given special treatment.
-        (let ((method (gnus-find-method-for-group (car groups))))
+        (let ((method (gnus-find-method-for-group group)))
           (when (eq 'nnvirtual (car method))
             (nnvirtual-catchup-group
-             (gnus-group-real-name (car groups)) (nth 1 method) all)))
-        (gnus-group-remove-mark (car groups))
-        (if (>= (gnus-group-group-level) gnus-level-zombie)
+             (gnus-group-real-name group) (nth 1 method) all)))
+        (if (>= (gnus-group-level group) gnus-level-zombie)
             (gnus-message 2 "Dead groups can't be caught up")
           (if (prog1
-                  (gnus-group-goto-group (car groups))
-                (gnus-group-catchup (car groups) all))
+                  (gnus-group-goto-group group)
+                (gnus-group-catchup group all))
               (gnus-group-update-group-line)
-            (setq ret (1+ ret))))
-        (setq groups (cdr groups)))
+            (setq ret (1+ ret)))))
       (gnus-group-next-unread-group 1)
       ret)))
 
@@ -2481,6 +2727,8 @@ The return value is the number of articles that were marked as read,
 or nil if no action could be taken."
   (let* ((entry (gnus-gethash group gnus-newsrc-hashtb))
          (num (car entry)))
+    ;; Remove entries for this group.
+    (nnmail-purge-split-history (gnus-group-real-name group))
     ;; Do the updating only if the newsgroup isn't killed.
     (if (not (numberp (car entry)))
         (gnus-message 1 "Can't catch up %s; non-active group" group)
@@ -2513,32 +2761,41 @@ or nil if no action could be taken."
       (error "No groups to expire"))
     (while (setq group (pop groups))
       (gnus-group-remove-mark group)
-      (when (gnus-check-backend-function 'request-expire-articles group)
-        (gnus-message 6 "Expiring articles in %s..." group)
-        (let* ((info (gnus-get-info group))
-               (expirable (if (gnus-group-total-expirable-p group)
-                              (cons nil (gnus-list-of-read-articles group))
-                            (assq 'expire (gnus-info-marks info))))
-               (expiry-wait (gnus-group-find-parameter group 'expiry-wait)))
-          (when expirable
-            (setcdr
-             expirable
-             (gnus-compress-sequence
-              (if expiry-wait
-                  ;; We set the expiry variables to the group
-                  ;; parameter.
-                  (let ((nnmail-expiry-wait-function nil)
-                        (nnmail-expiry-wait expiry-wait))
-                    (gnus-request-expire-articles
-                     (gnus-uncompress-sequence (cdr expirable)) group))
-                ;; Just expire using the normal expiry values.
-                (gnus-request-expire-articles
-                 (gnus-uncompress-sequence (cdr expirable)) group))))
-            (gnus-close-group group))
-          (gnus-message 6 "Expiring articles in %s...done" group)))
+      (gnus-group-expire-articles-1 group)
       (gnus-dribble-touch)
       (gnus-group-position-point))))
 
+(defun gnus-group-expire-articles-1 (group)
+  (when (gnus-check-backend-function 'request-expire-articles group)
+    (gnus-message 6 "Expiring articles in %s..." group)
+    (let* ((info (gnus-get-info group))
+           (expirable (if (gnus-group-total-expirable-p group)
+                          (cons nil (gnus-list-of-read-articles group))
+                        (assq 'expire (gnus-info-marks info))))
+           (expiry-wait (gnus-group-find-parameter group 'expiry-wait))
+           (nnmail-expiry-target
+            (or (gnus-group-find-parameter group 'expiry-target)
+                nnmail-expiry-target)))
+      (when expirable
+        (gnus-check-group group)
+        (setcdr
+         expirable
+         (gnus-compress-sequence
+          (if expiry-wait
+              ;; We set the expiry variables to the group
+              ;; parameter.
+              (let ((nnmail-expiry-wait-function nil)
+                    (nnmail-expiry-wait expiry-wait))
+                (gnus-request-expire-articles
+                 (gnus-uncompress-sequence (cdr expirable)) group))
+            ;; Just expire using the normal expiry values.
+            (gnus-request-expire-articles
+             (gnus-uncompress-sequence (cdr expirable)) group))))
+        (gnus-close-group group))
+      (gnus-message 6 "Expiring articles in %s...done" group)
+      ;; Return the list of un-expired articles.
+      (cdr expirable))))
+
 (defun gnus-group-expire-all-groups ()
   "Expire all expirable articles in all newsgroups."
   (interactive)
@@ -2565,7 +2822,7 @@ or nil if no action could be taken."
                               gnus-level-default-subscribed))
          s)))))
   (unless (and (>= level 1) (<= level gnus-level-killed))
-    (error "Illegal level: %d" level))
+    (error "Invalid level: %d" level))
   (let ((groups (gnus-group-process-prefix n))
         group)
     (while (setq group (pop groups))
@@ -2666,13 +2923,15 @@ N and the number of steps taken is returned."
     (gnus-group-yank-group)
     (gnus-group-position-point)))
 
-(defun gnus-group-kill-all-zombies ()
-  "Kill all zombie newsgroups."
-  (interactive)
-  (setq gnus-killed-list (nconc gnus-zombie-list gnus-killed-list))
-  (setq gnus-zombie-list nil)
-  (gnus-dribble-touch)
-  (gnus-group-list-groups))
+(defun gnus-group-kill-all-zombies (&optional dummy)
+  "Kill all zombie newsgroups.
+The optional DUMMY should always be nil."
+  (interactive (list (not (gnus-yes-or-no-p "Really kill all zombies? "))))
+  (unless dummy
+    (setq gnus-killed-list (nconc gnus-zombie-list gnus-killed-list))
+    (setq gnus-zombie-list nil)
+    (gnus-dribble-touch)
+    (gnus-group-list-groups)))
 
 (defun gnus-group-kill-region (begin end)
   "Kill newsgroups in current region (excluding current point).
@@ -2721,7 +2980,8 @@ of groups killed."
             (push (cons (car entry) (nth 2 entry))
                   gnus-list-of-killed-groups))
           (gnus-group-change-level
-           (if entry entry group) gnus-level-killed (if entry nil level)))
+           (if entry entry group) gnus-level-killed (if entry nil level))
+          (message "Killed group %s" group))
       ;; If there are lots and lots of groups to be killed, we use
       ;; this thing instead.
       (let (entry)
@@ -2807,7 +3067,7 @@ yanked) a list of yanked groups is returned."
       (gnus-make-hashtable-from-newsrc-alist)
       (gnus-group-list-groups)))
    (t
-    (error "Can't kill; illegal level: %d" level))))
+    (error "Can't kill; invalid level: %d" level))))
 
 (defun gnus-group-list-all-groups (&optional arg)
   "List all newsgroups with level ARG or lower.
@@ -2850,7 +3110,8 @@ entail asking the server for the groups."
   (interactive)
   ;; First we make sure that we have really read the active file.
   (unless (gnus-read-active-file-p)
-    (let ((gnus-read-active-file t))
+    (let ((gnus-read-active-file t)
+          (gnus-agent nil))             ; Trick the agent into ignoring the active file.
       (gnus-read-active-file)))
   ;; Find all groups and sort them.
   (let ((groups
@@ -2868,10 +3129,14 @@ entail asking the server for the groups."
         group)
     (erase-buffer)
     (while groups
+      (setq group (pop groups))
       (gnus-add-text-properties
        (point) (prog1 (1+ (point))
                  (insert "       *: "
-                         (setq group (pop groups)) "\n"))
+                         (gnus-group-name-decode group 
+                                                 (gnus-group-name-charset
+                                                  nil group))
+                         "\n"))
        (list 'gnus-group (gnus-intern-safe group gnus-active-hashtb)
              'gnus-unread t
              'gnus-level (inline (gnus-group-level group)))))
@@ -2890,7 +3155,11 @@ If ARG is a number, it specifies which levels you are interested in
 re-scanning.  If ARG is non-nil and not a number, this will force
 \"hard\" re-reading of the active files from all servers."
   (interactive "P")
-  (let ((gnus-inhibit-demon t))
+  (require 'nnmail)
+  (let ((gnus-inhibit-demon t)
+        ;; Binding this variable will inhibit multiple fetchings
+        ;; of the same mail source.
+        (nnmail-fetched-sources (list t)))
     (gnus-run-hooks 'gnus-get-new-news-hook)
 
     ;; Read any slave files.
@@ -2931,7 +3200,12 @@ If N is negative, this group and the N-1 previous groups will be checked."
          (ret (if (numberp n) (- n (length groups)) 0))
          (beg (unless n
                 (point)))
-         group method)
+         group method
+         (gnus-inhibit-demon t)
+         ;; Binding this variable will inhibit multiple fetchings
+         ;; of the same mail source.
+         (nnmail-fetched-sources (list t)))
+    (gnus-run-hooks 'gnus-get-new-news-hook)
     (while (setq group (pop groups))
       (gnus-group-remove-mark group)
       ;; Bypass any previous denials from the server.
@@ -2942,8 +3216,9 @@ If N is negative, this group and the N-1 previous groups will be checked."
              (gnus-get-info group) (gnus-active group) t)
             (unless (gnus-virtual-group-p group)
               (gnus-close-group group))
-            (gnus-agent-save-group-info
-             method (gnus-group-real-name group) (gnus-active group))
+            (when gnus-agent
+              (gnus-agent-save-group-info
+               method (gnus-group-real-name group) (gnus-active group)))
             (gnus-group-update-group group))
         (if (eq (gnus-server-status (gnus-find-method-for-group group))
                 'denied)
@@ -3020,8 +3295,12 @@ to use."
     (mapatoms
      (lambda (group)
        (setq b (point))
-       (insert (format "      *: %-20s %s\n" (symbol-name group)
-                       (symbol-value group)))
+       (let ((charset (gnus-group-name-charset nil (symbol-name group))))
+         (insert (format "      *: %-20s %s\n" 
+                         (gnus-group-name-decode
+                          (symbol-name group) charset)
+                         (gnus-group-name-decode
+                          (symbol-value group) charset))))
        (gnus-add-text-properties
         b (1+ b) (list 'gnus-group group
                        'gnus-unread t 'gnus-marked nil
@@ -3057,17 +3336,19 @@ to use."
       ;; Print out all the groups.
       (save-excursion
         (pop-to-buffer "*Gnus Help*")
-        (buffer-disable-undo (current-buffer))
+        (buffer-disable-undo)
         (erase-buffer)
         (setq groups (sort groups 'string<))
         (while groups
           ;; Groups may be entered twice into the list of groups.
           (when (not (string= (car groups) prev))
-            (insert (setq prev (car groups)) "\n")
-            (when (and gnus-description-hashtb
-                       (setq des (gnus-gethash (car groups)
-                                               gnus-description-hashtb)))
-              (insert "  " des "\n")))
+            (setq prev (car groups))
+            (let ((charset (gnus-group-name-charset nil prev)))
+              (insert (gnus-group-name-decode prev charset) "\n")
+              (when (and gnus-description-hashtb
+                         (setq des (gnus-gethash (car groups)
+                                                 gnus-description-hashtb)))
+                (insert "  " (gnus-group-name-decode des charset) "\n"))))
           (setq groups (cdr groups)))
         (goto-char (point-min))))
     (pop-to-buffer obuf)))
@@ -3267,59 +3548,60 @@ and the second element is the address."
   (gnus-browse-foreign-server method))
 
 (defun gnus-group-set-info (info &optional method-only-group part)
-  (let* ((entry (gnus-gethash
-                 (or method-only-group (gnus-info-group info))
-                 gnus-newsrc-hashtb))
-         (part-info info)
-         (info (if method-only-group (nth 2 entry) info))
-         method)
-    (when method-only-group
+  (when (or info part)
+    (let* ((entry (gnus-gethash
+                   (or method-only-group (gnus-info-group info))
+                   gnus-newsrc-hashtb))
+           (part-info info)
+           (info (if method-only-group (nth 2 entry) info))
+           method)
+      (when method-only-group
+        (unless entry
+          (error "Trying to change non-existent group %s" method-only-group))
+        ;; We have received parts of the actual group info - either the
+        ;; select method or the group parameters.        We first check
+        ;; whether we have to extend the info, and if so, do that.
+        (let ((len (length info))
+              (total (if (eq part 'method) 5 6)))
+          (when (< len total)
+            (setcdr (nthcdr (1- len) info)
+                    (make-list (- total len) nil)))
+          ;; Then we enter the new info.
+          (setcar (nthcdr (1- total) info) part-info)))
       (unless entry
-        (error "Trying to change non-existent group %s" method-only-group))
-      ;; We have received parts of the actual group info - either the
-      ;; select method or the group parameters.  We first check
-      ;; whether we have to extend the info, and if so, do that.
-      (let ((len (length info))
-            (total (if (eq part 'method) 5 6)))
-        (when (< len total)
-          (setcdr (nthcdr (1- len) info)
-                  (make-list (- total len) nil)))
-        ;; Then we enter the new info.
-        (setcar (nthcdr (1- total) info) part-info)))
-    (unless entry
-      ;; This is a new group, so we just create it.
-      (save-excursion
-        (set-buffer gnus-group-buffer)
-        (setq method (gnus-info-method info))
-        (when (gnus-server-equal method "native")
-          (setq method nil))
+        ;; This is a new group, so we just create it.
         (save-excursion
           (set-buffer gnus-group-buffer)
-          (if method
-              ;; It's a foreign group...
-              (gnus-group-make-group
-               (gnus-group-real-name (gnus-info-group info))
-               (if (stringp method) method
-                 (prin1-to-string (car method)))
-               (and (consp method)
-                    (nth 1 (gnus-info-method info))))
-            ;; It's a native group.
-            (gnus-group-make-group (gnus-info-group info))))
-        (gnus-message 6 "Note: New group created")
-        (setq entry
-              (gnus-gethash (gnus-group-prefixed-name
-                             (gnus-group-real-name (gnus-info-group info))
-                             (or (gnus-info-method info) gnus-select-method))
-                            gnus-newsrc-hashtb))))
-    ;; Whether it was a new group or not, we now have the entry, so we
-    ;; can do the update.
-    (if entry
-        (progn
-          (setcar (nthcdr 2 entry) info)
-          (when (and (not (eq (car entry) t))
-                     (gnus-active (gnus-info-group info)))
-            (setcar entry (length (gnus-list-of-unread-articles (car info))))))
-      (error "No such group: %s" (gnus-info-group info)))))
+          (setq method (gnus-info-method info))
+          (when (gnus-server-equal method "native")
+            (setq method nil))
+          (save-excursion
+            (set-buffer gnus-group-buffer)
+            (if method
+                ;; It's a foreign group...
+                (gnus-group-make-group
+                 (gnus-group-real-name (gnus-info-group info))
+                 (if (stringp method) method
+                   (prin1-to-string (car method)))
+                 (and (consp method)
+                      (nth 1 (gnus-info-method info))))
+              ;; It's a native group.
+              (gnus-group-make-group (gnus-info-group info))))
+          (gnus-message 6 "Note: New group created")
+          (setq entry
+                (gnus-gethash (gnus-group-prefixed-name
+                               (gnus-group-real-name (gnus-info-group info))
+                               (or (gnus-info-method info) gnus-select-method))
+                              gnus-newsrc-hashtb))))
+      ;; Whether it was a new group or not, we now have the entry, so we
+      ;; can do the update.
+      (if entry
+          (progn
+            (setcar (nthcdr 2 entry) info)
+            (when (and (not (eq (car entry) t))
+                       (gnus-active (gnus-info-group info)))
+              (setcar entry (length (gnus-list-of-unread-articles (car info))))))
+        (error "No such group: %s" (gnus-info-group info))))))
 
 (defun gnus-group-set-method-info (group select-method)
   (gnus-group-set-info select-method group 'method))
@@ -3329,7 +3611,7 @@ and the second element is the address."
 
 (defun gnus-add-marked-articles (group type articles &optional info force)
   ;; Add ARTICLES of TYPE to the info of GROUP.
-  ;; If INFO is non-nil, use that info.  If FORCE is non-nil, don't
+  ;; If INFO is non-nil, use that info.  If FORCE is non-nil, don't
   ;; add, but replace marked articles of TYPE with ARTICLES.
   (let ((info (or info (gnus-get-info group)))
         marked m)
@@ -3373,8 +3655,8 @@ or `gnus-group-catchup-group-hook'."
 (defun gnus-group-timestamp-delta (group)
   "Return the offset in seconds from the timestamp for GROUP to the current time, as a floating point number."
   (let* ((time (or (gnus-group-timestamp group)
-                  (list 0 0)))
-         (delta (gnus-time-minus (current-time) time)))
+                   (list 0 0)))
+         (delta (subtract-time (current-time) time)))
     (+ (* (nth 0 delta) 65536.0)
        (nth 1 delta))))
 
@@ -3385,6 +3667,118 @@ or `gnus-group-catchup-group-hook'."
         ""
       (gnus-time-iso8601 time))))
 
+(defun gnus-group-prepare-flat-list-dead-predicate 
+  (groups level mark predicate)
+  (let (group)
+    (if predicate
+        ;; This loop is used when listing groups that match some
+        ;; regexp.
+        (while (setq group (pop groups))
+          (when (funcall predicate group)
+            (gnus-add-text-properties
+             (point) (prog1 (1+ (point))
+                       (insert " " mark "     *: " 
+                               (gnus-group-name-decode group 
+                                                       (gnus-group-name-charset
+                                                        nil group))
+                               "\n"))
+             (list 'gnus-group (gnus-intern-safe group gnus-active-hashtb)
+                   'gnus-unread t
+                   'gnus-level level)))))))
+
+(defun gnus-group-prepare-flat-predicate (level predicate &optional lowest
+                                                dead-predicate)
+  "List all newsgroups with unread articles of level LEVEL or lower.
+If LOWEST is non-nil, list all newsgroups of level LOWEST or higher.
+If PREDICATE, only list groups which PREDICATE returns non-nil.
+If DEAD-PREDICATE, list dead groups which DEAD-PREDICATE returns non-nil."
+  (set-buffer gnus-group-buffer)
+  (let ((buffer-read-only nil)
+        (newsrc (cdr gnus-newsrc-alist))
+        (lowest (or lowest 1))
+        info clevel unread group params)
+    (erase-buffer)
+    ;; List living groups.
+    (while newsrc
+      (setq info (car newsrc)
+            group (gnus-info-group info)
+            params (gnus-info-params info)
+            newsrc (cdr newsrc)
+            unread (car (gnus-gethash group gnus-newsrc-hashtb)))
+      (and unread                       ; This group might be unchecked
+           (funcall predicate info)
+           (<= (setq clevel (gnus-info-level info)) level)
+           (>= clevel lowest)
+           (gnus-group-insert-group-line
+            group (gnus-info-level info)
+            (gnus-info-marks info) unread (gnus-info-method info))))
+
+    ;; List dead groups.
+    (and (>= level gnus-level-zombie) (<= lowest gnus-level-zombie)
+         (gnus-group-prepare-flat-list-dead-predicate
+          (setq gnus-zombie-list (sort gnus-zombie-list 'string<))
+          gnus-level-zombie ?Z
+          dead-predicate))
+    (and (>= level gnus-level-killed) (<= lowest gnus-level-killed)
+         (gnus-group-prepare-flat-list-dead-predicate
+          (setq gnus-killed-list (sort gnus-killed-list 'string<))
+          gnus-level-killed ?K dead-predicate))
+
+    (gnus-group-set-mode-line)
+    (setq gnus-group-list-mode (cons level t))
+    (gnus-run-hooks 'gnus-group-prepare-hook)
+    t))
+
+(defun gnus-group-list-cached (level &optional lowest)
+  "List all groups with cached articles.
+If the prefix LEVEL is non-nil, it should be a number that says which
+level to cut off listing groups.
+If LOWEST, don't list groups with level lower than LOWEST.
+
+This command may read the active file."
+  (interactive "P")
+  (when level
+    (setq level (prefix-numeric-value level)))
+  (when (or (not level) (>= level gnus-level-zombie))
+    (gnus-cache-open))
+  (gnus-group-prepare-flat-predicate (or level gnus-level-subscribed)
+                                #'(lambda (info)
+                                    (let ((marks (gnus-info-marks info)))
+                                      (assq 'cache marks)))
+                                lowest
+                                #'(lambda (group)
+                                    (or (gnus-gethash group 
+                                                      gnus-cache-active-hashtb)
+                                        ;; Cache active file might use "." 
+                                        ;; instead of ":".
+                                        (gnus-gethash 
+                                         (mapconcat 'identity
+                                                    (split-string group ":")
+                                                    ".")
+                                         gnus-cache-active-hashtb))))
+  (goto-char (point-min))
+  (gnus-group-position-point))
+
+(defun gnus-group-list-dormant (level &optional lowest)
+  "List all groups with dormant articles.
+If the prefix LEVEL is non-nil, it should be a number that says which
+level to cut off listing groups.
+If LOWEST, don't list groups with level lower than LOWEST.
+
+This command may read the active file."
+  (interactive "P")
+  (when level
+    (setq level (prefix-numeric-value level)))
+  (when (or (not level) (>= level gnus-level-zombie))
+    (gnus-cache-open))
+  (gnus-group-prepare-flat-predicate (or level gnus-level-subscribed)
+                                #'(lambda (info)
+                                    (let ((marks (gnus-info-marks info)))
+                                      (assq 'dormant marks)))
+                                lowest)
+  (goto-char (point-min))
+  (gnus-group-position-point))
+
 (provide 'gnus-group)
 
 ;;; gnus-group.el ends here
diff --git a/lisp/gnus/gnus-msg.el b/lisp/gnus/gnus-msg.el
index 992eac52c4a..7f80f8ea049 100644
--- a/lisp/gnus/gnus-msg.el
+++ b/lisp/gnus/gnus-msg.el
@@ -1,5 +1,6 @@
 ;;; gnus-msg.el --- mail and post interface for Gnus
-;; Copyright (C) 1995,96,97,98 Free Software Foundation, Inc.
+;; Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000
+;;        Free Software Foundation, Inc.
 
 ;; Author: Masanobu UMEDA <umerin@flab.flab.fujitsu.junet>
 ;;      Lars Magne Ingebrigtsen <larsi@gnus.org>
@@ -28,26 +29,24 @@
 
 (eval-when-compile (require 'cl))
 
-(eval-when-compile (require 'cl))
-
 (require 'gnus)
 (require 'gnus-ems)
 (require 'message)
 (require 'gnus-art)
 
-(defcustom gnus-post-method nil
+(defcustom gnus-post-method 'current
   "*Preferred method for posting USENET news.
 
 If this variable is `current', Gnus will use the \"current\" select
 method when posting.  If it is nil (which is the default), Gnus will
-use the native posting method of the server.
+use the native select method when posting.
 
 This method will not be used in mail groups and the like, only in
 \"real\" newsgroups.
 
 If not nil nor `native', the value must be a valid method as discussed
-in the documentation of `gnus-select-method'. It can also be a list of
-methods. If that is the case, the user will be queried for what select
+in the documentation of `gnus-select-method'.  It can also be a list of
+methods.  If that is the case, the user will be queried for what select
 method to use when posting."
   :group 'gnus-group-foreign
   :type `(choice (const nil)
@@ -102,13 +101,37 @@ the second with the current group name.")
 (defvar gnus-posting-styles nil
   "*Alist of styles to use when posting.")
 
-(defvar gnus-posting-style-alist
-  '((organization . message-user-organization)
-    (signature . message-signature)
-    (signature-file . message-signature-file)
-    (address . user-mail-address)
-    (name . user-full-name))
-  "*Mapping from style parameters to variables.")
+(defcustom gnus-group-posting-charset-alist
+  '(("^\\(no\\|fr\\|dk\\)\\.[^,]*\\(,[ \t\n]*\\(no\\|fr\\|dk\\)\\.[^,]*\\)*$" iso-8859-1 (iso-8859-1))
+    ("^\\(fido7\\|relcom\\)\\.[^,]*\\(,[ \t\n]*\\(fido7\\|relcom\\)\\.[^,]*\\)*$" koi8-r (koi8-r))
+    (message-this-is-mail nil nil)
+    (message-this-is-news nil t))
+  "Alist of regexps and permitted unencoded charsets for posting.
+Each element of the alist has the form (TEST HEADER BODY-LIST), where
+TEST is either a regular expression matching the newsgroup header or a
+variable to query,
+HEADER is the charset which may be left unencoded in the header (nil
+means encode all charsets),
+BODY-LIST is a list of charsets which may be encoded using 8bit
+content-transfer encoding in the body, or one of the special values
+nil (always encode using quoted-printable) or t (always use 8bit).
+
+Note that any value other than nil for HEADER infringes some RFCs, so
+use this option with care."
+  :type '(repeat (list :tag "Permitted unencoded charsets"
+                  (choice :tag "Where"
+                   (regexp :tag "Group")
+                   (const :tag "Mail message" :value message-this-is-mail)
+                   (const :tag "News article" :value message-this-is-news))
+                  (choice :tag "Header"
+                   (const :tag "None" nil)
+                   (symbol :tag "Charset"))
+                  (choice :tag "Body"
+                          (const :tag "Any" :value t)
+                          (const :tag "None" :value nil)
+                          (repeat :tag "Charsets"
+                                  (symbol :tag "Charset")))))
+  :group 'gnus-charset)
 
 ;;; Internal variables.
 
@@ -127,9 +150,10 @@ the second with the current group name.")
 The buffer below is a mail buffer.  When you press `C-c C-c', it will
 be sent to the Gnus Bug Exterminators.
 
-At the bottom of the buffer you'll see lots of variable settings.
-Please do not delete those.  They will tell the Bug People what your
-environment is, so that it will be easier to locate the bugs.
+The thing near the bottom of the buffer is how the environment
+settings will be included in the mail.  Please do not delete that.
+They will tell the Bug People what your environment is, so that it
+will be easier to locate the bugs.
 
 If you have found a bug that makes Emacs go \"beep\", set
 debug-on-error to t (`M-x set-variable RET debug-on-error RET t RET')
@@ -159,6 +183,7 @@ Thank you for your help in stamping out bugs.
   "c" gnus-summary-cancel-article
   "s" gnus-summary-supersede-article
   "r" gnus-summary-reply
+  "y" gnus-summary-yank-message
   "R" gnus-summary-reply-with-original
   "w" gnus-summary-wide-reply
   "W" gnus-summary-wide-reply-with-original
@@ -177,6 +202,20 @@ Thank you for your help in stamping out bugs.
   ;; "c" gnus-summary-send-draft
   "r" gnus-summary-resend-message)
 
+;;;###autoload
+(defun gnus-msg-mail (&rest args)
+  "Start editing a mail message to be sent.
+Like `message-mail', but with Gnus paraphernalia, particularly the
+the Gcc: header for archiving purposes."
+  (interactive)
+  (gnus-setup-message 'message
+    (apply 'message-mail args)))
+
+;;;###autoload
+(define-mail-user-agent 'gnus-user-agent
+      'gnus-msg-mail 'message-send-and-exit
+      'message-kill-buffer 'message-send-hook)
+
 ;;; Internal functions.
 
 (defvar gnus-article-reply nil)
@@ -191,7 +230,9 @@ Thank you for your help in stamping out bugs.
            (,group gnus-newsgroup-name)
            (message-header-setup-hook
             (copy-sequence message-header-setup-hook))
+           (mbl mml-buffer-list)
            (message-mode-hook (copy-sequence message-mode-hook)))
+       (setq mml-buffer-list nil)
        (add-hook 'message-header-setup-hook 'gnus-inews-insert-gcc)
        (add-hook 'message-header-setup-hook 'gnus-inews-insert-archive-gcc)
        (add-hook 'message-mode-hook 'gnus-configure-posting-styles)
@@ -202,12 +243,37 @@ Thank you for your help in stamping out bugs.
          (setq gnus-message-buffer (current-buffer))
          (set (make-local-variable 'gnus-message-group-art)
               (cons ,group ,article))
-         (make-local-variable 'gnus-newsgroup-name)
-         (gnus-run-hooks 'gnus-message-setup-hook))
+         (set (make-local-variable 'gnus-newsgroup-name) ,group)
+         (gnus-run-hooks 'gnus-message-setup-hook)
+         (if (eq major-mode 'message-mode)
+             ;; Make mml-buffer-list local.
+             ;; Restore global mml-buffer-list value as mbl.
+             ;; What a hack! -- Shenghuo
+             (let ((mml-buffer-list mml-buffer-list))
+               (setq mml-buffer-list mbl)
+               (make-local-variable 'mml-buffer-list)
+               (add-hook 'kill-buffer-hook 'mml-destroy-buffers t t))
+           (mml-destroy-buffers)
+           (setq mml-buffer-list mbl)))
        (gnus-add-buffer)
        (gnus-configure-windows ,config t)
        (set-buffer-modified-p nil))))
 
+(defun gnus-setup-posting-charset (group)
+  (let ((alist gnus-group-posting-charset-alist)
+        (group (or group ""))
+        elem)
+    (when group
+      (catch 'found
+        (while (setq elem (pop alist))
+          (when (or (and (stringp (car elem))
+                         (string-match (car elem) group))
+                    (and (gnus-functionp (car elem))
+                         (funcall (car elem) group))
+                    (and (symbolp (car elem))
+                         (symbol-value (car elem))))
+            (throw 'found (cons (cadr elem) (caddr elem)))))))))
+
 (defun gnus-inews-add-send-actions (winconf buffer article)
   (make-local-hook 'message-sent-hook)
   (add-hook 'message-sent-hook 'gnus-inews-do-gcc nil t)
@@ -230,11 +296,29 @@ Thank you for your help in stamping out bugs.
 
 ;;; Post news commands of Gnus group mode and summary mode
 
-(defun gnus-group-mail ()
-  "Start composing a mail."
-  (interactive)
-  (gnus-setup-message 'message
-    (message-mail)))
+(defun gnus-group-mail (&optional arg)
+  "Start composing a mail.
+If ARG, use the group under the point to find a posting style.
+If ARG is 1, prompt for a group name to find the posting style."
+  (interactive "P")
+  ;; We can't `let' gnus-newsgroup-name here, since that leads
+  ;; to local variables leaking.
+  (let ((group gnus-newsgroup-name)
+        (buffer (current-buffer)))
+    (unwind-protect
+        (progn
+          (setq gnus-newsgroup-name
+                (if arg
+                    (if (= 1 (prefix-numeric-value arg))
+                        (completing-read "Use posting style of group: "
+                                         gnus-active-hashtb nil
+                                         (gnus-read-active-file-p))
+                      (gnus-group-group-name))
+                  ""))
+          (gnus-setup-message 'message (message-mail)))
+      (save-excursion
+        (set-buffer buffer)
+        (setq gnus-newsgroup-name group)))))
 
 (defun gnus-group-post-news (&optional arg)
   "Start composing a news message.
@@ -355,7 +439,9 @@ header line with the old Message-ID."
   ;; if ARTICLE-BUFFER is nil, gnus-article-buffer is used
   ;; this buffer should be passed to all mail/news reply/post routines.
   (setq gnus-article-copy (gnus-get-buffer-create " *gnus article copy*"))
-  (buffer-disable-undo gnus-article-copy)
+  (save-excursion
+    (set-buffer gnus-article-copy)
+    (mm-enable-multibyte))
   (let ((article-buffer (or article-buffer gnus-article-buffer))
         end beg)
     (if (not (and (get-buffer article-buffer)
@@ -374,7 +460,7 @@ header line with the old Message-ID."
           (gnus-remove-text-with-property 'gnus-next)
           (insert
            (prog1
-               (format "%s" (buffer-string))
+               (buffer-substring-no-properties (point-min) (point-max))
              (erase-buffer)))
           ;; Find the original headers.
           (set-buffer gnus-original-article-buffer)
@@ -386,10 +472,10 @@ header line with the old Message-ID."
           ;; Delete the headers from the displayed articles.
           (set-buffer gnus-article-copy)
           (delete-region (goto-char (point-min))
-                         (or (search-forward "\n\n" nil t) (point)))
+                         (or (search-forward "\n\n" nil t) (point-max)))
           ;; Insert the original article headers.
           (insert-buffer-substring gnus-original-article-buffer beg end)
-          (gnus-article-decode-rfc1522)))
+          (article-decode-encoded-words)))
       gnus-article-copy)))
 
 (defun gnus-post-news (post &optional group header article-buffer yank subject
@@ -402,6 +488,7 @@ header line with the old Message-ID."
                               (article-buffer 'reply)
                               (t 'message))
       (let* ((group (or group gnus-newsgroup-name))
+             (charset (gnus-group-name-charset nil group))
              (pgroup group)
              to-address to-group mailing-list to-list
              newsgroup-p)
@@ -412,7 +499,8 @@ header line with the old Message-ID."
                 newsgroup-p (gnus-group-find-parameter group 'newsgroup)
                 mailing-list (when gnus-mailing-list-groups
                                (string-match gnus-mailing-list-groups group))
-                group (gnus-group-real-name group)))
+                group (gnus-group-name-decode (gnus-group-real-name group)
+                                              charset)))
         (if (or (and to-group
                      (gnus-news-group-p to-group))
                 newsgroup-p
@@ -464,7 +552,7 @@ If SILENT, don't prompt the user."
      ;; the default method.
      ((null group-method)
       (or (and (null (eq gnus-post-method 'active)) gnus-post-method)
-               gnus-select-method message-post-method))
+          gnus-select-method message-post-method))
      ;; We want the inverse of the default
      ((and arg (not (eq arg 0)))
       (if (eq gnus-post-method 'active)
@@ -485,14 +573,16 @@ If SILENT, don't prompt the user."
                    (list gnus-post-method)))
                gnus-secondary-select-methods
                (mapcar 'cdr gnus-server-alist)
+               (mapcar 'car gnus-opened-servers)
                (list gnus-select-method)
                (list group-method)))
              method-alist post-methods method)
         ;; Weed out all mail methods.
         (while methods
           (setq method (gnus-server-get-method "" (pop methods)))
-          (when (or (gnus-method-option-p method 'post)
-                    (gnus-method-option-p method 'post-mail))
+          (when (and (or (gnus-method-option-p method 'post)
+                         (gnus-method-option-p method 'post-mail))
+                     (not (member method post-methods)))
             (push method post-methods)))
         ;; Create a name-method alist.
         (setq method-alist
@@ -515,8 +605,9 @@ If SILENT, don't prompt the user."
      ;; Override normal method.
      ((and (eq gnus-post-method 'current)
            (not (eq (car group-method) 'nndraft))
+           (gnus-get-function group-method 'request-post t)
            (not arg))
-      group-method) 
+      group-method)
      ((and gnus-post-method
            (not (eq gnus-post-method 'current)))
       gnus-post-method)
@@ -525,69 +616,32 @@ If SILENT, don't prompt the user."
 
 
 
-;; Dummy to avoid byte-compile warning.
+;; Dummies to avoid byte-compile warning.
 (defvar nnspool-rejected-article-hook)
 (defvar xemacs-codename)
 
-;;; Since the X-Newsreader/X-Mailer are ``vanity'' headers, they might
-;;; as well include the Emacs version as well.
-;;; The following function works with later GNU Emacs, and XEmacs.
 (defun gnus-extended-version ()
   "Stringified Gnus version and Emacs version."
   (interactive)
   (concat
-   gnus-version
-   "/"
+   "Gnus/" (prin1-to-string (gnus-continuum-version gnus-version) t)
+   " (" gnus-version ")"
+   " "
    (cond
-    ((string-match "^\\([0-9]+\\.[0-9]+\\)\\.[.0-9]+$" emacs-version)
-     (concat "Emacs " (substring emacs-version
-                                 (match-beginning 1)
-                                 (match-end 1))))
+    ((string-match "^\\(\\([.0-9]+\\)*\\)\\.[0-9]+$" emacs-version)
+     (concat "Emacs/" (match-string 1 emacs-version)))
     ((string-match "\\([A-Z]*[Mm][Aa][Cc][Ss]\\)[^(]*\\(\\((beta.*)\\|'\\)\\)?"
                    emacs-version)
-     (concat (substring emacs-version
-                        (match-beginning 1)
-                        (match-end 1))
-             (format " %d.%d" emacs-major-version emacs-minor-version)
+     (concat (match-string 1 emacs-version)
+             (format "/%d.%d" emacs-major-version emacs-minor-version)
              (if (match-beginning 3)
-                 (substring emacs-version
-                            (match-beginning 3)
-                            (match-end 3))
+                 (match-string 3 emacs-version)
                "")
              (if (boundp 'xemacs-codename)
-                 (concat " - \"" xemacs-codename "\""))))
+                 (concat " (" xemacs-codename ")")
+               "")))
     (t emacs-version))))
 
-;; Written by "Mr. Per Persson" <pp@gnu.org>.
-(defun gnus-inews-insert-mime-headers ()
-  "Insert MIME headers.
-Assumes ISO-Latin-1 is used iff 8-bit characters are present."
-  (goto-char (point-min))
-  (let ((mail-header-separator
-         (progn
-           (goto-char (point-min))
-           (if (and (search-forward (concat "\n" mail-header-separator "\n")
-                                    nil t)
-                    (not (search-backward "\n\n" nil t)))
-               mail-header-separator
-             ""))))
-    (or (mail-position-on-field "Mime-Version")
-        (insert "1.0")
-        (cond ((save-restriction
-                 (widen)
-                 (goto-char (point-min))
-                 (re-search-forward "[^\000-\177]" nil t))
-               (or (mail-position-on-field "Content-Type")
-                   (insert "text/plain; charset=ISO-8859-1"))
-               (or (mail-position-on-field "Content-Transfer-Encoding")
-                   (insert "8bit")))
-              (t (or (mail-position-on-field "Content-Type")
-                     (insert "text/plain; charset=US-ASCII"))
-                 (or (mail-position-on-field "Content-Transfer-Encoding")
-                     (insert "7bit")))))))
-
-(custom-add-option 'message-header-hook 'gnus-inews-insert-mime-headers)
-
 
 ;;;
 ;;; Gnus Mail Functions
@@ -610,6 +664,10 @@ automatically."
       (gnus-summary-select-article)
       (set-buffer (gnus-copy-article-buffer))
       (gnus-msg-treat-broken-reply-to)
+      (save-restriction
+        (message-narrow-to-head)
+        (goto-char (point-max)))
+      (mml-quote-region (point) (point-max))
       (message-reply nil wide)
       (when yank
         (gnus-inews-yank-articles yank)))))
@@ -635,16 +693,50 @@ The original article will be yanked."
   (interactive "P")
   (gnus-summary-reply-with-original n t))
 
-(defun gnus-summary-mail-forward (&optional full-headers post)
-  "Forward the current message to another user.
-If FULL-HEADERS (the prefix), include full headers when forwarding."
+(defun gnus-summary-mail-forward (&optional arg post)
+  "Forward the current message to another user.  
+If ARG is nil, see `message-forward-as-mime' and `message-forward-show-mml';
+if ARG is 1, decode the message and forward directly inline;
+if ARG is 2, foward message as an rfc822 MIME section;
+if ARG is 3, decode message and forward as an rfc822 MIME section;
+if ARG is 4, foward message directly inline;
+otherwise, use flipped `message-forward-as-mime'.
+If POST, post instead of mail."
   (interactive "P")
-  (gnus-setup-message 'forward
-    (gnus-summary-select-article)
-    (set-buffer gnus-original-article-buffer)
-    (let ((message-included-forward-headers
-           (if full-headers "" message-included-forward-headers)))
-      (message-forward post))))
+  (let ((message-forward-as-mime message-forward-as-mime)
+        (message-forward-show-mml message-forward-show-mml))
+    (cond 
+     ((null arg))
+     ((eq arg 1) (setq message-forward-as-mime nil
+                       message-forward-show-mml t))
+     ((eq arg 2) (setq message-forward-as-mime t
+                       message-forward-show-mml nil))
+     ((eq arg 3) (setq message-forward-as-mime t
+                       message-forward-show-mml t))
+     ((eq arg 4) (setq message-forward-as-mime nil
+                       message-forward-show-mml nil))
+     (t (setq message-forward-as-mime (not message-forward-as-mime))))
+    (gnus-setup-message 'forward
+      (gnus-summary-select-article)
+      (let ((mail-parse-charset gnus-newsgroup-charset)
+            (mail-parse-ignored-charsets gnus-newsgroup-ignored-charsets)
+            text)
+        (save-excursion
+          (set-buffer gnus-original-article-buffer)
+          (setq text (buffer-string)))
+        (set-buffer 
+         (gnus-get-buffer-create
+          (generate-new-buffer-name " *Gnus forward*")))
+        (erase-buffer)
+        (unless message-forward-show-mml
+          (mm-disable-multibyte))
+        (insert text)
+        (goto-char (point-min))
+        (when (looking-at "From ")
+          (replace-match "X-From-Line: ") )
+        (when message-forward-show-mml
+          (mime-to-mml))
+        (message-forward post)))))
 
 (defun gnus-summary-resend-message (address n)
   "Resend the current article to ADDRESS."
@@ -657,11 +749,11 @@ If FULL-HEADERS (the prefix), include full headers when forwarding."
         (set-buffer gnus-original-article-buffer)
         (message-resend address)))))
 
-(defun gnus-summary-post-forward (&optional full-headers)
+(defun gnus-summary-post-forward (&optional arg)
   "Forward the current article to a newsgroup.
-If FULL-HEADERS (the prefix), include full headers when forwarding."
+See `gnus-summary-mail-forward' for ARG."
   (interactive "P")
-  (gnus-summary-mail-forward full-headers t))
+  (gnus-summary-mail-forward arg t))
 
 (defvar gnus-nastygram-message
   "The following article was inappropriately posted to %s.\n\n"
@@ -694,7 +786,8 @@ The current group name will be inserted at \"%s\".")
         (gnus-summary-select-article)
         (set-buffer gnus-original-article-buffer)
         (if (and (<= (length (message-tokenize-header
-                              (setq newsgroups (mail-fetch-field "newsgroups"))
+                              (setq newsgroups
+                                    (mail-fetch-field "newsgroups"))
                               ", "))
                      1)
                  (or (not (setq followup-to (mail-fetch-field "followup-to")))
@@ -833,7 +926,12 @@ If YANK is non-nil, include the original article."
                (stringp nntp-server-type))
       (insert nntp-server-type))
     (insert "\n\n\n\n\n")
-    (gnus-debug)
+    (let (text)
+      (save-excursion
+        (set-buffer (gnus-get-buffer-create " *gnus environment info*"))
+        (gnus-debug)
+        (setq text (buffer-string)))
+      (insert "<#part type=application/x-emacs-lisp disposition=inline description=\"User settings\">\n" text "\n<#/part>"))
     (goto-char (point-min))
     (search-forward "Subject: " nil t)
     (message "")))
@@ -842,6 +940,19 @@ If YANK is non-nil, include the original article."
   (when (get-buffer "*Gnus Help Bug*")
     (kill-buffer "*Gnus Help Bug*")))
 
+(defun gnus-summary-yank-message (buffer n)
+  "Yank the current article into a composed message."
+  (interactive
+   (list (completing-read "Buffer: " (mapcar 'list (message-buffers)) nil t)
+         current-prefix-arg))
+  (gnus-summary-iterate n
+    (let ((gnus-display-mime-function nil)
+          (gnus-inhibit-treatment t))
+      (gnus-summary-select-article))
+    (save-excursion
+      (set-buffer buffer)
+      (message-yank-buffer gnus-article-buffer))))
+
 (defun gnus-debug ()
   "Attempts to go through the Gnus source file and report what variables have been changed.
 The source file has to be in the Emacs load path."
@@ -857,7 +968,6 @@ The source file has to be in the Emacs load path."
     ;; Go through all the files looking for non-default values for variables.
     (save-excursion
       (set-buffer (gnus-get-buffer-create " *gnus bug info*"))
-      (buffer-disable-undo (current-buffer))
       (while files
         (erase-buffer)
         (when (and (setq file (locate-library (pop files)))
@@ -940,7 +1050,8 @@ this is a reply."
           (when gcc
             (message-remove-header "gcc")
             (widen)
-            (setq groups (message-tokenize-header gcc " ,"))
+            (setq groups (message-unquote-tokens
+                          (message-tokenize-header gcc " ,")))
             ;; Copy the article over to some group(s).
             (while (setq group (pop groups))
               (gnus-check-server
@@ -964,12 +1075,20 @@ this is a reply."
               (save-excursion
                 (nnheader-set-temp-buffer " *acc*")
                 (insert-buffer-substring cur)
+                (message-encode-message-body)
+                (save-restriction
+                  (message-narrow-to-headers)
+                  (let ((mail-parse-charset message-default-charset)
+                        (rfc2047-header-encoding-alist
+                         (cons '("Newsgroups" . default)
+                               rfc2047-header-encoding-alist)))
+                    (mail-encode-encoded-word-buffer)))
                 (goto-char (point-min))
                 (when (re-search-forward
                        (concat "^" (regexp-quote mail-header-separator) "$")
                        nil t)
                   (replace-match "" t t ))
-                (unless (gnus-request-accept-article group method t)
+                (unless (gnus-request-accept-article group method t t)
                   (gnus-message 1 "Couldn't store article in group %s: %s"
                                 group (gnus-status-message method))
                   (sit-for 2))
@@ -998,9 +1117,10 @@ this is a reply."
          (group (or group gnus-newsgroup-name ""))
          (gcc-self-val
           (and gnus-newsgroup-name
+               (not (equal gnus-newsgroup-name ""))
                (gnus-group-find-parameter
                 gnus-newsgroup-name 'gcc-self)))
-         result 
+         result
          (groups
           (cond
            ((null gnus-message-archive-method)
@@ -1068,86 +1188,131 @@ this is a reply."
 
 ;;; Posting styles.
 
-(defvar gnus-message-style-insertions nil)
-
 (defun gnus-configure-posting-styles ()
   "Configure posting styles according to `gnus-posting-styles'."
   (unless gnus-inhibit-posting-styles
-    (let ((styles gnus-posting-styles)
-          (gnus-newsgroup-name (or gnus-newsgroup-name ""))
-          style match variable attribute value value-value)
-      (make-local-variable 'gnus-message-style-insertions)
+    (let ((group (or gnus-newsgroup-name ""))
+          (styles gnus-posting-styles)
+          style match variable attribute value v results
+          filep name address element)
+      ;; If the group has a posting-style parameter, add it at the end with a
+      ;; regexp matching everything, to be sure it takes precedence over all
+      ;; the others.
+      (when gnus-newsgroup-name
+        (let ((tmp-style (gnus-group-find-parameter group 'posting-style t)))
+          (when tmp-style
+            (setq styles (append styles (list (cons ".*" tmp-style)))))))
       ;; Go through all styles and look for matches.
-      (while styles
-        (setq style (pop styles)
-              match (pop style))
-        (when (cond ((stringp match)
-                     ;; Regexp string match on the group name.
-                     (string-match match gnus-newsgroup-name))
-                    ((or (symbolp match)
-                         (gnus-functionp match))
-                     (cond ((gnus-functionp match)
-                            ;; Function to be called.
-                            (funcall match))
-                           ((boundp match)
-                            ;; Variable to be checked.
-                            (symbol-value match))))
-                    ((listp match)
-                     ;; This is a form to be evaled.
-                     (eval match)))
+      (dolist (style styles)
+        (setq match (pop style))
+        (goto-char (point-min))
+        (when (cond
+               ((stringp match)
+                ;; Regexp string match on the group name.
+                (string-match match group))
+               ((eq match 'header)
+                (let ((header (message-fetch-field (pop style))))
+                  (and header
+                       (string-match (pop style) header))))
+               ((or (symbolp match)
+                    (gnus-functionp match))
+                (cond
+                 ((gnus-functionp match)
+                  ;; Function to be called.
+                  (funcall match))
+                 ((boundp match)
+                  ;; Variable to be checked.
+                  (symbol-value match))))
+               ((listp match)
+                ;; This is a form to be evaled.
+                (eval match)))
           ;; We have a match, so we set the variables.
-          (while style
-            (setq attribute (pop style)
-                  value (cadr attribute)
-                  variable nil)
-            ;; We find the variable that is to be modified.
-            (if (and (not (stringp (car attribute)))
-                     (not (eq 'body (car attribute)))
-                     (not (setq variable
-                                (cdr (assq (car attribute) 
-                                           gnus-posting-style-alist)))))
-                (message "Couldn't find attribute %s" (car attribute))
-              ;; We get the value.
-              (setq value-value
-                    (cond ((stringp value)
-                           value)
-                          ((or (symbolp value)
-                               (gnus-functionp value))
-                           (cond ((gnus-functionp value)
-                                  (funcall value))
-                                 ((boundp value)
-                                  (symbol-value value))))
-                          ((listp value)
-                           (eval value))))
-              (if variable
-                  ;; This is an ordinary variable.
-                  (set (make-local-variable variable) value-value)
-                ;; This is either a body or a header to be inserted in the
-                ;; message.
-                (when value-value
-                  (let ((attr (car attribute)))
-                    (make-local-variable 'message-setup-hook)
-                    (if (eq 'body attr)
-                        (add-hook 'message-setup-hook
-                                  `(lambda ()
-                                     (save-excursion
-                                       (message-goto-body)
-                                       (insert ,value-value))))
-                      (add-hook 'message-setup-hook
-                                'gnus-message-insert-stylings)
-                      (push (cons (if (stringp attr) attr
-                                    (symbol-name attr))
-                                  value-value)
-                            gnus-message-style-insertions))))))))))))
-
-(defun gnus-message-insert-stylings ()
-  (let (val)
-    (save-excursion
-      (message-goto-eoh)
-      (while (setq val (pop gnus-message-style-insertions))
-        (when (cdr val)
-          (insert (car val) ": " (cdr val) "\n"))
-        (gnus-pull (car val) gnus-message-style-insertions)))))
+          (dolist (attribute style)
+            (setq element (pop attribute)
+                  variable nil
+                  filep nil)
+            (setq value
+                  (cond
+                   ((eq (car attribute) :file)
+                    (setq filep t)
+                    (cadr attribute))
+                   ((eq (car attribute) :value)
+                    (cadr attribute))
+                   (t
+                    (car attribute))))
+            ;; We get the value.
+            (setq v
+                  (cond
+                   ((stringp value)
+                    value)
+                   ((or (symbolp value)
+                        (gnus-functionp value))
+                    (cond ((gnus-functionp value)
+                           (funcall value))
+                          ((boundp value)
+                           (symbol-value value))))
+                   ((listp value)
+                    (eval value))))
+            ;; Translate obsolescent value.
+            (when (eq element 'signature-file)
+              (setq element 'signature
+                    filep t))
+            ;; Get the contents of file elems.
+            (when (and filep v)
+              (setq v (with-temp-buffer
+                        (insert-file-contents v)
+                        (buffer-string))))
+            (setq results (delq (assoc element results) results))
+            (push (cons element v) results))))
+      ;; Now we have all the styles, so we insert them.
+      (setq name (assq 'name results)
+            address (assq 'address results))
+      (setq results (delq name (delq address results)))
+      (make-local-variable 'message-setup-hook)
+      (dolist (result results)
+        (add-hook 'message-setup-hook
+                  (cond
+                   ((eq 'eval (car result))
+                    'ignore)
+                   ((eq 'body (car result))
+                    `(lambda ()
+                       (save-excursion
+                         (message-goto-body)
+                         (insert ,(cdr result)))))
+                   ((eq 'signature (car result))
+                    (set (make-local-variable 'message-signature) nil)
+                    (set (make-local-variable 'message-signature-file) nil)
+                    (if (not (cdr result))
+                        'ignore
+                      `(lambda ()
+                         (save-excursion
+                           (let ((message-signature ,(cdr result)))
+                             (when message-signature
+                               (message-insert-signature)))))))
+                   (t
+                    (let ((header
+                           (if (symbolp (car result))
+                               (capitalize (symbol-name (car result)))
+                             (car result))))
+                      `(lambda ()
+                         (save-excursion
+                           (message-remove-header ,header)
+                           (let ((value ,(cdr result)))
+                             (when value
+                               (message-goto-eoh)
+                               (insert ,header ": " value "\n"))))))))))
+      (when (or name address)
+        (add-hook 'message-setup-hook
+                  `(lambda ()
+                     (set (make-local-variable 'user-mail-address)
+                          ,(or (cdr address) user-mail-address))
+                     (let ((user-full-name ,(or (cdr name) (user-full-name)))
+                           (user-mail-address
+                            ,(or (cdr address) user-mail-address)))
+                       (save-excursion
+                         (message-remove-header "From")
+                         (message-goto-eoh)
+                         (insert "From: " (message-make-from) "\n")))))))))
 
 ;;; Allow redefinition of functions.
 
diff --git a/lisp/gnus/gnus-sum.el b/lisp/gnus/gnus-sum.el
index 45658018139..999e3b039fe 100644
--- a/lisp/gnus/gnus-sum.el
+++ b/lisp/gnus/gnus-sum.el
@@ -1,5 +1,6 @@
 ;;; gnus-sum.el --- summary mode commands for Gnus
-;; Copyright (C) 1996,97,98 Free Software Foundation, Inc.
+;; Copyright (C) 1996, 1997, 1998, 1999, 2000
+;;        Free Software Foundation, Inc.
 
 ;; Author: Lars Magne Ingebrigtsen <larsi@gnus.org>
 ;; Keywords: news
@@ -27,8 +28,6 @@
 
 (eval-when-compile (require 'cl))
 
-(eval-when-compile (require 'cl))
-
 (require 'gnus)
 (require 'gnus-group)
 (require 'gnus-spec)
@@ -36,6 +35,7 @@
 (require 'gnus-int)
 (require 'gnus-undo)
 (require 'gnus-util)
+(require 'mm-decode)
 (autoload 'gnus-summary-limit-include-cached "gnus-cache" nil t)
 
 (defcustom gnus-kill-summary-on-exit t
@@ -169,10 +169,15 @@ This variable will only be used if the value of
   :type 'string)
 
 (defcustom gnus-summary-goto-unread t
-  "*If t, marking commands will go to the next unread article.
-If `never', commands that usually go to the next unread article, will
-go to the next article, whether it is read or not.
-If nil, only the marking commands will go to the next (un)read article."
+  "*If t, many commands will go to the next unread article.
+This applies to marking commands as well as other commands that
+\"naturally\" select the next article, like, for instance, `SPC' at
+the end of an article.
+
+If nil, the marking commands do NOT go to the next unread article
+(they go to the next article instead).  If `never', commands that
+usually go to the next unread article, will go to the next article,
+whether it is read or not."
   :group 'gnus-summary-marks
   :link '(custom-manual "(gnus)Setting Marks")
   :type '(choice (const :tag "off" nil)
@@ -254,8 +259,12 @@ equal will be included."
 (defcustom gnus-auto-select-first t
   "*If nil, don't select the first unread article when entering a group.
 If this variable is `best', select the highest-scored unread article
-in the group.  If neither nil nor `best', select the first unread
-article.
+in the group.  If t, select the first unread article.
+
+This variable can also be a function to place point on a likely
+subject line.  Useful values include `gnus-summary-first-unread-subject',
+`gnus-summary-first-unread-article' and
+`gnus-summary-best-unread-article'.
 
 If you want to prevent automatic selection of the first unread article
 in some newsgroups, set the variable to nil in
@@ -263,7 +272,10 @@ in some newsgroups, set the variable to nil in
   :group 'gnus-group-select
   :type '(choice (const :tag "none" nil)
                  (const best)
-                 (sexp :menu-tag "first" t)))
+                 (sexp :menu-tag "first" t)
+                 (function-item gnus-summary-first-unread-subject)
+                 (function-item gnus-summary-first-unread-article)
+                 (function-item gnus-summary-best-unread-article)))
 
 (defcustom gnus-auto-select-next t
   "*If non-nil, offer to go to the next group from the end of the previous.
@@ -304,6 +316,7 @@ and non-`vertical', do both horizontal and vertical recentering."
   :group 'gnus-summary-maneuvering
   :type '(choice (const :tag "none" nil)
                  (const vertical)
+                 (integer :tag "height")
                  (sexp :menu-tag "both" t)))
 
 (defcustom gnus-show-all-headers nil
@@ -330,13 +343,6 @@ variable."
   :group 'gnus-article-various
   :type 'boolean)
 
-(defcustom gnus-show-mime nil
-  "*If non-nil, do mime processing of articles.
-The articles will simply be fed to the function given by
-`gnus-show-mime-method'."
-  :group 'gnus-article-mime
-  :type 'boolean)
-
 (defcustom gnus-move-split-methods nil
   "*Variable used to suggest where articles are to be moved to.
 It uses the same syntax as the `gnus-split-methods' variable."
@@ -345,7 +351,7 @@ It uses the same syntax as the `gnus-split-methods' variable."
                          (cons :value ("" "") regexp (repeat string))
                          (sexp :value nil))))
 
-(defcustom gnus-unread-mark ? ;space
+(defcustom gnus-unread-mark ?  ;Whitespace
   "*Mark used for unread articles."
   :group 'gnus-summary-marks
   :type 'character)
@@ -460,7 +466,7 @@ It uses the same syntax as the `gnus-split-methods' variable."
   :group 'gnus-summary-marks
   :type 'character)
 
-(defcustom gnus-empty-thread-mark ? ;space
+(defcustom gnus-empty-thread-mark ?  ;Whitespace
   "*There is no thread under the article."
   :group 'gnus-summary-marks
   :type 'character)
@@ -475,6 +481,19 @@ It uses the same syntax as the `gnus-split-methods' variable."
   :group 'gnus-extract-view
   :type 'boolean)
 
+(defcustom gnus-auto-expirable-marks
+  (list gnus-killed-mark gnus-del-mark gnus-catchup-mark
+        gnus-low-score-mark gnus-ancient-mark gnus-read-mark
+        gnus-souped-mark gnus-duplicate-mark)
+  "*The list of marks converted into expiration if a group is auto-expirable."
+  :group 'gnus-summary
+  :type '(repeat character))
+
+(defcustom gnus-inhibit-user-auto-expire t
+  "*If non-nil, user marking commands will not mark an article as expirable, even if the group has auto-expire turned on."
+  :group 'gnus-summary
+  :type 'boolean)
+
 (defcustom gnus-view-pseudos nil
   "*If `automatic', pseudo-articles will be viewed automatically.
 If `not-confirm', pseudos will be viewed automatically, and the user
@@ -506,7 +525,7 @@ with some simple extensions.
   :group 'gnus-threading
   :type 'string)
 
-(defcustom gnus-summary-mode-line-format "Gnus: %%b [%A] %Z"
+(defcustom gnus-summary-mode-line-format "Gnus: %g [%A] %Z"
   "*The format specification for the summary mode line.
 It works along the same lines as a normal formatting string,
 with some simple extensions:
@@ -529,6 +548,15 @@ with some simple extensions:
   :group 'gnus-summary-format
   :type 'string)
 
+(defcustom gnus-list-identifiers nil
+  "Regexp that matches list identifiers to be removed from subject.
+This can also be a list of regexps."
+  :group 'gnus-summary-format
+  :group 'gnus-article-hiding
+  :type '(choice (const :tag "none" nil)
+                 (regexp :value ".*")
+                 (repeat :value (".*") regexp)))
+
 (defcustom gnus-summary-mark-below 0
   "*Mark all articles with a score below this variable as read.
 This variable is local to each summary buffer and usually set by the
@@ -593,7 +621,7 @@ See `gnus-thread-score-function' for en explanation of what a
 \"thread score\" is.
 
 This variable is local to the summary buffers."
-  :group 'gnus-treading
+  :group 'gnus-threading
   :group 'gnus-score-default
   :type '(choice (const :tag "off" nil)
                  integer))
@@ -665,38 +693,14 @@ is not run if `gnus-visual' is nil."
   :group 'gnus-summary-visual
   :type 'hook)
 
-(defcustom gnus-structured-field-decoder
-  (if (and (featurep 'mule)
-           (boundp 'enable-multibyte-characters))
-      (lambda (string)
-        (if (and enable-multibyte-characters gnus-mule-coding-system)
-            (decode-coding-string string gnus-mule-coding-system)
-          string))
-    'identity)
-  "Function to decode non-ASCII characters in structured field for summary."
-  :group 'gnus-various
-  :type 'function)
-
-(defcustom gnus-unstructured-field-decoder
-  (if (and (featurep 'mule)
-           (boundp 'enable-multibyte-characters))
-      (lambda (string)
-        (if (and enable-multibyte-characters gnus-mule-coding-system)
-            (decode-coding-string string gnus-mule-coding-system)
-          string))
-    'identity)
-  "Function to decode non-ASCII characters in unstructured field for summary."
-  :group 'gnus-various
-  :type 'function)
-
-(defcustom gnus-parse-headers-hook
-  (list 'gnus-hack-decode-rfc1522 'gnus-decode-rfc1522)
+(defcustom gnus-parse-headers-hook nil
   "*A hook called before parsing the headers."
   :group 'gnus-various
   :type 'hook)
 
 (defcustom gnus-exit-group-hook nil
-  "*A hook called when exiting (not quitting) summary mode."
+  "*A hook called when exiting summary mode.
+This hook is not called from the non-updating exit commands like `Q'."
   :group 'gnus-various
   :type 'hook)
 
@@ -795,10 +799,107 @@ mark:    The articles mark."
 The function is called with one parameter, the article header vector,
 which it may alter in any way.")
 
+(defvar gnus-decode-encoded-word-function 'mail-decode-encoded-word-string
+  "Variable that says which function should be used to decode a string with encoded words.")
+
+(defcustom gnus-extra-headers nil
+  "*Extra headers to parse."
+  :group 'gnus-summary
+  :type '(repeat symbol))
+
+(defcustom gnus-ignored-from-addresses
+  (and user-mail-address (regexp-quote user-mail-address))
+  "*Regexp of From headers that may be suppressed in favor of To headers."
+  :group 'gnus-summary
+  :type 'regexp)
+
+(defcustom gnus-group-charset-alist
+  '(("^hk\\>\\|^tw\\>\\|\\<big5\\>" cn-big5)
+    ("^cn\\>\\|\\<chinese\\>" cn-gb-2312)
+    ("^fj\\>\\|^japan\\>" iso-2022-jp-2)
+    ("^tnn\\>\\|^pin\\>\\|^sci.lang.japan" iso-2022-7bit)
+    ("^relcom\\>" koi8-r)
+    ("^fido7\\>" koi8-r)
+    ("^\\(cz\\|hun\\|pl\\|sk\\|hr\\)\\>" iso-8859-2)
+    ("^israel\\>" iso-8859-1)
+    ("^han\\>" euc-kr)
+    ("^alt.chinese.text.big5\\>" chinese-big5)
+    ("^soc.culture.vietnamese\\>" vietnamese-viqr)
+    ("^\\(comp\\|rec\\|alt\\|sci\\|soc\\|news\\|gnu\\|bofh\\)\\>" iso-8859-1)
+    (".*" iso-8859-1))
+  "Alist of regexps (to match group names) and default charsets to be used when reading."
+  :type '(repeat (list (regexp :tag "Group")
+                       (symbol :tag "Charset")))
+  :group 'gnus-charset)
+
+(defcustom gnus-newsgroup-ignored-charsets '(unknown-8bit x-unknown)
+  "List of charsets that should be ignored.
+When these charsets are used in the \"charset\" parameter, the
+default charset will be used instead."
+  :type '(repeat symbol)
+  :group 'gnus-charset)
+
+(defcustom gnus-group-ignored-charsets-alist
+  '(("alt\\.chinese\\.text" iso-8859-1))
+  "Alist of regexps (to match group names) and charsets that should be ignored.
+When these charsets are used in the \"charset\" parameter, the
+default charset will be used instead."
+  :type '(repeat (cons (regexp :tag "Group")
+                       (repeat symbol)))
+  :group 'gnus-charset)
+
+(defcustom gnus-group-highlight-words-alist nil
+  "Alist of group regexps and highlight regexps.
+This variable uses the same syntax as `gnus-emphasis-alist'."
+  :type '(repeat (cons (regexp :tag "Group")
+                       (repeat (list (regexp :tag "Highlight regexp")
+                                     (number :tag "Group for entire word" 0)
+                                     (number :tag "Group for displayed part" 0)
+                                     (symbol :tag "Face"
+                                             gnus-emphasis-highlight-words)))))
+  :group 'gnus-summary-visual)
+
+(defcustom gnus-summary-show-article-charset-alist
+  nil
+  "Alist of number and charset.
+The article will be shown with the charset corresponding to the
+numbered argument.
+For example: ((1 . cn-gb-2312) (2 . big5))."
+  :type '(repeat (cons (number :tag "Argument" 1)
+                       (symbol :tag "Charset")))
+  :group 'gnus-charset)
+
+(defcustom gnus-preserve-marks t
+  "Whether marks are preserved when moving, copying and respooling messages."
+  :type 'boolean
+  :group 'gnus-summary-marks)
+
+(defcustom gnus-alter-articles-to-read-function nil
+  "Function to be called to alter the list of articles to be selected."
+  :type 'function
+  :group 'gnus-summary)
+
+(defcustom gnus-orphan-score nil
+  "*All orphans get this score added.  Set in the score file."
+  :group 'gnus-score-default
+  :type '(choice (const nil)
+                 integer))
+
+(defcustom gnus-summary-save-parts-default-mime "image/.*"
+  "*A regexp to match MIME parts when saving multiple parts of a message
+with gnus-summary-save-parts (X m). This regexp will be used by default
+when prompting the user for which type of files to save."
+  :group 'gnus-summary
+  :type 'regexp)
+
+
 ;;; Internal variables
 
+(defvar gnus-article-mime-handles nil)
+(defvar gnus-article-decoded-p nil)
 (defvar gnus-scores-exclude-files nil)
 (defvar gnus-page-broken nil)
+(defvar gnus-inhibit-mime-unbuttonizing nil)
 
 (defvar gnus-original-article nil)
 (defvar gnus-article-internal-prepare-hook nil)
@@ -806,6 +907,11 @@ which it may alter in any way.")
 
 (defvar gnus-thread-indent-array nil)
 (defvar gnus-thread-indent-array-level gnus-thread-indent-level)
+(defvar gnus-sort-gathered-threads-function 'gnus-thread-sort-by-number
+  "Function called to sort the articles within a thread after it has been gathered together.")
+
+(defvar gnus-summary-save-parts-type-history nil)
+(defvar gnus-summary-save-parts-last-directory nil)
 
 ;; Avoid highlighting in kill files.
 (defvar gnus-summary-inhibit-highlight nil)
@@ -853,6 +959,7 @@ which it may alter in any way.")
     (?l (bbb-grouplens-score gnus-tmp-header) ?s)
     (?V (gnus-thread-total-score (and (boundp 'thread) (car thread))) ?d)
     (?U gnus-tmp-unread ?c)
+    (?f (gnus-summary-from-or-to-or-newsgroups gnus-tmp-header) ?s)
     (?t (gnus-summary-number-of-articles-in-thread
          (and (boundp 'thread) (car thread)) gnus-tmp-level)
         ?d)
@@ -861,9 +968,9 @@ which it may alter in any way.")
         ?c)
     (?u gnus-tmp-user-defined ?s)
     (?P (gnus-pick-line-number) ?d))
-  "An alist of format specifications that can appear in summary lines,
-and what variables they correspond with, along with the type of the
-variable (string, integer, character, etc).")
+  "An alist of format specifications that can appear in summary lines.
+These are paired with what variables they correspond with, along with
+the type of the variable (string, integer, character, etc).")
 
 (defvar gnus-summary-dummy-line-format-alist
   `((?S gnus-tmp-subject ?s)
@@ -979,6 +1086,9 @@ variable (string, integer, character, etc).")
 (defvar gnus-have-all-headers nil)
 (defvar gnus-last-article nil)
 (defvar gnus-newsgroup-history nil)
+(defvar gnus-newsgroup-charset nil)
+(defvar gnus-newsgroup-ephemeral-charset nil)
+(defvar gnus-newsgroup-ephemeral-ignored-charsets nil)
 
 (defconst gnus-summary-local-variables
   '(gnus-newsgroup-name
@@ -1000,8 +1110,10 @@ variable (string, integer, character, etc).")
     gnus-newsgroup-dependencies gnus-newsgroup-selected-overlay
     gnus-newsgroup-scored gnus-newsgroup-kill-headers
     gnus-thread-expunge-below
-    gnus-score-alist gnus-current-score-file gnus-summary-expunge-below
+    gnus-score-alist gnus-current-score-file
+    (gnus-summary-expunge-below . global)
     (gnus-summary-mark-below . global)
+    (gnus-orphan-score . global)
     gnus-newsgroup-active gnus-scores-exclude-files
     gnus-newsgroup-history gnus-newsgroup-ancient
     gnus-newsgroup-sparse gnus-newsgroup-process-stack
@@ -1010,16 +1122,55 @@ variable (string, integer, character, etc).")
     (gnus-newsgroup-expunged-tally . 0)
     gnus-cache-removable-articles gnus-newsgroup-cached
     gnus-newsgroup-data gnus-newsgroup-data-reverse
-    gnus-newsgroup-limit gnus-newsgroup-limits)
+    gnus-newsgroup-limit gnus-newsgroup-limits
+    gnus-newsgroup-charset)
   "Variables that are buffer-local to the summary buffers.")
 
 ;; Byte-compiler warning.
 (defvar gnus-article-mode-map)
 
+;; MIME stuff.
+
+(defvar gnus-decode-encoded-word-methods
+  '(mail-decode-encoded-word-string)
+  "List of methods used to decode encoded words.
+
+This variable is a list of FUNCTION or (REGEXP . FUNCTION).  If item is
+FUNCTION, FUNCTION will be apply to all newsgroups.  If item is a
+(REGEXP . FUNCTION), FUNCTION will be only apply to thes newsgroups
+whose names match REGEXP.
+
+For example:
+((\"chinese\" . gnus-decode-encoded-word-string-by-guess)
+ mail-decode-encoded-word-string
+ (\"chinese\" . rfc1843-decode-string))")
+
+(defvar gnus-decode-encoded-word-methods-cache nil)
+
+(defun gnus-multi-decode-encoded-word-string (string)
+  "Apply the functions from `gnus-encoded-word-methods' that match."
+  (unless (and gnus-decode-encoded-word-methods-cache
+               (eq gnus-newsgroup-name
+                   (car gnus-decode-encoded-word-methods-cache)))
+    (setq gnus-decode-encoded-word-methods-cache (list gnus-newsgroup-name))
+    (mapcar (lambda (x)
+              (if (symbolp x)
+                  (nconc gnus-decode-encoded-word-methods-cache (list x))
+                (if (and gnus-newsgroup-name
+                         (string-match (car x) gnus-newsgroup-name))
+                    (nconc gnus-decode-encoded-word-methods-cache
+                           (list (cdr x))))))
+          gnus-decode-encoded-word-methods))
+  (let ((xlist gnus-decode-encoded-word-methods-cache))
+    (pop xlist)
+    (while xlist
+      (setq string (funcall (pop xlist) string))))
+  string)
+
 ;; Subject simplification.
 
 (defun gnus-simplify-whitespace (str)
-  "Remove excessive whitespace."
+  "Remove excessive whitespace from STR."
   (let ((mystr str))
     ;; Multiple spaces.
     (while (string-match "[ \t][ \t]+" mystr)
@@ -1064,7 +1215,7 @@ If RE-ONLY is non-nil, strip leading `Re:'s only."
 (defsubst gnus-simplify-buffer-fuzzy-step (regexp &optional newtext)
   (goto-char (point-min))
   (while (re-search-forward regexp nil t)
-      (replace-match (or newtext ""))))
+    (replace-match (or newtext ""))))
 
 (defun gnus-simplify-buffer-fuzzy ()
   "Simplify string in the buffer fuzzily.
@@ -1072,7 +1223,7 @@ The string in the accessible portion of the current buffer is simplified.
 It is assumed to be a single-line subject.
 Whitespace is generally cleaned up, and miscellaneous leading/trailing
 matter is removed.  Additional things can be deleted by setting
-gnus-simplify-subject-fuzzy-regexp."
+`gnus-simplify-subject-fuzzy-regexp'."
   (let ((case-fold-search t)
         (modified-tick))
     (gnus-simplify-buffer-fuzzy-step "\t" " ")
@@ -1196,6 +1347,8 @@ increase the score of each group you read."
     "\M-\C-h" gnus-summary-hide-thread
     "\M-\C-f" gnus-summary-next-thread
     "\M-\C-b" gnus-summary-prev-thread
+    [(meta down)] gnus-summary-next-thread
+    [(meta up)] gnus-summary-prev-thread
     "\M-\C-u" gnus-summary-up-thread
     "\M-\C-d" gnus-summary-down-thread
     "&" gnus-summary-execute-command
@@ -1206,6 +1359,7 @@ increase the score of each group you read."
     "\C-c\M-\C-s" gnus-summary-limit-include-expunged
     "\C-c\C-s\C-n" gnus-summary-sort-by-number
     "\C-c\C-s\C-l" gnus-summary-sort-by-lines
+    "\C-c\C-s\C-c" gnus-summary-sort-by-chars
     "\C-c\C-s\C-a" gnus-summary-sort-by-author
     "\C-c\C-s\C-s" gnus-summary-sort-by-subject
     "\C-c\C-s\C-d" gnus-summary-sort-by-date
@@ -1215,7 +1369,6 @@ increase the score of each group you read."
     "\M-g" gnus-summary-rescan-group
     "w" gnus-summary-stop-page-breaking
     "\C-c\C-r" gnus-summary-caesar-message
-    "\M-t" gnus-summary-toggle-mime
     "f" gnus-summary-followup
     "F" gnus-summary-followup-with-original
     "C" gnus-summary-cancel-article
@@ -1237,13 +1390,14 @@ increase the score of each group you read."
     "a" gnus-summary-post-news
     "x" gnus-summary-limit-to-unread
     "s" gnus-summary-isearch-article
-    "t" gnus-article-hide-headers
+    "t" gnus-summary-toggle-header
     "g" gnus-summary-show-article
     "l" gnus-summary-goto-last-article
     "\C-c\C-v\C-v" gnus-uu-decode-uu-view
     "\C-d" gnus-summary-enter-digest-group
     "\M-\C-d" gnus-summary-read-document
     "\M-\C-e" gnus-summary-edit-parameters
+    "\M-\C-a" gnus-summary-customize-parameters
     "\C-c\C-b" gnus-bug
     "*" gnus-cache-enter-article
     "\M-*" gnus-cache-remove-article
@@ -1254,6 +1408,9 @@ increase the score of each group you read."
     "\M-i" gnus-symbolic-argument
     "h" gnus-summary-select-article-buffer
 
+    "b" gnus-article-view-part
+    "\M-t" gnus-summary-toggle-display-buttonized
+
     "V" gnus-summary-score-map
     "X" gnus-uu-extract-map
     "S" gnus-summary-send-map)
@@ -1295,12 +1452,14 @@ increase the score of each group you read."
     "a" gnus-summary-limit-to-author
     "u" gnus-summary-limit-to-unread
     "m" gnus-summary-limit-to-marks
+    "M" gnus-summary-limit-exclude-marks
     "v" gnus-summary-limit-to-score
     "*" gnus-summary-limit-include-cached
     "D" gnus-summary-limit-include-dormant
     "T" gnus-summary-limit-include-thread
     "d" gnus-summary-limit-exclude-dormant
     "t" gnus-summary-limit-to-age
+    "x" gnus-summary-limit-to-extra
     "E" gnus-summary-limit-include-expunged
     "c" gnus-summary-limit-exclude-childless-dormant
     "C" gnus-summary-limit-mark-excluded-as-read)
@@ -1371,11 +1530,13 @@ increase the score of each group you read."
     "e" gnus-summary-end-of-article
     "^" gnus-summary-refer-parent-article
     "r" gnus-summary-refer-parent-article
+    "D" gnus-summary-enter-digest-group
     "R" gnus-summary-refer-references
     "T" gnus-summary-refer-thread
     "g" gnus-summary-show-article
     "s" gnus-summary-isearch-article
-    "P" gnus-summary-print-article)
+    "P" gnus-summary-print-article
+    "t" gnus-article-babel)
 
   (gnus-define-keys (gnus-summary-wash-map "W" gnus-summary-mode-map)
     "b" gnus-article-add-buttons
@@ -1383,15 +1544,19 @@ increase the score of each group you read."
     "o" gnus-article-treat-overstrike
     "e" gnus-article-emphasize
     "w" gnus-article-fill-cited-article
+    "Q" gnus-article-fill-long-lines
+    "C" gnus-article-capitalize-sentences
     "c" gnus-article-remove-cr
     "q" gnus-article-de-quoted-unreadable
+    "6" gnus-article-de-base64-unreadable
+    "Z" gnus-article-decode-HZ
+    "h" gnus-article-wash-html
     "f" gnus-article-display-x-face
     "l" gnus-summary-stop-page-breaking
     "r" gnus-summary-caesar-message
-    "t" gnus-article-hide-headers
+    "t" gnus-summary-toggle-header
     "v" gnus-summary-verbose-headers
-    "m" gnus-summary-toggle-mime
-    "h" gnus-article-treat-html
+    "H" gnus-article-strip-headers-in-body
     "d" gnus-article-treat-dumbquotes)
 
   (gnus-define-keys (gnus-summary-wash-hide-map "W" gnus-summary-wash-map)
@@ -1401,7 +1566,9 @@ increase the score of each group you read."
     "s" gnus-article-hide-signature
     "c" gnus-article-hide-citation
     "C" gnus-article-hide-citation-in-followups
+    "l" gnus-article-hide-list-identifiers
     "p" gnus-article-hide-pgp
+    "B" gnus-article-strip-banner
     "P" gnus-article-hide-pem
     "\C-c" gnus-article-hide-citation-maybe)
 
@@ -1411,6 +1578,12 @@ increase the score of each group you read."
     "c" gnus-article-highlight-citation
     "s" gnus-article-highlight-signature)
 
+  (gnus-define-keys (gnus-summary-wash-mime-map "M" gnus-summary-wash-map)
+    "w" gnus-article-decode-mime-words
+    "c" gnus-article-decode-charset
+    "v" gnus-mime-view-all-parts
+    "b" gnus-article-view-part)
+
   (gnus-define-keys (gnus-summary-wash-time-map "T" gnus-summary-wash-map)
     "z" gnus-article-date-ut
     "u" gnus-article-date-ut
@@ -1426,7 +1599,8 @@ increase the score of each group you read."
     "m" gnus-article-strip-multiple-blank-lines
     "a" gnus-article-strip-blank-lines
     "A" gnus-article-strip-all-blank-lines
-    "s" gnus-article-strip-leading-space)
+    "s" gnus-article-strip-leading-space
+    "e" gnus-article-strip-trailing-space)
 
   (gnus-define-keys (gnus-summary-help-map "H" gnus-summary-mode-map)
     "v" gnus-version
@@ -1440,6 +1614,7 @@ increase the score of each group you read."
     "\M-\C-e" gnus-summary-expire-articles-now
     "\177" gnus-summary-delete-article
     [delete] gnus-summary-delete-article
+    [backspace] gnus-summary-delete-article
     "m" gnus-summary-move-article
     "r" gnus-summary-respool-article
     "w" gnus-summary-edit-article
@@ -1460,7 +1635,17 @@ increase the score of each group you read."
     "h" gnus-summary-save-article-folder
     "v" gnus-summary-save-article-vm
     "p" gnus-summary-pipe-output
-    "s" gnus-soup-add-article))
+    "s" gnus-soup-add-article)
+
+  (gnus-define-keys (gnus-summary-mime-map "K" gnus-summary-mode-map)
+    "b" gnus-summary-display-buttonized
+    "m" gnus-summary-repair-multipart
+    "v" gnus-article-view-part
+    "o" gnus-article-save-part
+    "c" gnus-article-copy-part
+    "e" gnus-article-externalize-part
+    "i" gnus-article-inline-part
+    "|" gnus-article-pipe-part))
 
 (defun gnus-summary-make-menu-bar ()
   (gnus-turn-off-edit-menu 'summary)
@@ -1503,13 +1688,21 @@ increase the score of each group you read."
               ["Headers" gnus-article-hide-headers t]
               ["Signature" gnus-article-hide-signature t]
               ["Citation" gnus-article-hide-citation t]
+              ["List identifiers" gnus-article-hide-list-identifiers t]
               ["PGP" gnus-article-hide-pgp t]
+              ["Banner" gnus-article-strip-banner t]
               ["Boring headers" gnus-article-hide-boring-headers t])
              ("Highlight"
               ["All" gnus-article-highlight t]
               ["Headers" gnus-article-highlight-headers t]
               ["Signature" gnus-article-highlight-signature t]
               ["Citation" gnus-article-highlight-citation t])
+             ("MIME"
+              ["Words" gnus-article-decode-mime-words t]
+              ["Charset" gnus-article-decode-charset t]
+              ["QP" gnus-article-de-quoted-unreadable t]
+              ["Base64" gnus-article-de-base64-unreadable t]
+              ["View all" gnus-mime-view-all-parts t])
              ("Date"
               ["Local" gnus-article-date-local t]
               ["ISO8601" gnus-article-date-iso8601 t]
@@ -1524,23 +1717,27 @@ increase the score of each group you read."
                ["Trailing" gnus-article-remove-trailing-blank-lines t]
                ["All of the above" gnus-article-strip-blank-lines t]
                ["All" gnus-article-strip-all-blank-lines t]
-               ["Leading space" gnus-article-strip-leading-space t])
+               ["Leading space" gnus-article-strip-leading-space t]
+               ["Trailing space" gnus-article-strip-trailing-space t])
               ["Overstrike" gnus-article-treat-overstrike t]
               ["Dumb quotes" gnus-article-treat-dumbquotes t]
               ["Emphasis" gnus-article-emphasize t]
               ["Word wrap" gnus-article-fill-cited-article t]
+              ["Fill long lines" gnus-article-fill-long-lines t]
+              ["Capitalize sentences" gnus-article-capitalize-sentences t]
               ["CR" gnus-article-remove-cr t]
               ["Show X-Face" gnus-article-display-x-face t]
               ["Quoted-Printable" gnus-article-de-quoted-unreadable t]
-              ["UnHTMLize" gnus-article-treat-html t]
+              ["Base64" gnus-article-de-base64-unreadable t]
               ["Rot 13" gnus-summary-caesar-message t]
               ["Unix pipe" gnus-summary-pipe-message t]
               ["Add buttons" gnus-article-add-buttons t]
               ["Add buttons to head" gnus-article-add-buttons-to-head t]
               ["Stop page breaking" gnus-summary-stop-page-breaking t]
-              ["Toggle MIME" gnus-summary-toggle-mime t]
               ["Verbose header" gnus-summary-verbose-headers t]
-              ["Toggle header" gnus-summary-toggle-header t])
+              ["Toggle header" gnus-summary-toggle-header t]
+              ["Html" gnus-article-wash-html t]
+              ["HZ" gnus-article-decode-HZ t])
              ("Output"
               ["Save in default format" gnus-summary-save-article t]
               ["Save in file" gnus-summary-save-article-file t]
@@ -1584,6 +1781,7 @@ increase the score of each group you read."
              ("Cache"
               ["Enter article" gnus-cache-enter-article t]
               ["Remove article" gnus-cache-remove-article t])
+             ["Translate" gnus-article-babel t]
              ["Select article buffer" gnus-summary-select-article-buffer t]
              ["Enter digest buffer" gnus-summary-enter-digest-group t]
              ["Isearch article..." gnus-summary-isearch-article t]
@@ -1618,8 +1816,7 @@ increase the score of each group you read."
        ["Mark thread as read" gnus-summary-kill-thread t]
        ["Lower thread score" gnus-summary-lower-thread t]
        ["Raise thread score" gnus-summary-raise-thread t]
-       ["Rethread current" gnus-summary-rethread-current t]
-       ))
+       ["Rethread current" gnus-summary-rethread-current t]))
 
     (easy-menu-define
      gnus-summary-post-menu gnus-summary-mode-map ""
@@ -1674,6 +1871,7 @@ increase the score of each group you read."
         ["Subject..." gnus-summary-limit-to-subject t]
         ["Author..." gnus-summary-limit-to-author t]
         ["Age..." gnus-summary-limit-to-age t]
+        ["Extra..." gnus-summary-limit-to-extra t]
         ["Score" gnus-summary-limit-to-score t]
         ["Unread" gnus-summary-limit-to-unread t]
         ["Non-dormant" gnus-summary-limit-exclude-dormant t]
@@ -1683,6 +1881,7 @@ increase the score of each group you read."
         ["Hide childless dormant"
          gnus-summary-limit-exclude-childless-dormant t]
         ;;["Hide thread" gnus-summary-limit-exclude-thread t]
+        ["Hide marked" gnus-summary-limit-exclude-marks t]
         ["Show expunged" gnus-summary-show-all-expunged t])
        ("Process Mark"
         ["Set mark" gnus-summary-mark-as-processable t]
@@ -1729,7 +1928,8 @@ increase the score of each group you read."
         ["Sort by subject" gnus-summary-sort-by-subject t]
         ["Sort by date" gnus-summary-sort-by-date t]
         ["Sort by score" gnus-summary-sort-by-score t]
-        ["Sort by lines" gnus-summary-sort-by-lines t])
+        ["Sort by lines" gnus-summary-sort-by-lines t]
+        ["Sort by characters" gnus-summary-sort-by-chars t])
        ("Help"
         ["Fetch group FAQ" gnus-summary-fetch-faq t]
         ["Describe group" gnus-summary-describe-group t]
@@ -1753,6 +1953,7 @@ increase the score of each group you read."
        ["Edit local kill file" gnus-summary-edit-local-kill t]
        ["Edit main kill file" gnus-summary-edit-global-kill t]
        ["Edit group parameters" gnus-summary-edit-parameters t]
+       ["Customize group parameters" gnus-summary-customize-parameters t]
        ["Send a bug report" gnus-bug t]
        ("Exit"
         ["Catchup and exit" gnus-summary-catchup-and-exit t]
@@ -1783,6 +1984,7 @@ increase the score of each group you read."
                      ("article body" "body" string)
                      ("article head" "head" string)
                      ("xref" "xref" string)
+                     ("extra header" "extra" string)
                      ("lines" "lines" number)
                      ("followups to author" "followup" string)))
           (types '((number ("less than" <)
@@ -1837,7 +2039,8 @@ increase the score of each group you read."
                                                (list 'gnus-summary-header
                                                      (nth 1 header)))
                                              (list 'quote (nth 1 (car ts)))
-                                             (list 'gnus-score-default nil)
+                                             (list 'gnus-score-delta-default
+                                                   nil)
                                              (nth 1 (car ps))
                                              t)
                                             t)
@@ -1884,7 +2087,7 @@ The following commands are available:
   (setq mode-name "Summary")
   (make-local-variable 'minor-mode-alist)
   (use-local-map gnus-summary-mode-map)
-  (buffer-disable-undo (current-buffer))
+  (buffer-disable-undo)
   (setq buffer-read-only t)             ;Disable modification
   (setq truncate-lines t)
   (setq selective-display t)
@@ -1897,19 +2100,17 @@ The following commands are available:
   (make-local-variable 'gnus-summary-dummy-line-format)
   (make-local-variable 'gnus-summary-dummy-line-format-spec)
   (make-local-variable 'gnus-summary-mark-positions)
-  (make-local-hook 'post-command-hook)
-  (add-hook 'post-command-hook 'gnus-clear-inboxes-moved nil t)
   (make-local-hook 'pre-command-hook)
   (add-hook 'pre-command-hook 'gnus-set-global-variables nil t)
   (gnus-run-hooks 'gnus-summary-mode-hook)
+  (mm-enable-multibyte)
   (gnus-update-format-specifications nil 'summary 'summary-mode 'summary-dummy)
   (gnus-update-summary-mark-positions))
 
 (defun gnus-summary-make-local-variables ()
   "Make all the local summary buffer variables."
-  (let ((locals gnus-summary-local-variables)
-        global local)
-    (while (setq local (pop locals))
+  (let (global)
+    (dolist (local gnus-summary-local-variables)
       (if (consp local)
           (progn
             (if (eq (cdr local) 'global)
@@ -1917,11 +2118,9 @@ The following commands are available:
                 (setq global (symbol-value (car local)))
               ;; Use the value from the list.
               (setq global (eval (cdr local))))
-            (make-local-variable (car local))
-            (set (car local) global))
+            (set (make-local-variable (car local)) global))
         ;; Simple nil-valued local variable.
-        (make-local-variable local)
-        (set local nil)))))
+        (set (make-local-variable local) nil)))))
 
 (defun gnus-summary-clear-local-variables ()
   (let ((locals gnus-summary-local-variables))
@@ -2215,26 +2414,6 @@ marks of articles."
              ,@forms)
          (gnus-restore-hidden-threads-configuration ,config)))))
 
-(defun gnus-hidden-threads-configuration ()
-  "Return the current hidden threads configuration."
-  (save-excursion
-    (let (config)
-      (goto-char (point-min))
-      (while (search-forward "\r" nil t)
-        (push (1- (point)) config))
-      config)))
-
-(defun gnus-restore-hidden-threads-configuration (config)
-  "Restore hidden threads configuration from CONFIG."
-  (let (point buffer-read-only)
-    (while (setq point (pop config))
-      (when (and (< point (point-max))
-                 (goto-char point)
-                 (= (following-char) ?\n))
-        (subst-char-in-region point (1+ point) ?\n ?\r)))))
-
-;; This needs to be put here because it uses the
-;; gnus-save-hidden-threads macro
 (defun gnus-data-compute-positions ()
   "Compute the positions of all articles."
   (setq gnus-newsgroup-data-reverse nil)
@@ -2250,6 +2429,25 @@ marks of articles."
           (setq data (cdr data))
           (forward-line 1))))))
 
+(defun gnus-hidden-threads-configuration ()
+  "Return the current hidden threads configuration."
+  (save-excursion
+    (let (config)
+      (goto-char (point-min))
+      (while (search-forward "\r" nil t)
+        (push (1- (point)) config))
+      config)))
+
+(defun gnus-restore-hidden-threads-configuration (config)
+  "Restore hidden threads configuration from CONFIG."
+  (save-excursion
+    (let (point buffer-read-only)
+      (while (setq point (pop config))
+        (when (and (< point (point-max))
+                   (goto-char point)
+                   (eq (char-after) ?\n))
+          (subst-char-in-region point (1+ point) ?\n ?\r))))))
+
 ;; Various summary mode internalish functions.
 
 (defun gnus-mouse-pick-article (e)
@@ -2258,9 +2456,10 @@ marks of articles."
   (gnus-summary-next-page nil t))
 
 (defun gnus-summary-set-display-table ()
-  ;; Change the display table.  Odd characters have a tendency to mess
-  ;; up nicely formatted displays - we make all possible glyphs
-  ;; display only a single character.
+  "Change the display table.
+Odd characters have a tendency to mess
+up nicely formatted displays - we make all possible glyphs
+display only a single character."
 
   ;; We start from the standard display table, if any.
   (let ((table (or (copy-sequence standard-display-table)
@@ -2304,9 +2503,9 @@ marks of articles."
       t)))
 
 (defun gnus-set-global-variables ()
-  ;; Set the global equivalents of the summary buffer-local variables
-  ;; to the latest values they had.  These reflect the summary buffer
-  ;; that was in action when the last article was fetched.
+  "Set the global equivalents of the buffer-local variables.
+They are set to the latest values they had.  These reflect the summary
+buffer that was in action when the last article was fetched."
   (when (eq major-mode 'gnus-summary-mode)
     (setq gnus-summary-buffer (current-buffer))
     (let ((name gnus-newsgroup-name)
@@ -2319,7 +2518,8 @@ marks of articles."
           (original gnus-original-article-buffer)
           (gac gnus-article-current)
           (reffed gnus-reffed-article-number)
-          (score-file gnus-current-score-file))
+          (score-file gnus-current-score-file)
+          (default-charset gnus-newsgroup-charset))
       (save-excursion
         (set-buffer gnus-group-buffer)
         (setq gnus-newsgroup-name name
@@ -2332,7 +2532,8 @@ marks of articles."
               gnus-article-buffer article-buffer
               gnus-original-article-buffer original
               gnus-reffed-article-number reffed
-              gnus-current-score-file score-file)
+              gnus-current-score-file score-file
+              gnus-newsgroup-charset default-charset)
         ;; The article buffer also has local variables.
         (when (gnus-buffer-live-p gnus-article-buffer)
           (set-buffer gnus-article-buffer)
@@ -2351,7 +2552,8 @@ marks of articles."
 (defun gnus-summary-last-article-p (&optional article)
   "Return whether ARTICLE is the last article in the buffer."
   (if (not (setq article (or article (gnus-summary-article-number))))
-      t         ; All non-existent numbers are the last article.  :-)
+      ;; All non-existent numbers are the last article.  :-)
+      t
     (not (cdr (gnus-data-find-list article)))))
 
 (defun gnus-make-thread-indent-array ()
@@ -2381,7 +2583,7 @@ marks of articles."
         (let ((gnus-summary-line-format-spec spec)
               (gnus-newsgroup-downloadable '((0 . t))))
           (gnus-summary-insert-line
-           [0 "" "" "" "" "" 0 0 ""]  0 nil 128 t nil "" nil 1)
+           [0 "" "" "" "" "" 0 0 "" nil]  0 nil 128 t nil "" nil 1)
           (goto-char (point-min))
           (setq pos (list (cons 'unread (and (search-forward "\200" nil t)
                                              (- (point) 2)))))
@@ -2405,6 +2607,33 @@ marks of articles."
    (point) (progn (eval gnus-summary-dummy-line-format-spec) (point))
    (list 'gnus-number gnus-tmp-number 'gnus-intangible gnus-tmp-number)))
 
+(defun gnus-summary-from-or-to-or-newsgroups (header)
+  (let ((to (cdr (assq 'To (mail-header-extra header))))
+        (newsgroups (cdr (assq 'Newsgroups (mail-header-extra header))))
+        (mail-parse-charset gnus-newsgroup-charset)
+        (mail-parse-ignored-charsets
+         (save-excursion (set-buffer gnus-summary-buffer)
+                         gnus-newsgroup-ignored-charsets)))
+    (cond
+     ((and to
+           gnus-ignored-from-addresses
+           (string-match gnus-ignored-from-addresses
+                         (mail-header-from header)))
+      (concat "-> "
+              (or (car (funcall gnus-extract-address-components
+                                (funcall
+                                 gnus-decode-encoded-word-function to)))
+                  (funcall gnus-decode-encoded-word-function to))))
+     ((and newsgroups
+           gnus-ignored-from-addresses
+           (string-match gnus-ignored-from-addresses
+                         (mail-header-from header)))
+      (concat "=> " newsgroups))
+     (t
+      (or (car (funcall gnus-extract-address-components
+                        (mail-header-from header)))
+          (mail-header-from header))))))
+
 (defun gnus-summary-insert-line (gnus-tmp-header
                                  gnus-tmp-level gnus-tmp-current
                                  gnus-tmp-unread gnus-tmp-replied
@@ -2418,7 +2647,7 @@ marks of articles."
           (if (or (null gnus-summary-default-score)
                   (<= (abs (- gnus-tmp-score gnus-summary-default-score))
                       gnus-summary-zcore-fuzz))
-              ? ;space
+              ?  ;Whitespace
             (if (< gnus-tmp-score gnus-summary-default-score)
                 gnus-score-below-mark gnus-score-over-mark)))
          (gnus-tmp-replied
@@ -2451,7 +2680,7 @@ marks of articles."
       (setq gnus-tmp-name gnus-tmp-from))
     (unless (numberp gnus-tmp-lines)
       (setq gnus-tmp-lines 0))
-    (gnus-put-text-property-excluding-characters-with-faces
+    (gnus-put-text-property
      (point)
      (progn (eval gnus-summary-line-format-spec) (point))
      'gnus-number gnus-tmp-number)
@@ -2461,7 +2690,7 @@ marks of articles."
       (forward-line 1))))
 
 (defun gnus-summary-update-line (&optional dont-update)
-  ;; Update summary line after change.
+  "Update summary line after change."
   (when (and gnus-summary-default-score
              (not gnus-summary-inhibit-highlight))
     (let* ((gnus-summary-inhibit-highlight t) ; Prevent recursion.
@@ -2483,7 +2712,7 @@ marks of articles."
          (if (or (null gnus-summary-default-score)
                  (<= (abs (- score gnus-summary-default-score))
                      gnus-summary-zcore-fuzz))
-             ? ;space
+             ?  ;Whitespace
            (if (< score gnus-summary-default-score)
                gnus-score-below-mark gnus-score-over-mark))
          'score))
@@ -2552,7 +2781,7 @@ If NO-DISPLAY, don't generate a summary buffer."
                                    kill-buffer no-display
                                    select-articles)
                                   (setq show-all nil
-                                   select-articles nil)))))
+                                        select-articles nil)))))
                 (eq gnus-auto-select-next 'quietly))
       (set-buffer gnus-group-buffer)
       ;; The entry function called above goes to the next
@@ -2634,6 +2863,7 @@ If NO-DISPLAY, don't generate a summary buffer."
       (gnus-summary-set-local-parameters gnus-newsgroup-name)
       (gnus-update-format-specifications
        nil 'summary 'summary-mode 'summary-dummy)
+      (gnus-update-summary-mark-positions)
       ;; Do score processing.
       (when gnus-use-scoring
         (gnus-possibly-score-headers))
@@ -2646,6 +2876,7 @@ If NO-DISPLAY, don't generate a summary buffer."
               (let ((gnus-newsgroup-dormant nil))
                 (gnus-summary-initial-limit show-all))
             (gnus-summary-initial-limit show-all))
+        ;; When untreaded, all articles are always shown.
         (setq gnus-newsgroup-limit
               (mapcar
                (lambda (header) (mail-header-number header))
@@ -2691,10 +2922,15 @@ If NO-DISPLAY, don't generate a summary buffer."
                  (not no-display)
                  gnus-newsgroup-unreads
                  gnus-auto-select-first)
-            (unless (if (eq gnus-auto-select-first 'best)
-                        (gnus-summary-best-unread-article)
-                      (gnus-summary-first-unread-article))
-              (gnus-configure-windows 'summary))
+            (progn
+              (gnus-configure-windows 'summary)
+              (cond
+               ((eq gnus-auto-select-first 'best)
+                (gnus-summary-best-unread-article))
+               ((eq gnus-auto-select-first t)
+                (gnus-summary-first-unread-article))
+               ((gnus-functionp gnus-auto-select-first)
+                (funcall gnus-auto-select-first))))
           ;; Don't select any articles, just move point to the first
           ;; article in the group.
           (goto-char (point-min))
@@ -2839,12 +3075,12 @@ If NO-DISPLAY, don't generate a summary buffer."
     result))
 
 (defun gnus-sort-gathered-threads (threads)
-  "Sort subtreads inside each gathered thread by article number."
+  "Sort subtreads inside each gathered thread by `gnus-sort-gathered-threads-function'."
   (let ((result threads))
     (while threads
       (when (stringp (caar threads))
         (setcdr (car threads)
-                (sort (cdar threads) 'gnus-thread-sort-by-number)))
+                (sort (cdar threads) gnus-sort-gathered-threads-function)))
       (setq threads (cdr threads)))
     result))
 
@@ -2900,7 +3136,7 @@ If NO-DISPLAY, don't generate a summary buffer."
     threads))
 
 ;; Build the thread tree.
-(defun gnus-dependencies-add-header (header dependencies force-new)
+(defsubst gnus-dependencies-add-header (header dependencies force-new)
   "Enter HEADER into the DEPENDENCIES table if it is not already there.
 
 If FORCE-NEW is not nil, enter HEADER into the DEPENDENCIES table even
@@ -2979,6 +3215,7 @@ Returns HEADER if it was entered in the DEPENDENCIES.  Returns nil otherwise."
 
 (defun gnus-build-sparse-threads ()
   (let ((headers gnus-newsgroup-headers)
+        (mail-parse-charset gnus-newsgroup-charset)
         (gnus-summary-ignore-duplicates t)
         header references generation relations
         subject child end new-child date)
@@ -3031,7 +3268,8 @@ Returns HEADER if it was entered in the DEPENDENCIES.  Returns nil otherwise."
   ;; fetch the headers for the articles that aren't there.  This will
   ;; build complete threads - if the roots haven't been expired by the
   ;; server, that is.
-  (let (id heads)
+  (let ((mail-parse-charset gnus-newsgroup-charset)
+        id heads)
     (mapatoms
      (lambda (refs)
        (when (not (car (symbol-value refs)))
@@ -3046,24 +3284,6 @@ Returns HEADER if it was entered in the DEPENDENCIES.  Returns nil otherwise."
              (setq heads nil)))))
      gnus-newsgroup-dependencies)))
 
-;; The following macros and functions were written by Felix Lee
-;; <flee@cse.psu.edu>.
-
-(defmacro gnus-nov-read-integer ()
-  '(prog1
-       (if (= (following-char) ?\t)
-           0
-         (let ((num (ignore-errors (read buffer))))
-           (if (numberp num) num 0)))
-     (unless (eobp)
-       (search-forward "\t" eol 'move))))
-
-(defmacro gnus-nov-skip-field ()
-  '(search-forward "\t" eol 'move))
-
-(defmacro gnus-nov-field ()
-  '(buffer-substring (point) (if (gnus-nov-skip-field) (1- (point)) eol)))
-
 ;; This function has to be called with point after the article number
 ;; on the beginning of the line.
 (defsubst gnus-nov-parse-line (number dependencies &optional force-new)
@@ -3081,18 +3301,20 @@ Returns HEADER if it was entered in the DEPENDENCIES.  Returns nil otherwise."
           (setq header
                 (make-full-mail-header
                  number                 ; number
-                 (funcall
-                  gnus-unstructured-field-decoder (gnus-nov-field)) ; subject
-                 (funcall
-                  gnus-structured-field-decoder (gnus-nov-field)) ; from
-                 (gnus-nov-field)       ; date
-                 (or (gnus-nov-field)
-                     (nnheader-generate-fake-message-id)) ; id
-                 (gnus-nov-field)       ; refs
-                 (gnus-nov-read-integer) ; chars
-                 (gnus-nov-read-integer) ; lines
-                 (unless (= (following-char) ?\n)
-                   (gnus-nov-field))))) ; misc
+                 (funcall gnus-decode-encoded-word-function
+                          (nnheader-nov-field)) ; subject
+                 (funcall gnus-decode-encoded-word-function
+                          (nnheader-nov-field)) ; from
+                 (nnheader-nov-field)   ; date
+                 (nnheader-nov-read-message-id) ; id
+                 (nnheader-nov-field)   ; refs
+                 (nnheader-nov-read-integer) ; chars
+                 (nnheader-nov-read-integer) ; lines
+                 (unless (eobp)
+                   (if (looking-at "Xref: ")
+                       (goto-char (match-end 0)))
+                   (nnheader-nov-field)) ; Xref
+                 (nnheader-nov-parse-extra)))) ; extra
 
       (widen))
 
@@ -3101,9 +3323,9 @@ Returns HEADER if it was entered in the DEPENDENCIES.  Returns nil otherwise."
     (gnus-dependencies-add-header header dependencies force-new)))
 
 (defun gnus-build-get-header (id)
-  ;; Look through the buffer of NOV lines and find the header to
-  ;; ID.  Enter this line into the dependencies hash table, and return
-  ;; the id of the parent article (if any).
+  "Look through the buffer of NOV lines and find the header to ID.
+Enter this line into the dependencies hash table, and return
+the id of the parent article (if any)."
   (let ((deps gnus-newsgroup-dependencies)
         found header)
     (prog1
@@ -3138,6 +3360,7 @@ Returns HEADER if it was entered in the DEPENDENCIES.  Returns nil otherwise."
 (defun gnus-build-all-threads ()
   "Read all the headers."
   (let ((gnus-summary-ignore-duplicates t)
+        (mail-parse-charset gnus-newsgroup-charset)
         (dependencies gnus-newsgroup-dependencies)
         header article)
     (save-excursion
@@ -3147,8 +3370,7 @@ Returns HEADER if it was entered in the DEPENDENCIES.  Returns nil otherwise."
         (while (not (eobp))
           (ignore-errors
             (setq article (read (current-buffer))
-                  header (gnus-nov-parse-line
-                          article dependencies)))
+                  header (gnus-nov-parse-line article dependencies)))
           (when header
             (save-excursion
               (set-buffer gnus-summary-buffer)
@@ -3185,17 +3407,19 @@ Returns HEADER if it was entered in the DEPENDENCIES.  Returns nil otherwise."
        (memq article gnus-newsgroup-expirable)
        ;; Only insert the Subject string when it's different
        ;; from the previous Subject string.
-       (if (gnus-subject-equal
-            (condition-case ()
-                (mail-header-subject
-                 (gnus-data-header
-                  (cadr
-                   (gnus-data-find-list
-                    article
-                    (gnus-data-list t)))))
-              ;; Error on the side of excessive subjects.
-              (error ""))
-            (mail-header-subject header))
+       (if (and
+            gnus-show-threads
+            (gnus-subject-equal
+             (condition-case ()
+                 (mail-header-subject
+                  (gnus-data-header
+                   (cadr
+                    (gnus-data-find-list
+                     article
+                     (gnus-data-list t)))))
+               ;; Error on the side of excessive subjects.
+               (error ""))
+             (mail-header-subject header)))
            ""
          (mail-header-subject header))
        nil (cdr (assq article gnus-newsgroup-scored))
@@ -3409,7 +3633,6 @@ If LINE, insert the rebuilt thread starting on line LINE."
                   (while thread
                     (gnus-remove-thread-1 (car thread))
                     (setq thread (cdr thread))))
-              (gnus-summary-show-all-threads)
               (gnus-remove-thread-1 thread))))))))
 
 (defun gnus-remove-thread-1 (thread)
@@ -3421,6 +3644,7 @@ If LINE, insert the rebuilt thread starting on line LINE."
       (gnus-remove-thread-1 (pop thread)))
     (when (setq d (gnus-data-find number))
       (goto-char (gnus-data-pos d))
+      (gnus-summary-show-thread)
       (gnus-data-remove
        number
        (- (gnus-point-at-bol)
@@ -3428,13 +3652,22 @@ If LINE, insert the rebuilt thread starting on line LINE."
               (1+ (gnus-point-at-eol))
             (gnus-delete-line)))))))
 
+(defun gnus-sort-threads-1 (threads func)
+  (sort (mapcar (lambda (thread)
+                  (cons (car thread)
+                        (and (cdr thread)
+                             (gnus-sort-threads-1 (cdr thread) func))))
+                threads) func))
+
 (defun gnus-sort-threads (threads)
   "Sort THREADS."
   (if (not gnus-thread-sort-functions)
       threads
     (gnus-message 8 "Sorting threads...")
     (prog1
-        (sort threads (gnus-make-sort-function gnus-thread-sort-functions))
+        (gnus-sort-threads-1 
+         threads 
+         (gnus-make-sort-function gnus-thread-sort-functions))
       (gnus-message 8 "Sorting threads...done"))))
 
 (defun gnus-sort-articles (articles)
@@ -3449,12 +3682,12 @@ If LINE, insert the rebuilt thread starting on line LINE."
 
 ;; Written by Hallvard B Furuseth <h.b.furuseth@usit.uio.no>.
 (defmacro gnus-thread-header (thread)
-  ;; Return header of first article in THREAD.
-  ;; Note that THREAD must never, ever be anything else than a variable -
-  ;; using some other form will lead to serious barfage.
+  "Return header of first article in THREAD.
+Note that THREAD must never, ever be anything else than a variable -
+using some other form will lead to serious barfage."
   (or (symbolp thread) (signal 'wrong-type-argument '(symbolp thread)))
   ;; (8% speedup to gnus-summary-prepare, just for fun :-)
-  (list 'byte-code "\10\211:\203\17\0\211@;\203\16\0A@@\207" ;
+  (list 'byte-code "\10\211:\203\17\0\211@;\203\16\0A@@\207"
         (vector thread) 2))
 
 (defsubst gnus-article-sort-by-number (h1 h2)
@@ -3477,6 +3710,16 @@ If LINE, insert the rebuilt thread starting on line LINE."
   (gnus-article-sort-by-lines
    (gnus-thread-header h1) (gnus-thread-header h2)))
 
+(defsubst gnus-article-sort-by-chars (h1 h2)
+  "Sort articles by octet length."
+  (< (mail-header-chars h1)
+     (mail-header-chars h2)))
+
+(defun gnus-thread-sort-by-chars (h1 h2)
+  "Sort threads by root article octet length."
+  (gnus-article-sort-by-chars
+   (gnus-thread-header h1) (gnus-thread-header h2)))
+
 (defsubst gnus-article-sort-by-author (h1 h2)
   "Sort articles by root author."
   (string-lessp
@@ -3507,7 +3750,7 @@ If LINE, insert the rebuilt thread starting on line LINE."
 
 (defsubst gnus-article-sort-by-date (h1 h2)
   "Sort articles by root article date."
-  (gnus-time-less
+  (time-less-p
    (gnus-date-get-time (mail-header-date h1))
    (gnus-date-get-time (mail-header-date h2))))
 
@@ -3537,7 +3780,7 @@ Unscored articles will be counted as having a score of zero."
   (> (gnus-thread-total-score h1) (gnus-thread-total-score h2)))
 
 (defun gnus-thread-total-score (thread)
-  ;;  This function find the total score of THREAD.
+  ;; This function find the total score of THREAD.
   (cond ((null thread)
          0)
         ((consp thread)
@@ -3568,6 +3811,12 @@ Unscored articles will be counted as having a score of zero."
 (defvar gnus-tmp-root-expunged nil)
 (defvar gnus-tmp-dummy-line nil)
 
+(defvar gnus-tmp-header)
+(defun gnus-extra-header (type &optional header)
+  "Return the extra header of TYPE."
+  (or (cdr (assq type (mail-header-extra (or header gnus-tmp-header))))
+      ""))
+
 (defun gnus-summary-prepare-threads (threads)
   "Prepare summary buffer from THREADS and indentation LEVEL.
 THREADS is either a list of `(PARENT [(CHILD1 [(GRANDCHILD ...]...) ...])'
@@ -3765,7 +4014,7 @@ or a straight list of headers."
              (if (or (null gnus-summary-default-score)
                      (<= (abs (- gnus-tmp-score gnus-summary-default-score))
                          gnus-summary-zcore-fuzz))
-                 ? ;space
+                 ?  ;Whitespace
                (if (< gnus-tmp-score gnus-summary-default-score)
                    gnus-score-below-mark gnus-score-over-mark))
              gnus-tmp-replied
@@ -3795,7 +4044,7 @@ or a straight list of headers."
               (setq gnus-tmp-name gnus-tmp-from))
             (unless (numberp gnus-tmp-lines)
               (setq gnus-tmp-lines 0))
-            (gnus-put-text-property-excluding-characters-with-faces
+            (gnus-put-text-property
              (point)
              (progn (eval gnus-summary-line-format-spec) (point))
              'gnus-number number)
@@ -3849,6 +4098,24 @@ or a straight list of headers."
          (cdr (assq number gnus-newsgroup-scored))
          (memq number gnus-newsgroup-processable))))))
 
+(defun gnus-summary-remove-list-identifiers ()
+  "Remove list identifiers in `gnus-list-identifiers' from articles in the current group."
+  (let ((regexp (if (stringp gnus-list-identifiers)
+                    gnus-list-identifiers
+                  (mapconcat 'identity gnus-list-identifiers " *\\|"))))
+    (dolist (header gnus-newsgroup-headers)
+      (when (string-match (concat "\\(\\(\\(Re: +\\)?\\(" regexp 
+                                  " *\\)\\)+\\(Re: +\\)?\\)")
+                          (mail-header-subject header))
+        (mail-header-set-subject
+         header (concat (substring (mail-header-subject header)
+                                   0 (match-beginning 1))
+                        (or
+                         (match-string 3 (mail-header-subject header))
+                         (match-string 5 (mail-header-subject header)))
+                        (substring (mail-header-subject header)
+                                   (match-end 1))))))))
+
 (defun gnus-select-newsgroup (group &optional read-all select-articles)
   "Select newsgroup GROUP.
 If READ-ALL is non-nil, all articles in the group are selected.
@@ -3884,6 +4151,7 @@ If SELECT-ARTICLES, only select those articles from GROUP."
     (setq gnus-newsgroup-name group)
     (setq gnus-newsgroup-unselected nil)
     (setq gnus-newsgroup-unreads (gnus-list-of-unread-articles group))
+    (gnus-summary-setup-default-charset)
 
     ;; Adjust and set lists of article marks.
     (when info
@@ -3918,6 +4186,7 @@ If SELECT-ARTICLES, only select those articles from GROUP."
       ;; Init the dependencies hash table.
       (setq gnus-newsgroup-dependencies
             (gnus-make-hashtable (length articles)))
+      (gnus-set-global-variables)
       ;; Retrieve the headers and read them in.
       (gnus-message 5 "Fetching headers for %s..." gnus-newsgroup-name)
       (setq gnus-newsgroup-headers
@@ -3966,6 +4235,9 @@ If SELECT-ARTICLES, only select those articles from GROUP."
       ;; Let the Gnus agent mark articles as read.
       (when gnus-agent
         (gnus-agent-get-undownloaded-list))
+      ;; Remove list identifiers from subject
+      (when gnus-list-identifiers
+        (gnus-summary-remove-list-identifiers))
       ;; Check whether auto-expire is to be done in this group.
       (setq gnus-newsgroup-auto-expire
             (gnus-group-auto-expirable-p group))
@@ -3983,7 +4255,7 @@ If SELECT-ARTICLES, only select those articles from GROUP."
       (or gnus-newsgroup-headers t)))))
 
 (defun gnus-articles-to-read (group &optional read-all)
-  ;; Find out what articles the user wants to read.
+  "Find out what articles the user wants to read."
   (let* ((articles
           ;; Select all articles if `read-all' is non-nil, or if there
           ;; are no unread articles.
@@ -3992,7 +4264,9 @@ If SELECT-ARTICLES, only select those articles from GROUP."
                        (zerop (length gnus-newsgroup-unreads)))
                   (eq (gnus-group-find-parameter group 'display)
                       'all))
-              (gnus-uncompress-range (gnus-active group))
+              (or
+               (gnus-uncompress-range (gnus-active group))
+               (gnus-cache-articles-in-group group))
             (sort (append gnus-newsgroup-dormant gnus-newsgroup-marked
                           (copy-sequence gnus-newsgroup-unreads))
                   '<)))
@@ -4048,6 +4322,12 @@ If SELECT-ARTICLES, only select those articles from GROUP."
             (gnus-sorted-intersection
              gnus-newsgroup-unreads
              (gnus-sorted-complement gnus-newsgroup-unreads articles)))
+      (when gnus-alter-articles-to-read-function
+        (setq gnus-newsgroup-unreads
+              (sort 
+               (funcall gnus-alter-articles-to-read-function
+                        gnus-newsgroup-name gnus-newsgroup-unreads)
+               '<)))
       articles)))
 
 (defun gnus-killed-articles (killed articles)
@@ -4070,7 +4350,7 @@ If SELECT-ARTICLES, only select those articles from GROUP."
     out))
 
 (defun gnus-adjust-marked-articles (info)
-  "Set all article lists and remove all marks that are no longer legal."
+  "Set all article lists and remove all marks that are no longer valid."
   (let* ((marked-lists (gnus-info-marks info))
          (active (gnus-active (gnus-info-group info)))
          (min (car active))
@@ -4128,15 +4408,16 @@ If SELECT-ARTICLES, only select those articles from GROUP."
   (let ((types gnus-article-mark-lists)
         (info (gnus-get-info gnus-newsgroup-name))
         (uncompressed '(score bookmark killed))
-        type list newmarked symbol)
+        type list newmarked symbol delta-marks)
     (when info
-      ;; Add all marks lists that are non-nil to the list of marks lists.
+      ;; Add all marks lists to the list of marks lists.
       (while (setq type (pop types))
-        (when (setq list (symbol-value
-                          (setq symbol
-                                (intern (format "gnus-newsgroup-%s"
-                                                (car type))))))
+        (setq list (symbol-value
+                    (setq symbol
+                          (intern (format "gnus-newsgroup-%s"
+                                          (car type))))))
 
+        (when list
           ;; Get rid of the entries of the articles that have the
           ;; default score.
           (when (and (eq (cdr type) 'score)
@@ -4151,14 +4432,38 @@ If SELECT-ARTICLES, only select those articles from GROUP."
                     (setcdr prev (cdr arts))
                   (setq prev arts))
                 (setq arts (cdr arts)))
-              (setq list (cdr all))))
-
-          (push (cons (cdr type)
-                      (if (memq (cdr type) uncompressed) list
-                        (gnus-compress-sequence
-                         (set symbol (sort list '<)) t)))
-                newmarked)))
-
+              (setq list (cdr all)))))
+
+        (unless (memq (cdr type) uncompressed)
+          (setq list (gnus-compress-sequence (set symbol (sort list '<)) t)))
+       
+        (when (gnus-check-backend-function
+               'request-set-mark gnus-newsgroup-name)
+          ;; propagate flags to server, with the following exceptions:
+          ;; uncompressed:s are not proper flags (they are cons cells)
+          ;; cache is a internal gnus flag
+          ;; download are local to one gnus installation (well)
+          ;; unsend are for nndraft groups only
+          ;; xxx: generality of this?  this suits nnimap anyway
+          (unless (memq (cdr type) (append '(cache download unsend)
+                                           uncompressed))
+            (let* ((old (cdr (assq (cdr type) (gnus-info-marks info))))
+                   (del (gnus-remove-from-range (gnus-copy-sequence old) list))
+                   (add (gnus-remove-from-range
+                         (gnus-copy-sequence list) old)))
+              (when add
+                (push (list add 'add (list (cdr type))) delta-marks))
+              (when del
+                (push (list del 'del (list (cdr type))) delta-marks)))))
+          
+        (when list
+          (push (cons (cdr type) list) newmarked)))
+
+      (when delta-marks
+        (unless (gnus-check-group gnus-newsgroup-name)
+          (error "Can't open server for %s" gnus-newsgroup-name))
+        (gnus-request-set-mark gnus-newsgroup-name delta-marks))
+          
       ;; Enter these new marks into the info of the group.
       (if (nthcdr 3 info)
           (setcar (nthcdr 3 info) newmarked)
@@ -4174,10 +4479,12 @@ If SELECT-ARTICLES, only select those articles from GROUP."
             (setcdr (nthcdr i info) nil)))))))
 
 (defun gnus-set-mode-line (where)
-  "This function sets the mode line of the article or summary buffers.
+  "Set the mode line of the article or summary buffers.
 If WHERE is `summary', the summary mode line format will be used."
   ;; Is this mode line one we keep updated?
-  (when (memq where gnus-updated-mode-lines)
+  (when (and (memq where gnus-updated-mode-lines)
+             (symbol-value
+              (intern (format "gnus-%s-mode-line-format-spec" where))))
     (let (mode-string)
       (save-excursion
         ;; We evaluate this in the summary buffer since these
@@ -4188,7 +4495,11 @@ If WHERE is `summary', the summary mode line format will be used."
         (let* ((mformat (symbol-value
                          (intern
                           (format "gnus-%s-mode-line-format-spec" where))))
-               (gnus-tmp-group-name gnus-newsgroup-name)
+               (gnus-tmp-group-name (gnus-group-name-decode 
+                                     gnus-newsgroup-name
+                                     (gnus-group-name-charset 
+                                      nil
+                                      gnus-newsgroup-name)))
                (gnus-tmp-article-number (or gnus-current-article 0))
                (gnus-tmp-unread gnus-newsgroup-unreads)
                (gnus-tmp-unread-and-unticked (length gnus-newsgroup-unreads))
@@ -4227,7 +4538,7 @@ If WHERE is `summary', the summary mode line format will be used."
           ;; We might have to chop a bit of the string off...
           (when (> (length mode-string) max-len)
             (setq mode-string
-                  (concat (gnus-truncate-string mode-string (- max-len 3))
+                  (concat (truncate-string-to-width mode-string (- max-len 3))
                           "...")))
           ;; Pad the mode string a bit.
           (setq mode-string (format (format "%%-%ds" max-len) mode-string))))
@@ -4305,7 +4616,7 @@ The resulting hash table is returned, or nil if no Xrefs were found."
          (active (gnus-active group))
          ninfo)
     (when entry
-      ;; First peel off all illegal article numbers.
+      ;; First peel off all invalid article numbers.
       (when active
         (let ((ids articles)
               id first)
@@ -4374,15 +4685,6 @@ The resulting hash table is returned, or nil if no Xrefs were found."
         ;; Update the group buffer.
         (gnus-group-update-group group t)))))
 
-(defun gnus-methods-equal-p (m1 m2)
-  (let ((m1 (or m1 gnus-select-method))
-        (m2 (or m2 gnus-select-method)))
-    (or (equal m1 m2)
-        (and (eq (car m1) (car m2))
-             (or (not (memq 'address (assoc (symbol-name (car m1))
-                                            gnus-valid-select-methods)))
-                 (equal (nth 1 m1) (nth 1 m2)))))))
-
 (defvar gnus-newsgroup-none-id 0)
 
 (defun gnus-get-newsgroup-headers (&optional dependencies force-new)
@@ -4391,11 +4693,18 @@ The resulting hash table is returned, or nil if no Xrefs were found."
          (or dependencies
              (save-excursion (set-buffer gnus-summary-buffer)
                              gnus-newsgroup-dependencies)))
-        headers id end ref)
+        headers id end ref
+        (mail-parse-charset gnus-newsgroup-charset)
+        (mail-parse-ignored-charsets
+         (save-excursion (condition-case nil
+                             (set-buffer gnus-summary-buffer)
+                           (error))
+                         gnus-newsgroup-ignored-charsets)))
     (save-excursion
       (set-buffer nntp-server-buffer)
       ;; Translate all TAB characters into SPACE characters.
       (subst-char-in-region (point-min) (point-max) ?\t ?  t)
+      (subst-char-in-region (point-min) (point-max) ?\r ?  t)
       (gnus-run-hooks 'gnus-parse-headers-hook)
       (let ((case-fold-search t)
             in-reply-to header p lines chars)
@@ -4427,15 +4736,15 @@ The resulting hash table is returned, or nil if no Xrefs were found."
             (progn
               (goto-char p)
               (if (search-forward "\nsubject: " nil t)
-                  (funcall
-                   gnus-unstructured-field-decoder (nnheader-header-value))
+                  (funcall gnus-decode-encoded-word-function
+                           (nnheader-header-value))
                 "(none)"))
             ;; From.
             (progn
               (goto-char p)
               (if (search-forward "\nfrom: " nil t)
-                  (funcall
-                   gnus-structured-field-decoder (nnheader-header-value))
+                  (funcall gnus-decode-encoded-word-function
+                           (nnheader-header-value))
                 "(nobody)"))
             ;; Date.
             (progn
@@ -4505,7 +4814,19 @@ The resulting hash table is returned, or nil if no Xrefs were found."
             (progn
               (goto-char p)
               (and (search-forward "\nxref: " nil t)
-                   (nnheader-header-value)))))
+                   (nnheader-header-value)))
+            ;; Extra.
+            (when gnus-extra-headers
+              (let ((extra gnus-extra-headers)
+                    out)
+                (while extra
+                  (goto-char p)
+                  (when (search-forward
+                         (concat "\n" (symbol-name (car extra)) ": ") nil t)
+                    (push (cons (car extra) (nnheader-header-value))
+                          out))
+                  (pop extra))
+                out))))
           (when (equal id ref)
             (setq ref nil))
 
@@ -4526,16 +4847,20 @@ The resulting hash table is returned, or nil if no Xrefs were found."
 (defun gnus-get-newsgroup-headers-xover (sequence &optional
                                                   force-new dependencies
                                                   group also-fetch-heads)
-  "Parse the news overview data in the server buffer, and return a
-list of headers that match SEQUENCE (see `nntp-retrieve-headers')."
+  "Parse the news overview data in the server buffer.
+Return a list of headers that match SEQUENCE (see
+`nntp-retrieve-headers')."
   ;; Get the Xref when the users reads the articles since most/some
   ;; NNTP servers do not include Xrefs when using XOVER.
   (setq gnus-article-internal-prepare-hook '(gnus-article-get-xrefs))
-  (let ((cur nntp-server-buffer)
+  (let ((mail-parse-charset gnus-newsgroup-charset)
+        (mail-parse-ignored-charsets gnus-newsgroup-ignored-charsets)
+        (cur nntp-server-buffer)
         (dependencies (or dependencies gnus-newsgroup-dependencies))
         number headers header)
     (save-excursion
       (set-buffer nntp-server-buffer)
+      (subst-char-in-region (point-min) (point-max) ?\r ?  t)
       ;; Allow the user to mangle the headers before parsing them.
       (gnus-run-hooks 'gnus-parse-headers-hook)
       (goto-char (point-min))
@@ -4589,7 +4914,8 @@ This is meant to be called in `gnus-article-internal-prepare-hook'."
           (save-restriction
             (nnheader-narrow-to-headers)
             (goto-char (point-min))
-            (when (or (and (eq (downcase (following-char)) ?x)
+            (when (or (and (not (eobp))
+                           (eq (downcase (char-after)) ?x)
                            (looking-at "Xref:"))
                       (search-forward "\nXref:" nil t))
               (goto-char (1+ (match-end 0)))
@@ -4604,14 +4930,14 @@ the subject line on."
   (let* ((line (and (numberp old-header) old-header))
          (old-header (and (vectorp old-header) old-header))
          (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))
-        d)
+                        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))
+         d)
     (when header
       ;; Rebuild the thread that this article is part of and go to the
       ;; article we have fetched.
@@ -4706,7 +5032,8 @@ executed with point over the summary line of the articles."
     `(let ((,articles (gnus-summary-work-articles ,arg)))
        (while ,articles
          (gnus-summary-goto-subject (car ,articles))
-         ,@forms))))
+         ,@forms
+         (pop ,articles)))))
 
 (put 'gnus-summary-iterate 'lisp-indent-function 1)
 (put 'gnus-summary-iterate 'edebug-form-spec '(form body))
@@ -4851,9 +5178,12 @@ If `gnus-auto-center-summary' is nil, or the article buffer isn't
 displayed, no centering will be performed."
   ;; Suggested by earle@mahendo.JPL.NASA.GOV (Greg Earle).
   ;; Recenter only when requested.  Suggested by popovich@park.cs.columbia.edu.
+  (interactive)
   (let* ((top (cond ((< (window-height) 4) 0)
                     ((< (window-height) 7) 1)
-                    (t 2)))
+                    (t (if (numberp gnus-auto-center-summary)
+                           gnus-auto-center-summary
+                         2))))
          (height (1- (window-height)))
          (bottom (save-excursion (goto-char (point-max))
                                  (forward-line (- height))
@@ -4868,7 +5198,8 @@ displayed, no centering will be performed."
         ;; whichever is the least.
         (set-window-start
          window (min bottom (save-excursion
-                              (forward-line (- top)) (point)))))
+                              (forward-line (- top)) (point)))
+         t))
       ;; Do horizontal recentering while we're at it.
       (when (and (get-buffer-window (current-buffer) t)
                  (not (eq gnus-auto-center-summary 'vertical)))
@@ -4908,7 +5239,10 @@ displayed, no centering will be performed."
       ;; If the range of read articles is a single range, then the
       ;; first unread article is the article after the last read
       ;; article.  Sounds logical, doesn't it?
-      (if (not (listp (cdr read)))
+      (if (and (not (listp (cdr read)))
+               (or (< (car read) (car active))
+                   (progn (setq read (list read))
+                          nil)))
           (setq first (max (car active) (1+ (cdr read))))
         ;; `read' is a list of ranges.
         (when (/= (setq nlast (or (and (numberp (car read)) (car read))
@@ -4965,8 +5299,7 @@ displayed, no centering will be performed."
           (key-binding
            (read-key-sequence
             (substitute-command-keys
-             "\\<gnus-summary-mode-map>\\[gnus-summary-universal-argument]"
-             ))))
+             "\\<gnus-summary-mode-map>\\[gnus-summary-universal-argument]"))))
          'undefined)
         (gnus-error 1 "Undefined key")
       (save-excursion
@@ -5062,9 +5395,16 @@ If FORCE (the prefix), also save the .newsrc file(s)."
 
 (defun gnus-summary-exit (&optional temporary)
   "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."
+`gnus-exit-group-hook' is called with no arguments if that value is non-nil."
   (interactive)
   (gnus-set-global-variables)
+  (when (gnus-buffer-live-p gnus-article-buffer)
+    (save-excursion
+      (set-buffer gnus-article-buffer)
+      (mm-destroy-parts gnus-article-mime-handles)
+      ;; Set it to nil for safety reason.
+      (setq gnus-article-mime-handle-alist nil)
+      (setq gnus-article-mime-handles nil)))
   (gnus-kill-save-kill-buffer)
   (gnus-async-halt-prefetch)
   (let* ((group gnus-newsgroup-name)
@@ -5072,6 +5412,12 @@ gnus-exit-group-hook is called with no arguments if that value is non-nil."
          (mode major-mode)
          (group-point nil)
          (buf (current-buffer)))
+    (unless quit-config
+      ;; Do adaptive scoring, and possibly save score files.
+      (when gnus-newsgroup-adaptive
+        (gnus-score-adaptive))
+      (when gnus-use-scoring
+        (gnus-score-save)))
     (gnus-run-hooks 'gnus-summary-prepare-exit-hook)
     ;; If we have several article buffers, we kill them at exit.
     (unless gnus-single-article-buffer
@@ -5085,17 +5431,14 @@ gnus-exit-group-hook is called with no arguments if that value is non-nil."
       (gnus-dup-enter-articles))
     (when gnus-use-trees
       (gnus-tree-close group))
+    (when gnus-use-cache
+      (gnus-cache-write-active))
     ;; Remove entries for this 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)
-      (gnus-summary-update-info)
-      ;; Do adaptive scoring, and possibly save score files.
-      (when gnus-newsgroup-adaptive
-        (gnus-score-adaptive))
-      (when gnus-use-scoring
-        (gnus-score-save)))
+      (gnus-summary-update-info))
     (gnus-close-group group)
     ;; Make sure where we were, and go to next newsgroup.
     (set-buffer gnus-group-buffer)
@@ -5153,7 +5496,16 @@ gnus-exit-group-hook is called with no arguments if that value is non-nil."
               gnus-expert-user
               (gnus-y-or-n-p "Discard changes to this group and exit? "))
       (gnus-async-halt-prefetch)
-      (gnus-run-hooks 'gnus-summary-prepare-exit-hook)
+      (mapcar 'funcall
+              (delq 'gnus-summary-expire-articles
+                    (copy-sequence gnus-summary-prepare-exit-hook)))
+      (when (gnus-buffer-live-p gnus-article-buffer)
+        (save-excursion
+          (set-buffer gnus-article-buffer)
+          (mm-destroy-parts gnus-article-mime-handles)
+          ;; Set it to nil for safety reason.
+          (setq gnus-article-mime-handle-alist nil)
+          (setq gnus-article-mime-handles nil)))
       ;; If we have several article buffers, we kill them at exit.
       (unless gnus-single-article-buffer
         (gnus-kill-buffer gnus-article-buffer)
@@ -5261,7 +5613,8 @@ The state which existed when entering the ephemeral is reset."
       (rename-buffer
        (concat (substring name 0 (match-beginning 0)) "Dead "
                (substring name (match-beginning 0)))
-       t))))
+       t)
+      (bury-buffer))))
 
 (defun gnus-kill-or-deaden-summary (buffer)
   "Kill or deaden the summary BUFFER."
@@ -5322,8 +5675,7 @@ in."
 (defun gnus-summary-describe-briefly ()
   "Describe summary mode commands briefly."
   (interactive)
-  (gnus-message 6
-                (substitute-command-keys "\\<gnus-summary-mode-map>\\[gnus-summary-next-page]:Select  \\[gnus-summary-next-unread-article]:Forward  \\[gnus-summary-prev-unread-article]:Backward  \\[gnus-summary-exit]:Exit  \\[gnus-info-find-node]:Run Info  \\[gnus-summary-describe-briefly]:This help")))
+  (gnus-message 6 (substitute-command-keys "\\<gnus-summary-mode-map>\\[gnus-summary-next-page]:Select  \\[gnus-summary-next-unread-article]:Forward  \\[gnus-summary-prev-unread-article]:Backward  \\[gnus-summary-exit]:Exit  \\[gnus-info-find-node]:Run Info        \\[gnus-summary-describe-briefly]:This help")))
 
 ;; Walking around group mode buffer from summary mode.
 
@@ -5429,8 +5781,8 @@ returned."
                 (if backward
                     (gnus-summary-find-prev unread)
                   (gnus-summary-find-next unread)))
-      (gnus-summary-show-thread)
-      (setq n (1- n)))
+      (unless (zerop (setq n (1- n)))
+        (gnus-summary-show-thread)))
     (when (/= 0 n)
       (gnus-message 7 "No more%s articles"
                     (if unread " unread" "")))
@@ -5521,35 +5873,41 @@ be displayed."
     (set-buffer gnus-summary-buffer))
   (let ((article (or article (gnus-summary-article-number)))
         (all-headers (not (not all-headers))) ;Must be T or NIL.
-        gnus-summary-display-article-function
-        did)
+        gnus-summary-display-article-function)
     (and (not pseudo)
          (gnus-summary-article-pseudo-p article)
          (error "This is a pseudo-article"))
-    (prog1
-        (save-excursion
-          (set-buffer gnus-summary-buffer)
-          (if (or (and gnus-single-article-buffer
-                       (or (null gnus-current-article)
-                           (null gnus-article-current)
-                           (null (get-buffer gnus-article-buffer))
-                           (not (eq article (cdr gnus-article-current)))
-                           (not (equal (car gnus-article-current)
-                                       gnus-newsgroup-name))))
-                  (and (not gnus-single-article-buffer)
-                       (or (null gnus-current-article)
-                           (not (eq gnus-current-article article))))
-                  force)
-              ;; The requested article is different from the current article.
-              (prog1
-                  (gnus-summary-display-article article all-headers)
-                (setq did article))
+    (save-excursion
+      (set-buffer gnus-summary-buffer)
+      (if (or (and gnus-single-article-buffer
+                   (or (null gnus-current-article)
+                       (null gnus-article-current)
+                       (null (get-buffer gnus-article-buffer))
+                       (not (eq article (cdr gnus-article-current)))
+                       (not (equal (car gnus-article-current)
+                                   gnus-newsgroup-name))))
+              (and (not gnus-single-article-buffer)
+                   (or (null gnus-current-article)
+                       (not (eq gnus-current-article article))))
+              force)
+          ;; The requested article is different from the current article.
+          (progn
+            (when (gnus-buffer-live-p gnus-article-buffer)
+              (with-current-buffer gnus-article-buffer
+                (mm-enable-multibyte)))
+            (gnus-summary-display-article article all-headers)
+            (when (gnus-buffer-live-p gnus-article-buffer)
+              (with-current-buffer gnus-article-buffer
+                (if (not gnus-article-decoded-p) ;; a local variable
+                    (mm-disable-multibyte))))
             (when (or all-headers gnus-show-all-headers)
               (gnus-article-show-all-headers))
-            'old))
-      (when did
-        (gnus-article-set-window-start
-         (cdr (assq article gnus-newsgroup-bookmarks)))))))
+            (gnus-article-set-window-start
+             (cdr (assq article gnus-newsgroup-bookmarks)))
+            article)
+        (when (or all-headers gnus-show-all-headers)
+          (gnus-article-show-all-headers))
+        'old))))
 
 (defun gnus-summary-set-current-mark (&optional current-mark)
   "Obsolete function."
@@ -5821,15 +6179,25 @@ Return nil if there are no unread articles."
         (gnus-summary-display-article (gnus-summary-article-number)))
     (gnus-summary-position-point)))
 
+(defun gnus-summary-first-unread-subject ()
+  "Place the point on the subject line of the first unread article.
+Return nil if there are no unread articles."
+  (interactive)
+  (prog1
+      (when (gnus-summary-first-subject t)
+        (gnus-summary-show-thread)
+        (gnus-summary-first-subject t))
+    (gnus-summary-position-point)))
+
 (defun gnus-summary-first-article ()
   "Select the first article.
 Return nil if there are no articles."
   (interactive)
   (prog1
       (when (gnus-summary-first-subject)
-      (gnus-summary-show-thread)
-      (gnus-summary-first-subject)
-      (gnus-summary-display-article (gnus-summary-article-number)))
+        (gnus-summary-show-thread)
+        (gnus-summary-first-subject)
+        (gnus-summary-display-article (gnus-summary-article-number)))
     (gnus-summary-position-point)))
 
 (defun gnus-summary-best-unread-article ()
@@ -5951,16 +6319,32 @@ If given a prefix, remove all limits."
   "Limit the summary buffer to articles that are older than (or equal) AGE days.
 If YOUNGER-P (the prefix) is non-nil, limit the summary buffer to
 articles that are younger than AGE days."
-  (interactive "nTime in days: \nP")
+  (interactive
+   (let ((younger current-prefix-arg)
+         (days-got nil)
+         days)
+     (while (not days-got)
+       (setq days (if younger
+                      (read-string "Limit to articles within (in days): ")
+                    (read-string "Limit to articles old than (in days): ")))
+       (when (> (length days) 0)
+         (setq days (read days)))
+       (if (numberp days)
+           (setq days-got t)
+         (message "Please enter a number.")
+         (sleep-for 1)))
+     (list days younger)))
   (prog1
       (let ((data gnus-newsgroup-data)
-            (cutoff (nnmail-days-to-time age))
+            (cutoff (days-to-time age))
             articles d date is-younger)
         (while (setq d (pop data))
           (when (and (vectorp (gnus-data-header d))
                      (setq date (mail-header-date (gnus-data-header d))))
-            (setq is-younger (nnmail-time-less
-                              (nnmail-time-since (nnmail-date-to-time date))
+            (setq is-younger (time-less-p
+                              (time-since (condition-case ()
+                                              (date-to-time date)
+                                            (error '(0 0))))
                               cutoff))
             (when (if younger-p
                       is-younger
@@ -5969,6 +6353,30 @@ articles that are younger than AGE days."
         (gnus-summary-limit (nreverse articles)))
     (gnus-summary-position-point)))
 
+(defun gnus-summary-limit-to-extra (header regexp)
+  "Limit the summary buffer to articles that match an 'extra' header."
+  (interactive
+   (let ((header
+          (intern
+           (gnus-completing-read
+            (symbol-name (car gnus-extra-headers))
+            "Limit extra header:"
+            (mapcar (lambda (x)
+                      (cons (symbol-name x) x))
+                    gnus-extra-headers)
+            nil
+            t))))
+     (list header
+           (read-string (format "Limit to header %s (regexp): " header)))))
+  (when (not (equal "" regexp))
+    (prog1
+        (let ((articles (gnus-summary-find-matching
+                         (cons 'extra header) regexp 'all)))
+          (unless articles
+            (error "Found no matches for \"%s\"" regexp))
+          (gnus-summary-limit articles))
+      (gnus-summary-position-point))))
+
 (defalias 'gnus-summary-delete-marked-as-read 'gnus-summary-limit-to-unread)
 (make-obsolete
  'gnus-summary-delete-marked-as-read 'gnus-summary-limit-to-unread)
@@ -6166,6 +6574,7 @@ If ALL, mark even excluded ticked and dormants as read."
   "Go forwards in the thread until we find an article that we want to display."
   (when (or (eq gnus-fetch-old-headers 'some)
             (eq gnus-fetch-old-headers 'invisible)
+            (numberp gnus-fetch-old-headers)
             (eq gnus-build-sparse-threads 'some)
             (eq gnus-build-sparse-threads 'more))
     ;; Deal with old-fetched headers and sparse threads.
@@ -6195,6 +6604,7 @@ If ALL, mark even excluded ticked and dormants as read."
   "Cut off all uninteresting articles from the beginning of threads."
   (when (or (eq gnus-fetch-old-headers 'some)
             (eq gnus-fetch-old-headers 'invisible)
+            (numberp gnus-fetch-old-headers)
             (eq gnus-build-sparse-threads 'some)
             (eq gnus-build-sparse-threads 'more))
     (let ((th threads))
@@ -6212,6 +6622,7 @@ fetch-old-headers verbiage, and so on."
   (if (or gnus-inhibit-limiting
           (and (null gnus-newsgroup-dormant)
                (not (eq gnus-fetch-old-headers 'some))
+               (not (numberp gnus-fetch-old-headers))
                (not (eq gnus-fetch-old-headers 'invisible))
                (null gnus-summary-expunge-below)
                (not (eq gnus-build-sparse-threads 'some))
@@ -6265,7 +6676,8 @@ fetch-old-headers verbiage, and so on."
                  (zerop children))
             ;; If this is "fetch-old-headered" and there is no
             ;; visible children, then we don't want this article.
-            (and (eq gnus-fetch-old-headers 'some)
+            (and (or (eq gnus-fetch-old-headers 'some)
+                     (numberp gnus-fetch-old-headers))
                  (gnus-summary-article-ancient-p number)
                  (zerop children))
             ;; If this is "fetch-old-headered" and `invisible', then
@@ -6416,11 +6828,9 @@ of what's specified by the `gnus-refer-thread-limit' variable."
       (gnus-message 5 "Fetching headers for %s...done" gnus-newsgroup-name))
     (gnus-summary-limit-include-thread id)))
 
-(defun gnus-summary-refer-article (message-id &optional arg)
-  "Fetch an article specified by MESSAGE-ID.
-If ARG (the prefix), fetch the article using `gnus-refer-article-method'
-or `gnus-select-method', no matter what backend the article comes from."
-  (interactive "sMessage-ID: \nP")
+(defun gnus-summary-refer-article (message-id)
+  "Fetch an article specified by MESSAGE-ID."
+  (interactive "sMessage-ID: ")
   (when (and (stringp message-id)
              (not (zerop (length message-id))))
     ;; Construct the correct Message-ID if necessary.
@@ -6434,7 +6844,8 @@ or `gnus-select-method', no matter what backend the article comes from."
                         (gnus-summary-article-sparse-p
                          (mail-header-number header))
                         (memq (mail-header-number header)
-                              gnus-newsgroup-limit))))
+                              gnus-newsgroup-limit)))
+           number)
       (cond
        ;; If the article is present in the buffer we just go to it.
        ((and header
@@ -6447,28 +6858,48 @@ or `gnus-select-method', no matter what backend the article comes from."
           (when sparse
             (gnus-summary-update-article (mail-header-number header)))))
        (t
-        ;; We fetch the article
-        (let ((gnus-override-method
-               (cond ((gnus-news-group-p gnus-newsgroup-name)
-                      gnus-refer-article-method)
-                     (arg
-                      (or gnus-refer-article-method gnus-select-method))
-                     (t nil)))
-              number)
-          ;; Start the special refer-article method, if necessary.
-          (when (and gnus-refer-article-method
-                     (gnus-news-group-p gnus-newsgroup-name))
-            (gnus-check-server gnus-refer-article-method))
-          ;; Fetch the header, and display the article.
-          (if (setq number (gnus-summary-insert-subject message-id))
+        ;; We fetch the article.
+        (catch 'found
+          (dolist (gnus-override-method (gnus-refer-article-methods))
+            (gnus-check-server gnus-override-method)
+            ;; Fetch the header, and display the article.
+            (when (setq number (gnus-summary-insert-subject message-id))
               (gnus-summary-select-article nil nil nil number)
-            (gnus-message 3 "Couldn't fetch article %s" message-id))))))))
+              (throw 'found t)))
+          (gnus-message 3 "Couldn't fetch article %s" message-id)))))))
+
+(defun gnus-refer-article-methods ()
+  "Return a list of referrable methods."
+  (cond
+   ;; No method, so we default to current and native.
+   ((null gnus-refer-article-method)
+    (list gnus-current-select-method gnus-select-method))
+   ;; Current.
+   ((eq 'current gnus-refer-article-method)
+    (list gnus-current-select-method))
+   ;; List of select methods.
+   ((not (stringp (cadr gnus-refer-article-method)))
+    (let (out)
+      (dolist (method gnus-refer-article-method)
+        (push (if (eq 'current method)
+                  gnus-current-select-method
+                method)
+              out))
+      (nreverse out)))
+   ;; One single select method.
+   (t
+    (list gnus-refer-article-method))))
 
 (defun gnus-summary-edit-parameters ()
   "Edit the group parameters of the current group."
   (interactive)
   (gnus-group-edit-group gnus-newsgroup-name 'params))
 
+(defun gnus-summary-customize-parameters ()
+  "Customize the group parameters of the current group."
+  (interactive)
+  (gnus-group-customize gnus-newsgroup-name))
+
 (defun gnus-summary-enter-digest-group (&optional force)
   "Enter an nndoc group based on the current article.
 If FORCE, force a digest interpretation.  If not, try
@@ -6490,8 +6921,14 @@ to guess what the document format is."
                            (list (cons 'save-article-group ogroup))))
            (case-fold-search t)
            (buf (current-buffer))
-           dig)
+           dig to-address)
       (save-excursion
+        (set-buffer gnus-original-article-buffer)
+        ;; Have the digest group inherit the main mail address of
+        ;; the parent article.
+        (when (setq to-address (or (message-fetch-field "reply-to")
+                                   (message-fetch-field "from")))
+          (setq params (append (list (cons 'to-address to-address)))))
         (setq dig (nnheader-set-temp-buffer " *gnus digest buffer*"))
         (insert-buffer-substring gnus-original-article-buffer)
         ;; Remove lines that may lead nndoc to misinterpret the
@@ -6500,14 +6937,17 @@ to guess what the document format is."
          (goto-char (point-min))
          (or (search-forward "\n\n" nil t) (point)))
         (goto-char (point-min))
-        (delete-matching-lines "^\\(Path\\):\\|^From ")
+        (delete-matching-lines "^Path:\\|^From ")
         (widen))
       (unwind-protect
-          (if (gnus-group-read-ephemeral-group
-               name `(nndoc ,name (nndoc-address ,(get-buffer dig))
-                            (nndoc-article-type
-                             ,(if force 'digest 'guess))) t)
-              ;; Make all postings to this group go to the parent group.
+          (if (let ((gnus-newsgroup-ephemeral-charset gnus-newsgroup-charset)
+                    (gnus-newsgroup-ephemeral-ignored-charsets
+                     gnus-newsgroup-ignored-charsets))
+                (gnus-group-read-ephemeral-group
+                 name `(nndoc ,name (nndoc-address ,(get-buffer dig))
+                              (nndoc-article-type
+                               ,(if force 'mbox 'guess))) t))
+              ;; Make all postings to this group go to the parent group.
               (nconc (gnus-info-params (gnus-get-info name))
                      params)
             ;; Couldn't select this doc group.
@@ -6533,7 +6973,7 @@ Obeys the standard process/prefix convention."
       (gnus-summary-remove-process-mark article)
       (when (gnus-summary-display-article article)
         (save-excursion
-          (nnheader-temp-write nil
+          (with-temp-buffer
             (insert-buffer-substring gnus-original-article-buffer)
             ;; Remove some headers that may lead nndoc to make
             ;; the wrong guess.
@@ -6613,18 +7053,21 @@ Optional argument BACKWARD means do search for backward.
   ;; We have to require this here to make sure that the following
   ;; dynamic binding isn't shadowed by autoloading.
   (require 'gnus-async)
+  (require 'gnus-art)
   (let ((gnus-select-article-hook nil)  ;Disable hook.
-        (gnus-article-display-hook nil)
+        (gnus-article-prepare-hook nil)
         (gnus-mark-article-hook nil)    ;Inhibit marking as read.
         (gnus-use-article-prefetch nil)
         (gnus-xmas-force-redisplay nil) ;Inhibit XEmacs redisplay.
         (gnus-use-trees nil)            ;Inhibit updating tree buffer.
         (sum (current-buffer))
+        (gnus-display-mime-function nil)
         (found nil)
         point)
     (gnus-save-hidden-threads
       (gnus-summary-select-article)
       (set-buffer gnus-article-buffer)
+      (goto-char (window-point (get-buffer-window (current-buffer))))
       (when backward
         (forward-line -1))
       (while (not found)
@@ -6640,6 +7083,9 @@ Optional argument BACKWARD means do search for backward.
                (get-buffer-window (current-buffer))
                (point))
               (forward-line 1)
+              (set-window-point
+               (get-buffer-window (current-buffer))
+               (point))
               (set-buffer sum)
               (setq point (point)))
           ;; We didn't find it, so we go to the next article.
@@ -6678,11 +7124,18 @@ in the comparisons."
   (let ((data (if (eq backward 'all) gnus-newsgroup-data
                 (gnus-data-find-list
                  (gnus-summary-article-number) (gnus-data-list backward))))
-        (func `(lambda (h) (,(intern (concat "mail-header-" header)) h)))
         (case-fold-search (not not-case-fold))
-        articles d)
-    (unless (fboundp (intern (concat "mail-header-" header)))
-      (error "%s is not a valid header" header))
+        articles d func)
+    (if (consp header)
+        (if (eq (car header) 'extra)
+            (setq func
+                  `(lambda (h)
+                     (or (cdr (assq ',(cdr header) (mail-header-extra h)))
+                         "")))
+          (error "%s is an invalid header" header))
+      (unless (fboundp (intern (concat "mail-header-" header)))
+        (error "%s is not a valid header" header))
+      (setq func `(lambda (h) (,(intern (concat "mail-header-" header)) h))))
     (while data
       (setq d (car data))
       (and (or (not unread)             ; We want all articles...
@@ -6751,7 +7204,7 @@ article.  If BACKWARD (the prefix) is non-nil, search backward instead."
 If N is negative, print the N previous articles.  If N is nil and articles
 have been marked with the process mark, print these instead.
 
-If the optional second argument FILENAME is nil, send the image to the
+If the optional first argument FILENAME is nil, send the image to the
 printer.  If FILENAME is a string, save the PostScript image in a file with
 that name.  If FILENAME is a number, prompt the user for the name of the file
 to save in."
@@ -6784,20 +7237,42 @@ to save in."
 
 (defun gnus-summary-show-article (&optional arg)
   "Force re-fetching of the current article.
-If ARG (the prefix) is non-nil, show the raw article without any
-article massaging functions being run."
+If ARG (the prefix) is a number, show the article with the charset
+defined in `gnus-summary-show-article-charset-alist', or the charset
+inputed.
+If ARG (the prefix) is non-nil and not a number, show the raw article
+without any article massaging functions being run."
   (interactive "P")
-  (if (not arg)
-      ;; Select the article the normal way.
-      (gnus-summary-select-article nil 'force)
+  (cond
+   ((numberp arg)
+    (let ((gnus-newsgroup-charset
+           (or (cdr (assq arg gnus-summary-show-article-charset-alist))
+               (read-coding-system "Charset: ")))
+          (gnus-newsgroup-ignored-charsets 'gnus-all))
+      (gnus-summary-select-article nil 'force)))
+   ((not arg)
+    ;; Select the article the normal way.
+    (gnus-summary-select-article nil 'force))
+   (t
+    ;; We have to require this here to make sure that the following
+    ;; dynamic binding isn't shadowed by autoloading.
+    (require 'gnus-async)
+    (require 'gnus-art)
     ;; Bind the article treatment functions to nil.
     (let ((gnus-have-all-headers t)
-          gnus-article-display-hook
           gnus-article-prepare-hook
-          gnus-break-pages
-          gnus-show-mime
-          gnus-visual)
-      (gnus-summary-select-article nil 'force)))
+          gnus-article-decode-hook
+          gnus-display-mime-function
+          gnus-break-pages)
+      ;; Destroy any MIME parts.
+      (when (gnus-buffer-live-p gnus-article-buffer)
+        (save-excursion
+          (set-buffer gnus-article-buffer)
+          (mm-destroy-parts gnus-article-mime-handles)
+          ;; Set it to nil for safety reason.
+          (setq gnus-article-mime-handle-alist nil)
+          (setq gnus-article-mime-handles nil)))
+      (gnus-summary-select-article nil 'force))))
   (gnus-summary-goto-subject gnus-current-article)
   (gnus-summary-position-point))
 
@@ -6821,40 +7296,42 @@ If ARG is a negative number, hide the unwanted header lines."
   (interactive "P")
   (save-excursion
     (set-buffer gnus-article-buffer)
-    (let* ((buffer-read-only nil)
-           (inhibit-point-motion-hooks t)
-           (hidden (text-property-any
-                    (goto-char (point-min)) (search-forward "\n\n")
-                    'invisible t))
-           e)
-      (goto-char (point-min))
-      (when (search-forward "\n\n" nil t)
-        (delete-region (point-min) (1- (point))))
-      (goto-char (point-min))
-      (save-excursion
-        (set-buffer gnus-original-article-buffer)
+    (save-restriction
+      (let* ((buffer-read-only nil)
+             (inhibit-point-motion-hooks t)
+             hidden e)
+        (setq hidden
+              (if (numberp arg)
+                  (>= arg 0)
+                (save-restriction
+                  (article-narrow-to-head)
+                  (gnus-article-hidden-text-p 'headers))))
         (goto-char (point-min))
-        (setq e (1- (or (search-forward "\n\n" nil t) (point-max)))))
-      (insert-buffer-substring gnus-original-article-buffer 1 e)
-      (let ((article-inhibit-hiding t))
-        (gnus-run-hooks 'gnus-article-display-hook))
-      (when (or (not hidden) (and (numberp arg) (< arg 0)))
-        (gnus-article-hide-headers)))))
+        (when (search-forward "\n\n" nil t)
+          (delete-region (point-min) (1- (point))))
+        (goto-char (point-min))
+        (save-excursion
+          (set-buffer gnus-original-article-buffer)
+          (goto-char (point-min))
+          (setq e (1- (or (search-forward "\n\n" nil t) (point-max)))))
+        (insert-buffer-substring gnus-original-article-buffer 1 e)
+        (save-restriction
+          (narrow-to-region (point-min) (point))
+          (article-decode-encoded-words)
+          (if  hidden
+              (let ((gnus-treat-hide-headers nil)
+                    (gnus-treat-hide-boring-headers nil))
+                (setq gnus-article-wash-types
+                      (delq 'headers gnus-article-wash-types))
+                (gnus-treat-article 'head))
+            (gnus-treat-article 'head)))
+        (gnus-set-mode-line 'article)))))
 
 (defun gnus-summary-show-all-headers ()
   "Make all header lines visible."
   (interactive)
   (gnus-article-show-all-headers))
 
-(defun gnus-summary-toggle-mime (&optional arg)
-  "Toggle MIME processing.
-If ARG is a positive number, turn MIME processing on."
-  (interactive "P")
-  (setq gnus-show-mime
-        (if (null arg) (not gnus-show-mime)
-          (> (prefix-numeric-value arg) 0)))
-  (gnus-summary-select-article t 'force))
-
 (defun gnus-summary-caesar-message (&optional arg)
   "Caesar rotate the current article by 13.
 The numerical prefix specifies how many places to rotate each letter
@@ -6895,7 +7372,9 @@ re-spool using this method.
 
 For this function to work, both the current newsgroup and the
 newsgroup that you want to move to have to support the `request-move'
-and `request-accept' functions."
+and `request-accept' functions.
+
+ACTION can be either `move' (the default), `crosspost' or `copy'."
   (interactive "P")
   (unless action
     (setq action 'move))
@@ -6913,7 +7392,10 @@ and `request-accept' functions."
                     'request-replace-article gnus-newsgroup-name)))
          (error "The current group does not support article editing")))
   (let ((articles (gnus-summary-work-articles n))
-        (prefix (gnus-group-real-prefix gnus-newsgroup-name))
+        (prefix (if (gnus-check-backend-function
+                    'request-move-article gnus-newsgroup-name)
+                    (gnus-group-real-prefix gnus-newsgroup-name)
+                  ""))
         (names '((move "Move" "Moving")
                  (copy "Copy" "Copying")
                  (crosspost "Crosspost" "Crossposting")))
@@ -6932,7 +7414,8 @@ and `request-accept' functions."
              articles prefix))
       (set (intern (format "gnus-current-%s-group" action)) to-newsgroup))
     (setq to-method (or select-method
-                        (gnus-group-name-to-method to-newsgroup)))
+                        (gnus-server-to-method
+                         (gnus-group-method to-newsgroup))))
     ;; Check the method we are to move this article to...
     (unless (gnus-check-backend-function
              'request-accept-article (car to-method))
@@ -6958,7 +7441,7 @@ and `request-accept' functions."
                   gnus-newsgroup-name)) ; Server
           (list 'gnus-request-accept-article
                 to-newsgroup (list 'quote select-method)
-                (not articles))         ; Accept form
+                (not articles) t)       ; Accept form
           (not articles)))              ; Only save nov last time
         ;; Copy the article.
         ((eq action 'copy)
@@ -6966,7 +7449,7 @@ and `request-accept' functions."
            (set-buffer copy-buf)
            (when (gnus-request-article-this-buffer article gnus-newsgroup-name)
              (gnus-request-accept-article
-              to-newsgroup select-method (not articles)))))
+              to-newsgroup select-method (not articles) t))))
         ;; Crosspost the article.
         ((eq action 'crosspost)
          (let ((xref (message-tokenize-header
@@ -6999,19 +7482,21 @@ and `request-accept' functions."
                art-group))))))
       (cond
        ((not art-group)
-        (gnus-message 1 "Couldn't %s article %s"
-                      (cadr (assq action names)) article))
-       ((and (eq art-group 'junk)
-             (eq action 'move))
-        (gnus-summary-mark-article article gnus-canceled-mark)
-        (gnus-message 4 "Deleted article %s" article))
+        (gnus-message 1 "Couldn't %s article %s: %s"
+                      (cadr (assq action names)) article
+                      (nnheader-get-report (car to-method))))
+       ((eq art-group 'junk)
+        (when (eq action 'move)
+          (gnus-summary-mark-article article gnus-canceled-mark)
+          (gnus-message 4 "Deleted article %s" article)))
        (t
         (let* ((pto-group (gnus-group-prefixed-name
                            (car art-group) to-method))
                (entry
                 (gnus-gethash pto-group gnus-newsrc-hashtb))
                (info (nth 2 entry))
-               (to-group (gnus-info-group info)))
+               (to-group (gnus-info-group info))
+               to-marks)
           ;; Update the group that has been moved to.
           (when (and info
                      (memq action '(move copy)))
@@ -7019,49 +7504,54 @@ and `request-accept' functions."
               (push to-group to-groups))
 
             (unless (memq article gnus-newsgroup-unreads)
+              (push 'read to-marks)
               (gnus-info-set-read
                info (gnus-add-to-range (gnus-info-read info)
                                        (list (cdr art-group)))))
 
-            ;; Copy any marks over to the new group.
+            ;; See whether the article is to be put in the cache.
             (let ((marks gnus-article-mark-lists)
                   (to-article (cdr art-group)))
 
-              ;; See whether the article is to be put in the cache.
+              ;; Enter the article into the cache in the new group,
+              ;; if that is required.
               (when gnus-use-cache
                 (gnus-cache-possibly-enter-article
                  to-group to-article
-                 (let ((header (copy-sequence
-                                (gnus-summary-article-header article))))
-                   (mail-header-set-number header to-article)
-                   header)
                  (memq article gnus-newsgroup-marked)
                  (memq article gnus-newsgroup-dormant)
                  (memq article gnus-newsgroup-unreads)))
 
-              (when (and (equal to-group gnus-newsgroup-name)
-                         (not (memq article gnus-newsgroup-unreads)))
-                ;; Mark this article as read in this group.
-                (push (cons to-article gnus-read-mark) gnus-newsgroup-reads)
-                (setcdr (gnus-active to-group) to-article)
-                (setcdr gnus-newsgroup-active to-article))
-
-              (while marks
-                (when (memq article (symbol-value
-                                     (intern (format "gnus-newsgroup-%s"
-                                                     (caar marks)))))
-                  ;; If the other group is the same as this group,
-                  ;; then we have to add the mark to the list.
-                  (when (equal to-group gnus-newsgroup-name)
-                    (set (intern (format "gnus-newsgroup-%s" (caar marks)))
-                         (cons to-article
-                               (symbol-value
-                                (intern (format "gnus-newsgroup-%s"
-                                                (caar marks)))))))
-                  ;; Copy the marks to other group.
-                  (gnus-add-marked-articles
-                   to-group (cdar marks) (list to-article) info))
-                (setq marks (cdr marks)))
+              (when gnus-preserve-marks
+                ;; Copy any marks over to the new group.
+                (when (and (equal to-group gnus-newsgroup-name)
+                           (not (memq article gnus-newsgroup-unreads)))
+                  ;; Mark this article as read in this group.
+                  (push (cons to-article gnus-read-mark) gnus-newsgroup-reads)
+                  (setcdr (gnus-active to-group) to-article)
+                  (setcdr gnus-newsgroup-active to-article))
+
+                (while marks
+                  (when (memq article (symbol-value
+                                       (intern (format "gnus-newsgroup-%s"
+                                                       (caar marks)))))
+                    (push (cdar marks) to-marks)
+                    ;; If the other group is the same as this group,
+                    ;; then we have to add the mark to the list.
+                    (when (equal to-group gnus-newsgroup-name)
+                      (set (intern (format "gnus-newsgroup-%s" (caar marks)))
+                           (cons to-article
+                                 (symbol-value
+                                  (intern (format "gnus-newsgroup-%s"
+                                                  (caar marks)))))))
+                    ;; Copy the marks to other group.
+                    (gnus-add-marked-articles
+                     to-group (cdar marks) (list to-article) info))
+                  (setq marks (cdr marks)))
+
+                (gnus-request-set-mark to-group (list (list (list to-article)
+                                                            'set
+                                                            to-marks))))
 
               (gnus-dribble-enter
                (concat "(gnus-group-set-info '"
@@ -7174,9 +7664,8 @@ latter case, they will be copied into the relevant groups."
         (error "Can't read %s" file))
     (save-excursion
       (set-buffer (gnus-get-buffer-create " *import file*"))
-      (buffer-disable-undo (current-buffer))
       (erase-buffer)
-      (insert-file-contents file)
+      (nnheader-insert-file-contents file)
       (goto-char (point-min))
       (unless (nnheader-article-p)
         ;; This doesn't look like an article, so we fudge some headers.
@@ -7184,10 +7673,7 @@ latter case, they will be copied into the relevant groups."
               lines (count-lines (point-min) (point-max)))
         (insert "From: " (read-string "From: ") "\n"
                 "Subject: " (read-string "Subject: ") "\n"
-                "Date: " (timezone-make-date-arpa-standard
-                          (current-time-string (nth 5 atts))
-                          (current-time-zone now)
-                          (current-time-zone now))
+                "Date: " (message-make-date (nth 5 atts))
                 "\n"
                 "Message-ID: " (message-make-message-id) "\n"
                 "Lines: " (int-to-string lines) "\n"
@@ -7196,12 +7682,11 @@ latter case, they will be copied into the relevant groups."
       (kill-buffer (current-buffer)))))
 
 (defun gnus-summary-article-posted-p ()
-  "Say whether the current (mail) article is available from `gnus-select-method' as well.
+  "Say whether the current (mail) article is available from news as well.
 This will be the case if the article has both been mailed and posted."
   (interactive)
   (let ((id (mail-header-references (gnus-summary-article-header)))
-        (gnus-override-method
-         (or gnus-refer-article-method gnus-select-method)))
+        (gnus-override-method (car (gnus-refer-article-methods))))
     (if (gnus-request-head id "")
         (gnus-message 2 "The current message was found on %s"
                       gnus-override-method)
@@ -7229,11 +7714,16 @@ This will be the case if the article has both been mailed and posted."
            (expiry-wait (if now 'immediate
                           (gnus-group-find-parameter
                            gnus-newsgroup-name 'expiry-wait)))
+           (nnmail-expiry-target
+            (or (gnus-group-find-parameter gnus-newsgroup-name 'expiry-target)
+                nnmail-expiry-target))
            es)
       (when expirable
         ;; There are expirable articles in this group, so we run them
         ;; through the expiry process.
         (gnus-message 6 "Expiring articles...")
+        (unless (gnus-check-group gnus-newsgroup-name)
+          (error "Can't open server for %s" gnus-newsgroup-name))
         ;; The list of articles that weren't expired is returned.
         (save-excursion
           (if expiry-wait
@@ -7281,6 +7771,8 @@ delete these instead."
   (unless (gnus-check-backend-function 'request-expire-articles
                                        gnus-newsgroup-name)
     (error "The current newsgroup does not support article deletion"))
+  (unless (gnus-check-server (gnus-find-method-for-group gnus-newsgroup-name))
+    (error "Couldn't open server"))
   ;; Compute the list of articles to delete.
   (let ((articles (sort (copy-sequence (gnus-summary-work-articles n)) '<))
         not-deleted)
@@ -7307,28 +7799,63 @@ delete these instead."
     (gnus-set-mode-line 'summary)
     not-deleted))
 
-(defun gnus-summary-edit-article (&optional force)
+(defun gnus-summary-edit-article (&optional arg)
   "Edit the current article.
 This will have permanent effect only in mail groups.
-If FORCE is non-nil, allow editing of articles even in read-only
+If ARG is nil, edit the decoded articles.
+If ARG is 1, edit the raw articles. 
+If ARG is 2, edit the raw articles even in read-only groups.
+Otherwise, allow editing of articles even in read-only
 groups."
   (interactive "P")
-  (save-excursion
-    (set-buffer gnus-summary-buffer)
-    (gnus-set-global-variables)
-    (when (and (not force)
-               (gnus-group-read-only-p))
-      (error "The current newsgroup does not support article editing"))
-    ;; Select article if needed.
-    (unless (eq (gnus-summary-article-number)
-                gnus-current-article)
-      (gnus-summary-select-article t))
-    (gnus-article-date-original)
-    (gnus-article-edit-article
-     `(lambda (no-highlight)
-        (gnus-summary-edit-article-done
-         ,(or (mail-header-references gnus-current-headers) "")
-         ,(gnus-group-read-only-p) ,gnus-summary-buffer no-highlight)))))
+  (let (force raw)
+    (cond 
+     ((null arg))
+     ((eq arg 1) (setq raw t))
+     ((eq arg 2) (setq raw t
+                       force t))
+     (t (setq force t)))
+    (if (and raw (not force) (equal gnus-newsgroup-name "nndraft:drafts"))
+        (error "Can't edit the raw article in group nndraft:drafts."))
+    (save-excursion
+      (set-buffer gnus-summary-buffer)
+      (let ((mail-parse-charset gnus-newsgroup-charset)
+            (mail-parse-ignored-charsets gnus-newsgroup-ignored-charsets))
+        (gnus-set-global-variables)
+        (when (and (not force)
+                   (gnus-group-read-only-p))
+          (error "The current newsgroup does not support article editing"))
+        (gnus-summary-show-article t)
+        (when (and (not raw) (gnus-buffer-live-p gnus-article-buffer))
+          (with-current-buffer gnus-article-buffer
+            (mm-enable-multibyte)))
+        (if (equal gnus-newsgroup-name "nndraft:drafts")
+            (setq raw t))
+        (gnus-article-edit-article
+         (if raw 'ignore 
+           #'(lambda () 
+               (let ((mbl mml-buffer-list))
+                 (setq mml-buffer-list nil)
+                 (mime-to-mml)
+                 (make-local-hook 'kill-buffer-hook)
+                 (let ((mml-buffer-list mml-buffer-list))
+                   (setq mml-buffer-list mbl)
+                   (make-local-variable 'mml-buffer-list))
+                 (add-hook 'kill-buffer-hook 'mml-destroy-buffers t t))))
+         `(lambda (no-highlight)
+            (let ((mail-parse-charset ',gnus-newsgroup-charset)
+                  (mail-parse-ignored-charsets 
+                   ',gnus-newsgroup-ignored-charsets))
+              ,(if (not raw) '(progn 
+                                (mml-to-mime)
+                                (mml-destroy-buffers)
+                                (remove-hook 'kill-buffer-hook 
+                                             'mml-destroy-buffers t)
+                                (kill-local-variable 'mml-buffer-list)))
+              (gnus-summary-edit-article-done
+               ,(or (mail-header-references gnus-current-headers) "")
+               ,(gnus-group-read-only-p) 
+               ,gnus-summary-buffer no-highlight))))))))
 
 (defalias 'gnus-summary-edit-article-postpone 'gnus-article-edit-exit)
 
@@ -7338,12 +7865,12 @@ groups."
   (interactive)
   ;; Replace the article.
   (let ((buf (current-buffer)))
-    (nnheader-temp-write nil
-      (insert-buffer buf)
+    (with-temp-buffer
+      (insert-buffer-substring buf)
       (if (and (not read-only)
                (not (gnus-request-replace-article
                      (cdr gnus-article-current) (car gnus-article-current)
-                     (current-buffer))))
+                     (current-buffer) t)))
           (error "Couldn't replace article")
         ;; Update the summary buffer.
         (if (and references
@@ -7356,7 +7883,7 @@ groups."
                 (message-narrow-to-head)
                 (let ((head (buffer-string))
                       header)
-                  (nnheader-temp-write nil
+                  (with-temp-buffer
                     (insert (format "211 %d Article retrieved.\n"
                                     (cdr gnus-article-current)))
                     (insert head)
@@ -7381,7 +7908,8 @@ groups."
         (unless no-highlight
           (save-excursion
             (set-buffer gnus-article-buffer)
-            (gnus-run-hooks 'gnus-article-display-hook)
+            ;;;!!! Fix this -- article should be rehighlighted.
+            ;;;(gnus-run-hooks 'gnus-article-display-hook)
             (set-buffer gnus-original-article-buffer)
             (gnus-request-article
              (cdr gnus-article-current)
@@ -7544,7 +8072,7 @@ the actual number of articles marked is returned."
   "Mark ARTICLE replied and update the summary line."
   (push article gnus-newsgroup-replied)
   (let ((buffer-read-only nil))
-    (when (gnus-summary-goto-subject article)
+    (when (gnus-summary-goto-subject article nil t)
       (gnus-summary-update-secondary-mark article))))
 
 (defun gnus-summary-set-bookmark (article)
@@ -7624,8 +8152,10 @@ the actual number of articles marked is returned."
   "Mark N articles as read forwards.
 If N is negative, mark backwards instead.  Mark with MARK, ?r by default.
 The difference between N and the actual number of articles marked is
-returned."
+returned.
+Iff NO-EXPIRE, auto-expiry will be inhibited."
   (interactive "p")
+  (gnus-summary-show-thread)
   (let ((backward (< n 0))
         (gnus-summary-goto-unread
          (and gnus-summary-goto-unread
@@ -7663,11 +8193,7 @@ returned."
     (setq mark (gnus-request-update-mark gnus-newsgroup-name article mark))
     ;; Check for auto-expiry.
     (when (and gnus-newsgroup-auto-expire
-               (or (= mark gnus-killed-mark) (= mark gnus-del-mark)
-                   (= mark gnus-catchup-mark) (= mark gnus-low-score-mark)
-                   (= mark gnus-ancient-mark)
-                   (= mark gnus-read-mark) (= mark gnus-souped-mark)
-                   (= mark gnus-duplicate-mark)))
+               (memq mark gnus-auto-expirable-marks))
       (setq mark gnus-expirable-mark)
       ;; Let the backend know about the mark change.
       (setq mark (gnus-request-update-mark gnus-newsgroup-name article mark))
@@ -7706,7 +8232,6 @@ returned."
              (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))))
 
@@ -7718,25 +8243,22 @@ returned."
   "Mark ARTICLE with MARK.  MARK can be any character.
 Four MARK strings are reserved: `? ' (unread), `?!' (ticked),
 `??' (dormant) and `?E' (expirable).
-If MARK is nil, then the default character `?D' is used.
+If MARK is nil, then the default character `?r' is used.
 If ARTICLE is nil, then the article on the current line will be
-marked."
+marked.
+Iff NO-EXPIRE, auto-expiry will be inhibited."
   ;; The mark might be a string.
   (when (stringp mark)
     (setq mark (aref mark 0)))
   ;; If no mark is given, then we check auto-expiring.
-  (and (not no-expire)
-       gnus-newsgroup-auto-expire
-       (or (not mark)
-           (and (gnus-characterp mark)
-                (or (= mark gnus-killed-mark) (= mark gnus-del-mark)
-                    (= mark gnus-catchup-mark) (= mark gnus-low-score-mark)
-                    (= mark gnus-read-mark) (= mark gnus-souped-mark)
-                    (= mark gnus-duplicate-mark))))
-       (setq mark gnus-expirable-mark))
-  (let* ((mark (or mark gnus-del-mark))
-         (article (or article (gnus-summary-article-number)))
-         (old-mark (gnus-summary-article-mark article)))
+  (when (null mark)
+    (setq mark gnus-del-mark))
+  (when (and (not no-expire)
+             gnus-newsgroup-auto-expire
+             (memq mark gnus-auto-expirable-marks))
+    (setq mark gnus-expirable-mark))
+  (let ((article (or article (gnus-summary-article-number)))
+        (old-mark (gnus-summary-article-mark article)))
     ;; Allow the backend to change the mark.
     (setq mark (gnus-request-update-mark gnus-newsgroup-name article mark))
     (if (eq mark old-mark)
@@ -7756,7 +8278,6 @@ marked."
              (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))))
 
@@ -7788,19 +8309,19 @@ marked."
   (let ((forward (cdr (assq type gnus-summary-mark-positions)))
         (buffer-read-only nil))
     (re-search-backward "[\n\r]" (gnus-point-at-bol) 'move-to-limit)
-    (when (looking-at "\r")
-      (incf forward))
-    (when (and forward
-               (<= (+ forward (point)) (point-max)))
-      ;; Go to the right position on the line.
-      (goto-char (+ forward (point)))
-      ;; Replace the old mark with the new mark.
-      (subst-char-in-region (point) (1+ (point)) (following-char) mark)
-      ;; Optionally update the marks by some user rule.
-      (when (eq type 'unread)
-        (gnus-data-set-mark
-         (gnus-data-find (gnus-summary-article-number)) mark)
-        (gnus-summary-update-line (eq mark gnus-unread-mark))))))
+    (when forward
+      (when (looking-at "\r")
+        (incf forward))
+      (when (<= (+ forward (point)) (point-max))
+        ;; Go to the right position on the line.
+        (goto-char (+ forward (point)))
+        ;; Replace the old mark with the new mark.
+        (subst-char-in-region (point) (1+ (point)) (char-after) mark)
+        ;; Optionally update the marks by some user rule.
+        (when (eq type 'unread)
+          (gnus-data-set-mark
+           (gnus-data-find (gnus-summary-article-number)) mark)
+          (gnus-summary-update-line (eq mark gnus-unread-mark)))))))
 
 (defun gnus-mark-article-as-read (article &optional mark)
   "Enter ARTICLE in the pertinent lists and remove it from others."
@@ -7881,14 +8402,15 @@ If N is negative, mark backwards instead.
 The difference between N and the actual number of articles marked is
 returned."
   (interactive "p")
-  (gnus-summary-mark-forward n gnus-del-mark t))
+  (gnus-summary-mark-forward n gnus-del-mark gnus-inhibit-user-auto-expire))
 
 (defun gnus-summary-mark-as-read-backward (n)
   "Mark the N articles as read backwards.
 The difference between N and the actual number of articles marked is
 returned."
   (interactive "p")
-  (gnus-summary-mark-forward (- n) gnus-del-mark t))
+  (gnus-summary-mark-forward
+   (- n) gnus-del-mark gnus-inhibit-user-auto-expire))
 
 (defun gnus-summary-mark-as-read (&optional article mark)
   "Mark current article as read.
@@ -8069,7 +8591,7 @@ If ALL is non-nil, also mark ticked and dormant articles as read."
   (gnus-summary-catchup t quietly))
 
 (defun gnus-summary-catchup-and-exit (&optional all quietly)
-  "Mark all articles not marked as unread in this newsgroup as read, then exit.
+  "Mark all unread articles in this group as read, then exit.
 If prefix argument ALL is non-nil, all articles are marked as read."
   (interactive "P")
   (when (gnus-summary-catchup all quietly nil 'fast)
@@ -8084,7 +8606,6 @@ If prefix argument ALL is non-nil, all articles are marked as read."
   (interactive "P")
   (gnus-summary-catchup-and-exit t quietly))
 
-;; Suggested by "Arne Eofsson" <arne@hodgkin.mbi.ucla.edu>.
 (defun gnus-summary-catchup-and-goto-next-group (&optional all)
   "Mark all articles in this group as read and select the next group.
 If given a prefix, mark all articles, unread as well as ticked, as
@@ -8092,7 +8613,38 @@ read."
   (interactive "P")
   (save-excursion
     (gnus-summary-catchup all))
-  (gnus-summary-next-article t nil nil t))
+  (gnus-summary-next-group))
+
+;;;
+;;; with article
+;;;
+
+(defmacro gnus-with-article (article &rest forms)
+  "Select ARTICLE and perform FORMS in the original article buffer.
+Then replace the article with the result."
+  `(progn
+     ;; We don't want the article to be marked as read.
+     (let (gnus-mark-article-hook)
+       (gnus-summary-select-article t t nil ,article))
+     (set-buffer gnus-original-article-buffer)
+     ,@forms
+     (if (not (gnus-check-backend-function
+               'request-replace-article (car gnus-article-current)))
+         (gnus-message 5 "Read-only group; not replacing")
+       (unless (gnus-request-replace-article
+                ,article (car gnus-article-current)
+                (current-buffer) t)
+         (error "Couldn't replace article")))
+     ;; The cache and backlog have to be flushed somewhat.
+     (when gnus-keep-backlog
+       (gnus-backlog-remove-article
+        (car gnus-article-current) (cdr gnus-article-current)))
+     (when gnus-use-cache
+       (gnus-cache-update-article
+        (car gnus-article-current) (cdr gnus-article-current)))))
+
+(put 'gnus-with-article 'lisp-indent-function 1)
+(put 'gnus-with-article 'edebug-form-spec '(form body))
 
 ;; Thread-based commands.
 
@@ -8171,25 +8723,17 @@ is non-nil or the Subject: of both articles are the same."
                          (gnus-summary-article-header parent-article))))
         (unless (and message-id (not (equal message-id "")))
           (error "No message-id in desired parent"))
-        ;; 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
-            (insert buf)
+        (gnus-with-article current-article
+          (save-restriction
             (goto-char (point-min))
+            (message-narrow-to-head)
             (if (re-search-forward "^References: " nil t)
                 (progn
                   (re-search-forward "^[^ \t]" nil t)
                   (forward-line -1)
                   (end-of-line)
                   (insert " " message-id))
-              (insert "References: " message-id "\n"))
-            (unless (gnus-request-replace-article
-                     current-article (car gnus-article-current)
-                     (current-buffer))
-              (error "Couldn't replace article"))))
+              (insert "References: " message-id "\n"))))
         (set-buffer gnus-summary-buffer)
         (gnus-summary-unmark-all-processable)
         (gnus-summary-update-article current-article)
@@ -8264,9 +8808,7 @@ Returns nil if no threads were there to be hidden."
                 (subst-char-in-region start (point) ?\n ?\^M)
                 (gnus-summary-goto-subject article))
             (goto-char start)
-            nil)
-        ;;(gnus-summary-position-point)
-        ))))
+            nil)))))
 
 (defun gnus-summary-go-to-next-thread (&optional previous)
   "Go to the same level (or less) next thread.
@@ -8398,14 +8940,14 @@ Argument REVERSE means reverse order."
 
 (defun gnus-summary-sort-by-author (&optional reverse)
   "Sort the summary buffer by author name alphabetically.
-If case-fold-search is non-nil, case of letters is ignored.
+If `case-fold-search' is non-nil, case of letters is ignored.
 Argument REVERSE means reverse order."
   (interactive "P")
   (gnus-summary-sort 'author reverse))
 
 (defun gnus-summary-sort-by-subject (&optional reverse)
   "Sort the summary buffer by subject alphabetically.  `Re:'s are ignored.
-If case-fold-search is non-nil, case of letters is ignored.
+If `case-fold-search' is non-nil, case of letters is ignored.
 Argument REVERSE means reverse order."
   (interactive "P")
   (gnus-summary-sort 'subject reverse))
@@ -8423,27 +8965,33 @@ Argument REVERSE means reverse order."
   (gnus-summary-sort 'score reverse))
 
 (defun gnus-summary-sort-by-lines (&optional reverse)
-  "Sort the summary buffer by article length.
+  "Sort the summary buffer by the number of lines.
 Argument REVERSE means reverse order."
   (interactive "P")
   (gnus-summary-sort 'lines reverse))
 
+(defun gnus-summary-sort-by-chars (&optional reverse)
+  "Sort the summary buffer by article length.
+Argument REVERSE means reverse order."
+  (interactive "P")
+  (gnus-summary-sort 'chars reverse))
+
 (defun gnus-summary-sort (predicate reverse)
   "Sort summary buffer by PREDICATE.  REVERSE means reverse order."
   (let* ((thread (intern (format "gnus-thread-sort-by-%s" predicate)))
          (article (intern (format "gnus-article-sort-by-%s" predicate)))
          (gnus-thread-sort-functions
-          (list
-           (if (not reverse)
-               thread
-             `(lambda (t1 t2)
-                (,thread t2 t1)))))
+          (if (not reverse)
+              thread
+            `(lambda (t1 t2)
+               (,thread t2 t1))))
+         (gnus-sort-gathered-threads-function
+          gnus-thread-sort-functions)
          (gnus-article-sort-functions
-          (list
-           (if (not reverse)
-               article
-             `(lambda (t1 t2)
-                (,article t2 t1)))))
+          (if (not reverse)
+              article
+            `(lambda (t1 t2)
+               (,article t2 t1))))
          (buffer-read-only)
          (gnus-summary-prepare-hook nil))
     ;; We do the sorting by regenerating the threads.
@@ -8466,10 +9014,9 @@ The variable `gnus-default-article-saver' specifies the saver function."
          (save-buffer (save-excursion
                         (nnheader-set-temp-buffer " *Gnus Save*")))
          (num (length articles))
-         header article file)
-    (while articles
-      (setq header (gnus-summary-article-header
-                    (setq article (pop articles))))
+         header file)
+    (dolist (article articles)
+      (setq header (gnus-summary-article-header article))
       (if (not (vectorp header))
           ;; This is a pseudo-article.
           (if (assq 'name header)
@@ -8599,16 +9146,14 @@ save those articles instead."
                            split-name))
                     ((consp result)
                      (setq split-name (append result split-name)))))))))
-    split-name))
+    (nreverse split-name)))
 
 (defun gnus-valid-move-group-p (group)
   (and (boundp group)
        (symbol-name group)
-       (memq 'respool
-             (assoc (symbol-name
-                     (car (gnus-find-method-for-group
-                           (symbol-name group))))
-                    gnus-valid-select-methods))))
+       (symbol-value group)
+       (gnus-get-function (gnus-find-method-for-group
+                           (symbol-name group)) 'request-accept-article t)))
 
 (defun gnus-read-move-group-name (prompt default articles prefix)
   "Read a group name."
@@ -8639,7 +9184,8 @@ save those articles instead."
                                   (mapcar (lambda (el) (list el))
                                           (nreverse split-name))
                                   nil nil nil
-                                  'gnus-group-history)))))
+                                  'gnus-group-history))))
+         (to-method (gnus-server-to-method (gnus-group-method to-newsgroup))))
     (when to-newsgroup
       (if (or (string= to-newsgroup "")
               (string= to-newsgroup prefix))
@@ -8647,18 +9193,62 @@ save those articles instead."
       (unless to-newsgroup
         (error "No group name entered"))
       (or (gnus-active to-newsgroup)
-          (gnus-activate-group to-newsgroup)
+          (gnus-activate-group to-newsgroup nil nil to-method)
           (if (gnus-y-or-n-p (format "No such group: %s.  Create it? "
                                      to-newsgroup))
-              (or (and (gnus-request-create-group
-                        to-newsgroup (gnus-group-name-to-method to-newsgroup))
-                       (gnus-activate-group to-newsgroup nil nil
-                                            (gnus-group-name-to-method
-                                             to-newsgroup)))
+              (or (and (gnus-request-create-group to-newsgroup to-method)
+                       (gnus-activate-group
+                        to-newsgroup nil nil to-method)
+                       (gnus-subscribe-group to-newsgroup))
                   (error "Couldn't create group %s" to-newsgroup)))
           (error "No such group: %s" to-newsgroup)))
     to-newsgroup))
 
+(defun gnus-summary-save-parts (type dir n &optional reverse)
+  "Save parts matching TYPE to DIR.
+If REVERSE, save parts that do not match TYPE."
+  (interactive
+   (list (read-string "Save parts of type: " 
+                      (or (car gnus-summary-save-parts-type-history)
+                          gnus-summary-save-parts-default-mime)
+                      'gnus-summary-save-parts-type-history)
+         (setq gnus-summary-save-parts-last-directory
+               (read-file-name "Save to directory: " 
+                               gnus-summary-save-parts-last-directory
+                               nil t))
+         current-prefix-arg))
+  (gnus-summary-iterate n
+    (let ((gnus-display-mime-function nil)
+          (gnus-inhibit-treatment t))
+      (gnus-summary-select-article))
+    (save-excursion
+      (set-buffer gnus-article-buffer)
+      (let ((handles (or gnus-article-mime-handles
+                         (mm-dissect-buffer) (mm-uu-dissect))))
+        (when handles
+          (gnus-summary-save-parts-1 type dir handles reverse)
+          (unless gnus-article-mime-handles ;; Don't destroy this case.
+            (mm-destroy-parts handles)))))))
+
+(defun gnus-summary-save-parts-1 (type dir handle reverse)
+  (if (stringp (car handle))
+      (mapcar (lambda (h) (gnus-summary-save-parts-1 type dir h reverse))
+              (cdr handle))
+    (when (if reverse
+              (not (string-match type (mm-handle-media-type handle)))
+            (string-match type (mm-handle-media-type handle)))
+      (let ((file (expand-file-name
+                   (file-name-nondirectory
+                    (or
+                     (mail-content-type-get
+                      (mm-handle-disposition handle) 'filename)
+                     (concat gnus-newsgroup-name
+                             "." (number-to-string
+                                  (cdr gnus-article-current)))))
+                   dir)))
+        (unless (file-exists-p file)
+          (mm-save-part-to-file handle file))))))
+
 ;; Summary extract commands
 
 (defun gnus-summary-insert-pseudos (pslist &optional not-view)
@@ -8694,7 +9284,7 @@ save those articles instead."
                                 (lambda (f)
                                   (if (equal f " ")
                                       f
-                                    (gnus-quote-arg-for-sh-or-csh f)))
+                                    (mm-quote-arg f)))
                                 files " ")))))
           (setq ps (cdr ps)))))
     (if (and gnus-view-pseudos (not not-view))
@@ -8771,8 +9361,10 @@ save those articles instead."
   "Read the headers of article ID and enter them into the Gnus system."
   (let ((group gnus-newsgroup-name)
         (gnus-override-method
-         (and (gnus-news-group-p gnus-newsgroup-name)
-              gnus-refer-article-method))
+         (or
+          gnus-override-method
+          (and (gnus-news-group-p gnus-newsgroup-name)
+               (car (gnus-refer-article-methods)))))
         where)
     ;; First we check to see whether the header in question is already
     ;; fetched.
@@ -8846,8 +9438,8 @@ save those articles instead."
 ;;;
 
 (defun gnus-highlight-selected-summary ()
+  "Highlight selected article in summary buffer."
   ;; Added by Per Abrahamsen <amanda@iesd.auc.dk>.
-  ;; Highlight selected article in summary buffer
   (when gnus-summary-selected-face
     (save-excursion
       (let* ((beg (progn (beginning-of-line) (point)))
@@ -8938,19 +9530,38 @@ save those articles instead."
         (setq unread (cdr unread)))
       (when (<= prev (cdr active))
         (push (cons prev (cdr active)) read))
+      (setq read (if (> (length read) 1) (nreverse read) read))
       (if compute
-          (if (> (length read) 1) (nreverse read) read)
+          read
         (save-excursion
-          (set-buffer gnus-group-buffer)
-          (gnus-undo-register
-            `(progn
-               (gnus-info-set-marks ',info ',(gnus-info-marks info) t)
-               (gnus-info-set-read ',info ',(gnus-info-read info))
-               (gnus-get-unread-articles-in-group ',info (gnus-active ,group))
-               (gnus-group-update-group ,group t))))
+          (let (setmarkundo)
+            ;; Propagate the read marks to the backend.
+            (when (gnus-check-backend-function 'request-set-mark group)
+              (let ((del (gnus-remove-from-range (gnus-info-read info) read))
+                    (add (gnus-remove-from-range read (gnus-info-read info))))
+                (when (or add del)
+                  (unless (gnus-check-group group)
+                    (error "Can't open server for %s" group))
+                  (gnus-request-set-mark
+                   group (delq nil (list (if add (list add 'add '(read)))
+                                         (if del (list del 'del '(read))))))
+                  (setq setmarkundo
+                        `(gnus-request-set-mark
+                          ,group
+                          ',(delq nil (list
+                                       (if del (list del 'add '(read)))
+                                       (if add (list add 'del '(read))))))))))
+            (set-buffer gnus-group-buffer)
+            (gnus-undo-register
+              `(progn
+                 (gnus-info-set-marks ',info ',(gnus-info-marks info) t)
+                 (gnus-info-set-read ',info ',(gnus-info-read info))
+                 (gnus-get-unread-articles-in-group ',info 
+                                                    (gnus-active ,group))
+                 (gnus-group-update-group ,group t)
+                 ,setmarkundo))))
         ;; Enter this list into the group info.
-        (gnus-info-set-read
-         info (if (> (length read) 1) (nreverse read) read))
+        (gnus-info-set-read info read)
         ;; Set the number of unread articles in gnus-newsrc-hashtb.
         (gnus-get-unread-articles-in-group info (gnus-active group))
         t))))
@@ -8983,6 +9594,165 @@ save those articles instead."
            (gnus-summary-exit))
          buffers)))))
 
+(defun gnus-summary-setup-default-charset ()
+  "Setup newsgroup default charset."
+  (if (equal gnus-newsgroup-name "nndraft:drafts")
+      (setq gnus-newsgroup-charset nil)
+    (let* ((name (and gnus-newsgroup-name
+                      (gnus-group-real-name gnus-newsgroup-name)))
+           (ignored-charsets
+            (or gnus-newsgroup-ephemeral-ignored-charsets
+                (append
+                 (and gnus-newsgroup-name
+                      (or (gnus-group-find-parameter gnus-newsgroup-name
+                                                     'ignored-charsets t)
+                          (let ((alist gnus-group-ignored-charsets-alist)
+                                elem (charsets nil))
+                            (while (setq elem (pop alist))
+                              (when (and name
+                                         (string-match (car elem) name))
+                                (setq alist nil
+                                      charsets (cdr elem))))
+                            charsets)))
+                 gnus-newsgroup-ignored-charsets))))
+      (setq gnus-newsgroup-charset
+            (or gnus-newsgroup-ephemeral-charset
+                (and gnus-newsgroup-name
+                     (or (gnus-group-find-parameter gnus-newsgroup-name 'charset)
+                         (let ((alist gnus-group-charset-alist)
+                               elem charset)
+                           (while (setq elem (pop alist))
+                             (when (and name
+                                        (string-match (car elem) name))
+                               (setq alist nil
+                                     charset (cadr elem))))
+                           charset)))
+                gnus-default-charset))
+      (set (make-local-variable 'gnus-newsgroup-ignored-charsets)
+           ignored-charsets))))
+
+;;;
+;;; Mime Commands
+;;;
+
+(defun gnus-summary-display-buttonized (&optional show-all-parts)
+  "Display the current article buffer fully MIME-buttonized.
+If SHOW-ALL-PARTS (the prefix) is non-nil, all multipart/* parts are
+treated as multipart/mixed."
+  (interactive "P")
+  (require 'gnus-art)
+  (let ((gnus-unbuttonized-mime-types nil)
+        (gnus-mime-display-multipart-as-mixed show-all-parts))
+    (gnus-summary-show-article)))
+
+(defun gnus-summary-repair-multipart (article)
+  "Add a Content-Type header to a multipart article without one."
+  (interactive (list (gnus-summary-article-number)))
+  (gnus-with-article article
+    (message-narrow-to-head)
+    (goto-char (point-max))
+    (widen)
+    (when (search-forward "\n--" nil t)
+      (let ((separator (buffer-substring (point) (gnus-point-at-eol))))
+        (message-narrow-to-head)
+        (message-remove-header "Mime-Version")
+        (message-remove-header "Content-Type")
+        (goto-char (point-max))
+        (insert (format "Content-Type: multipart/mixed; boundary=\"%s\"\n"
+                        separator))
+        (insert "Mime-Version: 1.0\n")
+        (widen))))
+  (let (gnus-mark-article-hook)
+    (gnus-summary-select-article t t nil article)))
+
+(defun gnus-summary-toggle-display-buttonized ()
+  "Toggle the buttonizing of the article buffer."
+  (interactive)
+  (require 'gnus-art)
+  (if (setq gnus-inhibit-mime-unbuttonizing
+            (not gnus-inhibit-mime-unbuttonizing))
+      (let ((gnus-unbuttonized-mime-types nil))
+        (gnus-summary-show-article))
+    (gnus-summary-show-article)))
+
+;;;
+;;; Generic summary marking commands
+;;;
+
+(defvar gnus-summary-marking-alist
+  '((read gnus-del-mark "d")
+    (unread gnus-unread-mark "u")
+    (ticked gnus-ticked-mark "!")
+    (dormant gnus-dormant-mark "?")
+    (expirable gnus-expirable-mark "e"))
+  "An alist of names/marks/keystrokes.")
+
+(defvar gnus-summary-generic-mark-map (make-sparse-keymap))
+(defvar gnus-summary-mark-map)
+
+(defun gnus-summary-make-all-marking-commands ()
+  (define-key gnus-summary-mark-map "M" gnus-summary-generic-mark-map)
+  (dolist (elem gnus-summary-marking-alist)
+    (apply 'gnus-summary-make-marking-command elem)))
+
+(defun gnus-summary-make-marking-command (name mark keystroke)
+  (let ((map (make-sparse-keymap)))
+    (define-key gnus-summary-generic-mark-map keystroke map)
+    (dolist (lway `((next "next" next nil "n")
+                    (next-unread "next unread" next t "N")
+                    (prev "previous" prev nil "p")
+                    (prev-unread "previous unread" prev t "P")
+                    (nomove "" nil nil ,keystroke)))
+      (let ((func (gnus-summary-make-marking-command-1
+                   mark (car lway) lway name)))
+        (setq func (eval func))
+        (define-key map (nth 4 lway) func)))))
+      
+(defun gnus-summary-make-marking-command-1 (mark way lway name)
+  `(defun ,(intern
+            (format "gnus-summary-put-mark-as-%s%s"
+                    name (if (eq way 'nomove)
+                             ""
+                           (concat "-" (symbol-name way)))))
+     (n)
+     ,(format
+       "Mark the current article as %s%s.
+If N, the prefix, then repeat N times.
+If N is negative, move in reverse order.
+The difference between N and the actual number of articles marked is
+returned."
+       name (cadr lway))
+     (interactive "p")
+     (gnus-summary-generic-mark n ,mark ',(nth 2 lway) ,(nth 3 lway))))
+    
+(defun gnus-summary-generic-mark (n mark move unread)
+  "Mark N articles with MARK."
+  (unless (eq major-mode 'gnus-summary-mode)
+    (error "This command can only be used in the summary buffer"))
+  (gnus-summary-show-thread)
+  (let ((nummove
+         (cond
+          ((eq move 'next) 1)
+          ((eq move 'prev) -1)
+          (t 0))))
+    (if (zerop nummove)
+        (setq n 1)
+      (when (< n 0)
+        (setq n (abs n)
+              nummove (* -1 nummove))))
+    (while (and (> n 0)
+                (gnus-summary-mark-article nil mark)
+                (zerop (gnus-summary-next-subject nummove unread t)))
+      (setq n (1- n)))
+    (when (/= 0 n)
+      (gnus-message 7 "No more %sarticles" (if mark "" "unread ")))
+    (gnus-summary-recenter)
+    (gnus-summary-position-point)
+    (gnus-set-mode-line 'summary)
+    n))
+
+(gnus-summary-make-all-marking-commands)
+
 (gnus-ems-redefine)
 
 (provide 'gnus-sum)
diff --git a/lisp/gnus/gnus-topic.el b/lisp/gnus/gnus-topic.el
index 26b91f8072f..35324395bb7 100644
--- a/lisp/gnus/gnus-topic.el
+++ b/lisp/gnus/gnus-topic.el
@@ -1,5 +1,6 @@
 ;;; gnus-topic.el --- a folding minor mode for Gnus group buffers
-;; Copyright (C) 1995,96,97,98 Free Software Foundation, Inc.
+;; Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000
+;;        Free Software Foundation, Inc.
 
 ;; Author: Ilja Weis <kult@uni-paderborn.de>
 ;;      Lars Magne Ingebrigtsen <larsi@gnus.org>
@@ -28,8 +29,6 @@
 
 (eval-when-compile (require 'cl))
 
-(eval-when-compile (require 'cl))
-
 (require 'gnus)
 (require 'gnus-group)
 (require 'gnus-start)
@@ -151,11 +150,20 @@ with some simple extensions.
       (gnus-group-topic group))))
 
 (defun gnus-topic-goto-topic (topic)
-  "Go to TOPIC."
   (when topic
     (gnus-goto-char (text-property-any (point-min) (point-max)
                                        'gnus-topic (intern topic)))))
 
+(defun gnus-topic-jump-to-topic (topic)
+  "Go to TOPIC."
+  (interactive
+   (list (completing-read "Go to topic: "
+                          (mapcar 'list (gnus-topic-list))
+                          nil t)))
+  (dolist (topic (gnus-current-topics topic))
+    (gnus-topic-fold t))
+  (gnus-topic-goto-topic topic))
+  
 (defun gnus-current-topic ()
   "Return the name of the current topic."
   (let ((result
@@ -184,8 +192,9 @@ If TOPIC, start with that topic."
     (beginning-of-line)
     (get-text-property (point) 'gnus-active)))
 
-(defun gnus-topic-find-groups (topic &optional level all lowest)
-  "Return entries for all visible groups in TOPIC."
+(defun gnus-topic-find-groups (topic &optional level all lowest recursive)
+  "Return entries for all visible groups in TOPIC.
+If RECURSIVE is t, return groups in its subtopics too."
   (let ((groups (cdr (assoc topic gnus-topic-alist)))
         info clevel unread group params visible-groups entry active)
     (setq lowest (or lowest 1))
@@ -205,16 +214,17 @@ If TOPIC, start with that topic."
                          (if (member group gnus-zombie-list)
                              gnus-level-zombie gnus-level-killed))))
       (and
-       unread                           ; nil means that the group is dead.
+       info                             ; nil means that the group is dead.
        (<= clevel level)
        (>= clevel lowest)               ; Is inside the level we want.
        (or all
-           (if (eq unread t)
+           (if (or (eq unread t)
+                   (eq unread nil))
                gnus-group-list-inactive-groups
              (> unread 0))
            (and gnus-list-groups-with-ticked-articles
                 (cdr (assq 'tick (gnus-info-marks info))))
-                                        ; Has right readedness.
+           ;; Has right readedness.
            ;; Check for permanent visibility.
            (and gnus-permanently-visible-groups
                 (string-match gnus-permanently-visible-groups group))
@@ -222,7 +232,18 @@ If TOPIC, start with that topic."
            (cdr (assq 'visible params)))
        ;; Add this group to the list of visible groups.
        (push (or entry group) visible-groups)))
-    (nreverse visible-groups)))
+    (setq visible-groups (nreverse visible-groups))
+    (when recursive 
+      (if (eq recursive t)
+          (setq recursive (cdr (gnus-topic-find-topology topic))))
+      (mapcar (lambda (topic-topology)
+                (setq visible-groups 
+                      (nconc visible-groups 
+                             (gnus-topic-find-groups
+                              (caar topic-topology) 
+                              level all lowest topic-topology))))
+              (cdr recursive)))
+    visible-groups))
 
 (defun gnus-topic-previous-topic (topic)
   "Return the previous topic on the same level as TOPIC."
@@ -363,7 +384,8 @@ If TOPIC, start with that topic."
 
 ;;; Generating group buffers
 
-(defun gnus-group-prepare-topics (level &optional all lowest regexp list-topic topic-level)
+(defun gnus-group-prepare-topics (level &optional all lowest
+                                        regexp list-topic topic-level)
   "List all newsgroups with unread articles of level LEVEL or lower.
 Use the `gnus-group-topics' to sort the groups.
 If ALL is non-nil, list groups that have no unread articles.
@@ -418,7 +440,7 @@ articles in the topic and its subtopics."
          (entries (gnus-topic-find-groups
                    (car type) list-level
                    (or all
-                       (cdr (assq 'visible 
+                       (cdr (assq 'visible
                                   (gnus-topic-hierarchical-parameters
                                    (car type)))))
                    lowest))
@@ -446,7 +468,8 @@ articles in the topic and its subtopics."
         (if (stringp entry)
             ;; Dead groups.
             (gnus-group-insert-group-line
-             entry (if (member entry gnus-zombie-list) gnus-level-zombie gnus-level-killed)
+             entry (if (member entry gnus-zombie-list)
+                       gnus-level-zombie gnus-level-killed)
              nil (- (1+ (cdr (setq active (gnus-active entry))))
                     (car active))
              nil)
@@ -494,7 +517,7 @@ articles in the topic and its subtopics."
       (let ((data (cadr (gnus-topic-find-topology topic))))
         (setcdr data
                 (list (if insert 'visible 'invisible)
-                      (if hide 'hide nil)
+                      (caddr data)
                       (cadddr data))))
       (if total-remove
           (setq gnus-topic-alist
@@ -507,9 +530,9 @@ articles in the topic and its subtopics."
    (car gnus-group-list-mode) (cdr gnus-group-list-mode)
    nil nil topic level))
 
-(defun gnus-topic-fold (&optional insert)
+(defun gnus-topic-fold (&optional insert topic)
   "Remove/insert the current topic."
-  (let ((topic (gnus-group-topic-name)))
+  (let ((topic (or topic (gnus-group-topic-name))))
     (when topic
       (save-excursion
         (if (not (gnus-group-active-topic-p))
@@ -533,15 +556,16 @@ articles in the topic and its subtopics."
     (gnus-topic-update-unreads name unread)
     (beginning-of-line)
     ;; Insert the text.
-    (gnus-add-text-properties
-     (point)
-     (prog1 (1+ (point))
-       (eval gnus-topic-line-format-spec))
-     (list 'gnus-topic (intern name)
-           'gnus-topic-level level
-           'gnus-topic-unread unread
-           'gnus-active active-topic
-           'gnus-topic-visible visiblep))))
+    (if shownp
+        (gnus-add-text-properties
+         (point)
+         (prog1 (1+ (point))
+           (eval gnus-topic-line-format-spec))
+         (list 'gnus-topic (intern name)
+               'gnus-topic-level level
+               'gnus-topic-unread unread
+               'gnus-active active-topic
+               'gnus-topic-visible visiblep)))))
 
 (defun gnus-topic-update-unreads (topic unreads)
   (setq gnus-topic-unreads (delq (assoc topic gnus-topic-unreads)
@@ -584,7 +608,8 @@ articles in the topic and its subtopics."
   (let* ((topic (gnus-group-topic group))
          (groups (cdr (assoc topic gnus-topic-alist)))
          (g (cdr (member group groups)))
-         (unfound t))
+         (unfound t)
+         entry)
     ;; Try to jump to a visible group.
     (while (and g (not (gnus-group-goto-group (car g) t)))
       (pop g))
@@ -598,8 +623,20 @@ articles in the topic and its subtopics."
       (when (and unfound
                  topic
                  (not (gnus-topic-goto-missing-topic topic)))
-        (gnus-topic-insert-topic-line
-         topic t t (car (gnus-topic-find-topology topic)) nil 0)))))
+        (let* ((top (gnus-topic-find-topology topic))
+               (children (cddr top))
+               (type (cadr top))
+               (unread 0)
+               (entries (gnus-topic-find-groups
+                         (car type) (car gnus-group-list-mode)
+                         (cdr gnus-group-list-mode))))
+          (while children
+            (incf unread (gnus-topic-unread (caar (pop children)))))
+          (while (setq entry (pop entries))
+            (when (numberp (car entry))
+              (incf unread (car entry))))
+          (gnus-topic-insert-topic-line
+           topic t t (car (gnus-topic-find-topology topic)) nil unread))))))
 
 (defun gnus-topic-goto-missing-topic (topic)
   (if (gnus-topic-goto-topic topic)
@@ -608,15 +645,18 @@ articles in the topic and its subtopics."
     (let* ((top (gnus-topic-find-topology
                  (gnus-topic-parent-topic topic)))
            (tp (reverse (cddr top))))
-      (while (not (equal (caaar tp) topic))
-        (setq tp (cdr tp)))
-      (pop tp)
-      (while (and tp
-                  (not (gnus-topic-goto-topic (caaar tp))))
-        (pop tp))
-      (if tp
-          (gnus-topic-forward-topic 1)
-        (gnus-topic-goto-missing-topic (caadr top))))
+      (if (not top)
+          (gnus-topic-insert-topic-line
+           topic t t (car (gnus-topic-find-topology topic)) nil 0)
+        (while (not (equal (caaar tp) topic))
+          (setq tp (cdr tp)))
+        (pop tp)
+        (while (and tp
+                    (not (gnus-topic-goto-topic (caaar tp))))
+          (pop tp))
+        (if tp
+            (gnus-topic-forward-topic 1)
+          (gnus-topic-goto-missing-topic (caadr top)))))
     nil))
 
 (defun gnus-topic-update-topic-line (topic-name &optional reads)
@@ -908,6 +948,7 @@ articles in the topic and its subtopics."
     "=" gnus-topic-select-group
     "\r" gnus-topic-select-group
     " " gnus-topic-read-group
+    "\C-c\C-x" gnus-topic-expire-articles
     "\C-k" gnus-topic-kill-group
     "\C-y" gnus-topic-yank-group
     "\M-g" gnus-topic-get-new-news-this-topic
@@ -931,6 +972,7 @@ articles in the topic and its subtopics."
     "c" gnus-topic-copy-group
     "h" gnus-topic-hide-topic
     "s" gnus-topic-show-topic
+    "j" gnus-topic-jump-to-topic
     "M" gnus-topic-move-matching
     "C" gnus-topic-copy-matching
     "\C-i" gnus-topic-indent
@@ -962,6 +1004,7 @@ articles in the topic and its subtopics."
         ["Copy matching" gnus-topic-copy-matching t]
         ["Move matching" gnus-topic-move-matching t])
        ("Topics"
+        ["Goto" gnus-topic-jump-to-topic t]
         ["Show" gnus-topic-show-topic t]
         ["Hide" gnus-topic-hide-topic t]
         ["Delete" gnus-topic-delete t]
@@ -969,6 +1012,7 @@ articles in the topic and its subtopics."
         ["Create" gnus-topic-create-topic t]
         ["Mark" gnus-topic-mark-topic t]
         ["Indent" gnus-topic-indent t]
+        ["Sort" gnus-topic-sort-topics t]
         ["Toggle hide empty" gnus-topic-toggle-display-empty-topics t]
         ["Edit parameters" gnus-topic-edit-parameters t])
        ["List active" gnus-topic-list-active t]))))
@@ -982,12 +1026,15 @@ articles in the topic and its subtopics."
           (if (null arg) (not gnus-topic-mode)
             (> (prefix-numeric-value arg) 0)))
     ;; Infest Gnus with topics.
-     (if (not gnus-topic-mode)
+    (if (not gnus-topic-mode)
         (setq gnus-goto-missing-group-function nil)
       (when (gnus-visual-p 'topic-menu 'menu)
         (gnus-topic-make-menu-bar))
       (gnus-set-format 'topic t)
-      (gnus-add-minor-mode 'gnus-topic-mode " Topic" gnus-topic-mode-map)
+      (gnus-add-minor-mode 'gnus-topic-mode " Topic"
+                           gnus-topic-mode-map nil (lambda (&rest junk)
+                                                     (interactive)
+                                                     (gnus-topic-mode nil t)))
       (add-hook 'gnus-group-catchup-group-hook 'gnus-topic-update-topic)
       (set (make-local-variable 'gnus-group-prepare-function)
            'gnus-group-prepare-topics)
@@ -1032,7 +1079,8 @@ If performed over a topic line, toggle folding the topic."
   (if (gnus-group-topic-p)
       (let ((gnus-group-list-mode
              (if all (cons (if (numberp all) all 7) t) gnus-group-list-mode)))
-        (gnus-topic-fold all))
+        (gnus-topic-fold all)
+        (gnus-dribble-touch))
     (gnus-group-select-group all)))
 
 (defun gnus-mouse-pick-topic (e)
@@ -1041,6 +1089,19 @@ If performed over a topic line, toggle folding the topic."
   (mouse-set-point e)
   (gnus-topic-read-group nil))
 
+(defun gnus-topic-expire-articles (topic)
+  "Expire articles in this topic or group."
+  (interactive (list (gnus-group-topic-name)))
+  (if (not topic)
+      (call-interactively 'gnus-group-expire-articles)
+    (save-excursion
+      (gnus-message 5 "Expiring groups in %s..." topic)
+      (let ((gnus-group-marked
+             (mapcar (lambda (entry) (car (nth 2 entry)))
+                     (gnus-topic-find-groups topic gnus-level-killed t))))
+        (gnus-group-expire-articles nil))
+      (gnus-message 5 "Expiring groups in %s...done" topic))))
+
 (defun gnus-topic-read-group (&optional all no-article group)
   "Read news in this newsgroup.
 If the prefix argument ALL is non-nil, already read articles become
@@ -1086,44 +1147,60 @@ When used interactively, PARENT will be the topic under point."
   (gnus-group-list-groups)
   (gnus-topic-goto-topic topic))
 
+;; FIXME: 
+;;  1. When the marked groups are overlapped with the process 
+;;     region, the behavior of move or remove is not right.
+;;  2. Can't process on several marked groups with a same name, 
+;;     because gnus-group-marked only keeps one copy.
+
 (defun gnus-topic-move-group (n topic &optional copyp)
   "Move the next N groups to TOPIC.
 If COPYP, copy the groups instead."
   (interactive
    (list current-prefix-arg
          (completing-read "Move to topic: " gnus-topic-alist nil t)))
-  (let ((groups (gnus-group-process-prefix n))
+  (let ((use-marked (and (not n) (not (gnus-region-active-p)) 
+                         gnus-group-marked t))
+        (groups (gnus-group-process-prefix n))
         (topicl (assoc topic gnus-topic-alist))
-        (start-group (progn (forward-line 1) (gnus-group-group-name)))
         (start-topic (gnus-group-topic-name))
+        (start-group (progn (forward-line 1) (gnus-group-group-name)))
         entry)
-    (mapcar
-     (lambda (g)
-       (gnus-group-remove-mark g)
-       (when (and
-              (setq entry (assoc (gnus-current-topic) gnus-topic-alist))
-              (not copyp))
-         (setcdr entry (gnus-delete-first g (cdr entry))))
-       (nconc topicl (list g)))
-     groups)
-    (gnus-topic-enter-dribble)
-    (if start-group
-        (gnus-group-goto-group start-group)
-      (gnus-topic-goto-topic start-topic))
-    (gnus-group-list-groups)))
+    (if (and (not groups) (not copyp) start-topic)
+        (gnus-topic-move start-topic topic)
+      (mapcar
+       (lambda (g)
+         (gnus-group-remove-mark g use-marked)
+         (when (and
+                (setq entry (assoc (gnus-current-topic) gnus-topic-alist))
+                (not copyp))
+           (setcdr entry (gnus-delete-first g (cdr entry))))
+         (nconc topicl (list g)))
+       groups)
+      (gnus-topic-enter-dribble)
+      (if start-group
+          (gnus-group-goto-group start-group)
+        (gnus-topic-goto-topic start-topic))
+      (gnus-group-list-groups))))
 
-(defun gnus-topic-remove-group (&optional arg)
+(defun gnus-topic-remove-group (&optional n)
   "Remove the current group from the topic."
   (interactive "P")
-  (gnus-group-iterate arg
-    (lambda (group)
-      (let ((topicl (assoc (gnus-current-topic) gnus-topic-alist))
-            (buffer-read-only nil))
-        (when (and topicl group)
-          (gnus-delete-line)
-          (gnus-delete-first group topicl))
-        (gnus-topic-update-topic)
-        (gnus-group-position-point)))))
+  (let ((use-marked (and (not n) (not (gnus-region-active-p)) 
+                         gnus-group-marked t))
+        (groups (gnus-group-process-prefix n)))
+    (mapcar
+     (lambda (group)
+       (gnus-group-remove-mark group use-marked)
+       (let ((topicl (assoc (gnus-current-topic) gnus-topic-alist))
+             (buffer-read-only nil))
+         (when (and topicl group)
+           (gnus-delete-line)
+           (gnus-delete-first group topicl))
+         (gnus-topic-update-topic)))
+     groups)
+    (gnus-topic-enter-dribble)
+    (gnus-group-position-point)))
 
 (defun gnus-topic-copy-group (n topic)
   "Copy the current group to a topic."
@@ -1145,7 +1222,12 @@ If COPYP, copy the groups instead."
         (gnus-topic-find-topology topic nil nil gnus-topic-topology)
         (gnus-topic-enter-dribble))
     (gnus-group-kill-group n discard)
-    (gnus-topic-update-topic)))
+    (if (not (gnus-group-topic-p))
+        (gnus-topic-update-topic)
+      ;; Move up one line so that we update the right topic.
+      (forward-line -1)
+      (gnus-topic-update-topic)
+      (forward-line 1))))
 
 (defun gnus-topic-yank-group (&optional arg)
   "Yank the last topic."
@@ -1195,43 +1277,64 @@ If COPYP, copy the groups instead."
             (setq alist (cdr alist))))))
     (gnus-topic-update-topic)))
 
-(defun gnus-topic-hide-topic ()
-  "Hide the current topic."
-  (interactive)
+(defun gnus-topic-hide-topic (&optional permanent)
+  "Hide the current topic.
+If PERMANENT, make it stay hidden in subsequent sessions as well."
+  (interactive "P")
   (when (gnus-current-topic)
     (gnus-topic-goto-topic (gnus-current-topic))
-    (gnus-topic-remove-topic nil nil 'hidden)))
-
-(defun gnus-topic-show-topic ()
-  "Show the hidden topic."
-  (interactive)
+    (if permanent
+        (setcar (cddr 
+                 (cadr
+                  (gnus-topic-find-topology (gnus-current-topic))))
+                'hidden))
+    (gnus-topic-remove-topic nil nil)))
+
+(defun gnus-topic-show-topic (&optional permanent)
+  "Show the hidden topic.
+If PERMANENT, make it stay shown in subsequent sessions as well."
+  (interactive "P")
   (when (gnus-group-topic-p)
-    (gnus-topic-remove-topic t nil 'shown)))
-
-(defun gnus-topic-mark-topic (topic &optional unmark)
-  "Mark all groups in the topic with the process mark."
-  (interactive (list (gnus-group-topic-name)))
+    (if (not permanent)
+        (gnus-topic-remove-topic t nil)
+      (let ((topic 
+             (gnus-topic-find-topology 
+              (completing-read "Show topic: " gnus-topic-alist nil t))))
+        (setcar (cddr (cadr topic)) nil)
+        (setcar (cdr (cadr topic)) 'visible)
+        (gnus-group-list-groups)))))
+
+(defun gnus-topic-mark-topic (topic &optional unmark recursive)
+  "Mark all groups in the TOPIC with the process mark.
+If RECURSIVE is t, mark its subtopics too."
+  (interactive (list (gnus-group-topic-name)
+                     nil
+                     (and current-prefix-arg t)))
   (if (not topic)
       (call-interactively 'gnus-group-mark-group)
     (save-excursion
-      (let ((groups (gnus-topic-find-groups topic gnus-level-killed t)))
+      (let ((groups (gnus-topic-find-groups topic gnus-level-killed t nil 
+                                            recursive)))
         (while groups
           (funcall (if unmark 'gnus-group-remove-mark 'gnus-group-set-mark)
                    (gnus-info-group (nth 2 (pop groups)))))))))
 
-(defun gnus-topic-unmark-topic (topic &optional unmark)
-  "Remove the process mark from all groups in the topic."
-  (interactive (list (gnus-group-topic-name)))
+(defun gnus-topic-unmark-topic (topic &optional dummy recursive)
+  "Remove the process mark from all groups in the TOPIC.
+If RECURSIVE is t, unmark its subtopics too."
+  (interactive (list (gnus-group-topic-name)
+                     nil
+                     (and current-prefix-arg t)))
   (if (not topic)
       (call-interactively 'gnus-group-unmark-group)
-    (gnus-topic-mark-topic topic t)))
+    (gnus-topic-mark-topic topic t recursive)))
 
 (defun gnus-topic-get-new-news-this-topic (&optional n)
   "Check for new news in the current topic."
   (interactive "P")
   (if (not (gnus-group-topic-p))
       (gnus-group-get-new-news-this-group n)
-    (gnus-topic-mark-topic (gnus-group-topic-name))
+    (gnus-topic-mark-topic (gnus-group-topic-name) nil (and n t))
     (gnus-group-get-new-news-this-group)))
 
 (defun gnus-topic-move-matching (regexp topic &optional copyp)
@@ -1450,6 +1553,68 @@ If REVERSE, sort in reverse order."
   (interactive "P")
   (gnus-topic-sort-groups 'gnus-group-sort-by-method reverse))
 
+(defun gnus-topic-sort-topics-1 (top reverse)
+  (if (cdr top)
+      (let ((subtop
+             (mapcar `(lambda (top)
+                        (gnus-topic-sort-topics-1 top ,reverse))
+                     (sort (cdr top)
+                           '(lambda (t1 t2) 
+                              (string-lessp (caar t1) (caar t2)))))))
+        (setcdr top (if reverse (reverse subtop) subtop))))
+  top)
+
+(defun gnus-topic-sort-topics (&optional topic reverse)
+  "Sort topics in TOPIC alphabeticaly by topic name.
+If REVERSE, reverse the sorting order."
+  (interactive 
+   (list (completing-read "Sort topics in : " gnus-topic-alist nil t 
+                          (gnus-current-topic))
+         current-prefix-arg))
+  (let ((topic-topology (or (and topic (cdr (gnus-topic-find-topology topic)))
+                            gnus-topic-topology)))
+    (gnus-topic-sort-topics-1 topic-topology reverse)
+    (gnus-topic-enter-dribble)
+    (gnus-group-list-groups)
+    (gnus-topic-goto-topic topic)))
+
+(defun gnus-topic-move (current to)
+  "Move the CURRENT topic to TO."
+  (interactive 
+   (list 
+    (gnus-group-topic-name)
+    (completing-read "Move to topic: " gnus-topic-alist nil t)))
+  (unless (and current to)
+    (error "Can't find topic"))
+  (let ((current-top (cdr (gnus-topic-find-topology current)))
+        (to-top (cdr (gnus-topic-find-topology to))))
+    (unless current-top
+      (error "Can't find topic `%s'" current))
+    (unless to-top
+      (error "Can't find topic `%s'" to))
+    (if (gnus-topic-find-topology to current-top 0);; Don't care the level
+        (error "Can't move `%s' to its sub-level" current))
+    (gnus-topic-find-topology current nil nil 'delete)
+    (while (cdr to-top)
+      (setq to-top (cdr to-top)))
+    (setcdr to-top (list current-top))
+    (gnus-topic-enter-dribble)
+    (gnus-group-list-groups)
+    (gnus-topic-goto-topic current)))
+
+(defun gnus-subscribe-topics (newsgroup)
+  (catch 'end
+    (let (match gnus-group-change-level-function)
+      (dolist (topic (gnus-topic-list))
+        (when (and (setq match (cdr (assq 'subscribe
+                                          (gnus-topic-parameters topic))))
+                   (string-match match newsgroup))
+          ;; Just subscribe the group.
+          (gnus-subscribe-alphabetically newsgroup)
+          ;; Add the group to the topic.
+          (nconc (assoc topic gnus-topic-alist) (list newsgroup))
+          (throw 'end t))))))
+          
 (provide 'gnus-topic)
 
 ;;; gnus-topic.el ends here
diff --git a/lisp/gnus/gnus-util.el b/lisp/gnus/gnus-util.el
index 8885fbd8719..72e4d031e1c 100644
--- a/lisp/gnus/gnus-util.el
+++ b/lisp/gnus/gnus-util.el
@@ -1,5 +1,6 @@
 ;;; gnus-util.el --- utility functions for Gnus
-;; Copyright (C) 1996,97,98 Free Software Foundation, Inc.
+;; Copyright (C) 1996, 1997, 1998, 1999, 2000
+;;        Free Software Foundation, Inc.
 
 ;; Author: Lars Magne Ingebrigtsen <larsi@gnus.org>
 ;; Keywords: news
@@ -33,12 +34,10 @@
 (require 'custom)
 (eval-when-compile (require 'cl))
 (require 'nnheader)
-(require 'timezone)
 (require 'message)
-(eval-when-compile (require 'rmail))
+(require 'time-date)
 
 (eval-and-compile
-  (autoload 'nnmail-date-to-time "nnmail")
   (autoload 'rmail-insert-rmail-file-header "rmail")
   (autoload 'rmail-count-new-messages "rmail")
   (autoload 'rmail-show-message "rmail"))
@@ -76,9 +75,6 @@
          (set symbol nil))
      symbol))
 
-(defun gnus-truncate-string (str width)
-  (substring str 0 width))
-
 ;; Added by Geoffrey T. Dairiki <dairiki@u.washington.edu>.  A safe way
 ;; to limit the length of a string.  This function is necessary since
 ;; `(substr "abc" 0 30)' pukes with "Args out of range".
@@ -107,25 +103,15 @@
      (when (gnus-buffer-exists-p buf)
        (kill-buffer buf))))
 
-(if (fboundp 'point-at-bol)
-    (fset 'gnus-point-at-bol 'point-at-bol)
-  (defun gnus-point-at-bol ()
-    "Return point at the beginning of the line."
-    (let ((p (point)))
-      (beginning-of-line)
-      (prog1
-          (point)
-        (goto-char p)))))
-
-(if (fboundp 'point-at-eol)
-    (fset 'gnus-point-at-eol 'point-at-eol)
-  (defun gnus-point-at-eol ()
-    "Return point at the end of the line."
-    (let ((p (point)))
-      (end-of-line)
-      (prog1
-          (point)
-        (goto-char p)))))
+(defalias 'gnus-point-at-bol
+  (if (fboundp 'point-at-bol)
+      'point-at-bol
+    'line-beginning-position))
+
+(defalias 'gnus-point-at-eol
+  (if (fboundp 'point-at-eol)
+      'point-at-eol
+    'line-end-position))
 
 (defun gnus-delete-first (elt list)
   "Delete by side effect the first occurrence of ELT as a member of LIST."
@@ -179,8 +165,8 @@
         (and (string-match "(.*" from)
              (setq name (substring from (1+ (match-beginning 0))
                                    (match-end 0)))))
-    ;; Fix by Hallvard B Furuseth <h.b.furuseth@usit.uio.no>.
-    (list (or name from) (or address from))))
+    (list (if (string= name "") nil name) (or address from))))
+
 
 (defun gnus-fetch-field (field)
   "Return the value of the header FIELD of current article."
@@ -232,43 +218,6 @@
 
 ;;; Time functions.
 
-(defun gnus-days-between (date1 date2)
-  ;; Return the number of days between date1 and date2.
-  (- (gnus-day-number date1) (gnus-day-number date2)))
-
-(defun gnus-day-number (date)
-  (let ((dat (mapcar (lambda (s) (and s (string-to-int s)) )
-                     (timezone-parse-date date))))
-    (timezone-absolute-from-gregorian
-     (nth 1 dat) (nth 2 dat) (car dat))))
-
-(defun gnus-time-to-day (time)
-  "Convert TIME to day number."
-  (let ((tim (decode-time time)))
-    (timezone-absolute-from-gregorian
-     (nth 4 tim) (nth 3 tim) (nth 5 tim))))
-
-(defun gnus-encode-date (date)
-  "Convert DATE to internal time."
-  (let* ((parse (timezone-parse-date date))
-         (date (mapcar (lambda (d) (and d (string-to-int d))) parse))
-         (time (mapcar 'string-to-int (timezone-parse-time (aref parse 3)))))
-    (encode-time (caddr time) (cadr time) (car time)
-                 (caddr date) (cadr date) (car date)
-                 (* 60 (timezone-zone-to-minute (nth 4 date))))))
-
-(defun gnus-time-minus (t1 t2)
-  "Subtract two internal times."
-  (let ((borrow (< (cadr t1) (cadr t2))))
-    (list (- (car t1) (car t2) (if borrow 1 0))
-          (- (+ (if borrow 65536 0) (cadr t1)) (cadr t2)))))
-
-(defun gnus-time-less (t1 t2)
-  "Say whether time T1 is less than time T2."
-  (or (< (car t1) (car t2))
-      (and (= (car t1) (car t2))
-           (< (nth 1 t1) (nth 1 t2)))))
-
 (defun gnus-file-newer-than (file date)
   (let ((fdate (nth 5 (file-attributes file))))
     (or (> (car fdate) (car date))
@@ -343,20 +292,9 @@
 
 (defun gnus-dd-mmm (messy-date)
   "Return a string like DD-MMM from a big messy string."
-  (let ((datevec (ignore-errors (timezone-parse-date messy-date))))
-    (if (or (not datevec)
-            (string-equal "0" (aref datevec 1)))
-        "??-???"
-      (format "%2s-%s"
-              (condition-case ()
-                  ;; Make sure leading zeroes are stripped.
-                  (number-to-string (string-to-number (aref datevec 2)))
-                (error "??"))
-              (capitalize
-               (or (car
-                    (nth (1- (string-to-number (aref datevec 1)))
-                         timezone-months-assoc))
-                   "???"))))))
+  (condition-case ()
+      (format-time-string "%d-%b" (safe-date-to-time messy-date))
+    (error "  -   ")))
 
 (defmacro gnus-date-get-time (date)
   "Convert DATE string to Emacs time.
@@ -367,17 +305,17 @@ Cache the result as a text property stored in DATE."
          '(0 0)
        (or (get-text-property 0 'gnus-time d)
            ;; or compute the value...
-           (let ((time (nnmail-date-to-time d)))
+           (let ((time (safe-date-to-time d)))
              ;; and store it back in the string.
              (put-text-property 0 1 'gnus-time time d)
              time)))))
 
 (defsubst gnus-time-iso8601 (time)
-  "Return a string of TIME in YYMMDDTHHMMSS format."
+  "Return a string of TIME in YYYYMMDDTHHMMSS format."
   (format-time-string "%Y%m%dT%H%M%S" time))
 
 (defun gnus-date-iso8601 (date)
-  "Convert the DATE to YYMMDDTHHMMSS."
+  "Convert the DATE to YYYYMMDDTHHMMSS."
   (condition-case ()
       (gnus-time-iso8601 (gnus-date-get-time date))
     (error "")))
@@ -451,12 +389,14 @@ jabbering all the time."
             ids))
     (nreverse ids)))
 
-(defun gnus-parent-id (references &optional n)
+(defsubst gnus-parent-id (references &optional n)
   "Return the last Message-ID in REFERENCES.
 If N, return the Nth ancestor instead."
   (when references
     (let ((ids (inline (gnus-split-references references))))
-      (car (last ids (or n 1))))))
+      (while (nthcdr (or n 1) ids)
+        (setq ids (cdr ids)))
+      (car ids))))
 
 (defsubst gnus-buffer-live-p (buffer)
   "Say whether BUFFER is alive or not."
@@ -496,20 +436,8 @@ If N, return the Nth ancestor instead."
     (cons (and (numberp event) event) event)))
 
 (defun gnus-sortable-date (date)
-  "Make sortable string by string-lessp from DATE.
-Timezone package is used."
-  (condition-case ()
-      (progn
-        (setq date (inline (timezone-fix-time
-                            date nil
-                            (aref (inline (timezone-parse-date date)) 4))))
-        (inline
-          (timezone-make-sortable-date
-           (aref date 0) (aref date 1) (aref date 2)
-           (inline
-             (timezone-make-time-string
-              (aref date 3) (aref date 4) (aref date 5))))))
-    (error "")))
+  "Make string suitable for sorting from DATE."
+  (gnus-time-iso8601 (date-to-time date)))
 
 (defun gnus-copy-file (file &optional to)
   "Copy FILE to TO."
@@ -541,7 +469,7 @@ Timezone package is used."
         (erase-buffer))
     (set-buffer (gnus-get-buffer-create gnus-work-buffer))
     (kill-all-local-variables)
-    (buffer-disable-undo (current-buffer))))
+    (mm-enable-multibyte)))
 
 (defmacro gnus-group-real-name (group)
   "Find the real name of a foreign newsgroup."
@@ -553,21 +481,41 @@ Timezone package is used."
 (defun gnus-make-sort-function (funs)
   "Return a composite sort condition based on the functions in FUNC."
   (cond
-   ((not (listp funs)) funs)
+   ;; Just a simple function.
+   ((gnus-functionp funs) funs)
+   ;; No functions at all.
    ((null funs) funs)
-   ((cdr funs)
+   ;; A list of functions.
+   ((or (cdr funs)
+        (listp (car funs)))
     `(lambda (t1 t2)
        ,(gnus-make-sort-function-1 (reverse funs))))
+   ;; A list containing just one function.
    (t
     (car funs))))
 
 (defun gnus-make-sort-function-1 (funs)
   "Return a composite sort condition based on the functions in FUNC."
-  (if (cdr funs)
-      `(or (,(car funs) t1 t2)
-           (and (not (,(car funs) t2 t1))
-                ,(gnus-make-sort-function-1 (cdr funs))))
-    `(,(car funs) t1 t2)))
+  (let ((function (car funs))
+        (first 't1)
+        (last 't2))
+    (when (consp function)
+      (cond
+       ;; Reversed spec.
+       ((eq (car function) 'not)
+        (setq function (cadr function)
+              first 't2
+              last 't1))
+       ((gnus-functionp function)
+        ;; Do nothing.
+        )
+       (t
+        (error "Invalid sort spec: %s" function))))
+    (if (cdr funs)
+        `(or (,function ,first ,last)
+             (and (not (,function ,last ,first))
+                  ,(gnus-make-sort-function-1 (cdr funs))))
+      `(,function ,first ,last))))
 
 (defun gnus-turn-off-edit-menu (type)
   "Turn off edit menu in `gnus-TYPE-mode-map'."
@@ -591,17 +539,19 @@ Bind `print-quoted' and `print-readably' to t while printing."
 
 (defun gnus-make-directory (directory)
   "Make DIRECTORY (and all its parents) if it doesn't exist."
-  (when (and directory
-             (not (file-exists-p directory)))
-    (make-directory directory t))
+  (let ((file-name-coding-system nnmail-pathname-coding-system))
+    (when (and directory
+               (not (file-exists-p directory)))
+      (make-directory directory t)))
   t)
 
 (defun gnus-write-buffer (file)
   "Write the current buffer's contents to FILE."
   ;; Make sure the directory exists.
   (gnus-make-directory (file-name-directory file))
-  ;; Write the buffer.
-  (write-region (point-min) (point-max) file nil 'quietly))
+  (let ((file-name-coding-system nnmail-pathname-coding-system))
+    ;; Write the buffer.
+    (write-region (point-min) (point-max) file nil 'quietly)))
 
 (defun gnus-delete-file (file)
   "Delete FILE if it exists."
@@ -614,13 +564,13 @@ Bind `print-quoted' and `print-readably' to t while printing."
     (setq string (replace-match "" t t string)))
   string)
 
-(defun gnus-put-text-property-excluding-newlines (beg end prop val)
+(defsubst gnus-put-text-property-excluding-newlines (beg end prop val)
   "The same as `put-text-property', but don't put this prop on any newlines in the region."
   (save-match-data
     (save-excursion
       (save-restriction
         (goto-char beg)
-        (while (re-search-forward "[ \t]*\n" end 'move)
+        (while (re-search-forward gnus-emphasize-whitespace-regexp end 'move)
           (gnus-put-text-property beg (match-beginning 0) prop val)
           (setq beg (point)))
         (gnus-put-text-property beg (point) prop val)))))
@@ -733,7 +683,8 @@ with potentially long computations."
                 (save-excursion
                   (set-buffer file-buffer)
                   (rmail-insert-rmail-file-header)
-                  (let ((require-final-newline nil))
+                  (let ((require-final-newline nil)
+                        (coding-system-for-write mm-text-coding-system))
                     (gnus-write-buffer filename)))
                 (kill-buffer file-buffer))
             (error "Output file does not exist")))
@@ -744,7 +695,7 @@ with potentially long computations."
       ;; Decide whether to append to a file or to an Emacs buffer.
       (let ((outbuf (get-file-buffer filename)))
         (if (not outbuf)
-            (append-to-file (point-min) (point-max) filename)
+            (mm-append-to-file (point-min) (point-max) filename)
           ;; File has been visited, in buffer OUTBUF.
           (set-buffer outbuf)
           (let ((buffer-read-only nil)
@@ -784,7 +735,8 @@ with potentially long computations."
             (let ((file-buffer (create-file-buffer filename)))
               (save-excursion
                 (set-buffer file-buffer)
-                (let ((require-final-newline nil))
+                (let ((require-final-newline nil)
+                      (coding-system-for-write mm-text-coding-system))
                   (gnus-write-buffer filename)))
               (kill-buffer file-buffer))
           (error "Output file does not exist")))
@@ -812,7 +764,7 @@ with potentially long computations."
                     (insert "\n"))
                   (insert "\n"))
                 (goto-char (point-max))
-                (append-to-file (point-min) (point-max) filename)))
+                (mm-append-to-file (point-min) (point-max) filename)))
           ;; File has been visited, in buffer OUTBUF.
           (set-buffer outbuf)
           (let ((buffer-read-only nil))
@@ -853,84 +805,84 @@ ARG is passed to the first function."
 ;;; .netrc and .authinforc parsing
 ;;;
 
-(defvar gnus-netrc-syntax-table
-  (let ((table (copy-syntax-table text-mode-syntax-table)))
-    (modify-syntax-entry ?@ "w" table)
-    (modify-syntax-entry ?- "w" table)
-    (modify-syntax-entry ?_ "w" table)
-    (modify-syntax-entry ?! "w" table)
-    (modify-syntax-entry ?. "w" table)
-    (modify-syntax-entry ?, "w" table)
-    (modify-syntax-entry ?: "w" table)
-    (modify-syntax-entry ?\; "w" table)
-    (modify-syntax-entry ?% "w" table)
-    (modify-syntax-entry ?) "w" table)
-    (modify-syntax-entry ?( "w" table)
-    table)
-  "Syntax table when parsing .netrc files.")
-
 (defun gnus-parse-netrc (file)
   "Parse FILE and return an list of all entries in the file."
-  (if (not (file-exists-p file))
-      ()
-    (save-excursion
+  (when (file-exists-p file)
+    (with-temp-buffer
       (let ((tokens '("machine" "default" "login"
-                      "password" "account" "macdef" "force"))
+                      "password" "account" "macdef" "force"
+                      "port"))
             alist elem result pair)
-        (nnheader-set-temp-buffer " *netrc*")
-        (unwind-protect
-            (progn
-              (set-syntax-table gnus-netrc-syntax-table)
-              (insert-file-contents file)
-              (goto-char (point-min))
-              ;; Go through the file, line by line.
-              (while (not (eobp))
-                (narrow-to-region (point) (gnus-point-at-eol))
-                ;; For each line, get the tokens and values.
-                (while (not (eobp))
-                  (skip-chars-forward "\t ")
-                  (unless (eobp)
-                    (setq elem (buffer-substring
-                                (point) (progn (forward-sexp 1) (point))))
-                    (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,
-                      ;; except "default".
-                      (when (and pair (or (cdr pair)
-                                          (equal (car pair) "default")))
-                        (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))))))
-                (if alist
-                    (push (nreverse alist) result))
-                (setq alist nil
-                      pair nil)
-                (widen)
-                (forward-line 1))
-              (nreverse result))
-          (kill-buffer " *netrc*"))))))
-
-(defun gnus-netrc-machine (list machine)
-  "Return the netrc values from LIST for MACHINE or for the default entry."
-  (let ((rest list))
-    (while (and list
-                (not (equal (cdr (assoc "machine" (car list))) machine)))
+        (insert-file-contents file)
+        (goto-char (point-min))
+        ;; Go through the file, line by line.
+        (while (not (eobp))
+          (narrow-to-region (point) (gnus-point-at-eol))
+          ;; For each line, get the tokens and values.
+          (while (not (eobp))
+            (skip-chars-forward "\t ")
+            ;; Skip lines that begin with a "#".
+            (if (eq (char-after) ?#)
+                (goto-char (point-max))
+              (unless (eobp)
+                (setq elem
+                      (if (= (following-char) ?\")
+                          (read (current-buffer))
+                        (buffer-substring
+                         (point) (progn (skip-chars-forward "^\t ")
+                                        (point)))))
+                (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,
+                  ;; except "default".
+                  (when (and pair (or (cdr pair)
+                                      (equal (car pair) "default")))
+                    (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)))))))
+          (when alist
+            (push (nreverse alist) result))
+          (setq alist nil
+                pair nil)
+          (widen)
+          (forward-line 1))
+        (nreverse result)))))
+
+(defun gnus-netrc-machine (list machine &optional port defaultport)
+  "Return the netrc values from LIST for MACHINE or for the default entry.
+If PORT specified, only return entries with matching port tokens.
+Entries without port tokens default to DEFAULTPORT."
+  (let ((rest list)
+        result)
+    (while list
+      (when (equal (cdr (assoc "machine" (car list))) machine)
+        (push (car list) result))
       (pop list))
-    (car (or list
-             (progn (while (and rest (not (assoc "default" (car rest))))
-                      (pop rest))
-                    rest)))))
+    (unless result
+      ;; No machine name matches, so we look for default entries.
+      (while rest
+        (when (assoc "default" (car rest))
+          (push (car rest) result))
+        (pop rest)))
+    (when result
+      (setq result (nreverse result))
+      (while (and result
+                  (not (equal (or port defaultport "nntp")
+                              (or (gnus-netrc-get (car result) "port")
+                                  defaultport "nntp"))))
+        (pop result))
+      (car result))))
 
 (defun gnus-netrc-get (alist type)
   "Return the value of token TYPE from ALIST."
@@ -938,7 +890,7 @@ ARG is passed to the first function."
 
 ;;; Various
 
-(defvar gnus-group-buffer) ; Compiler directive
+(defvar gnus-group-buffer)              ; Compiler directive
 (defun gnus-alive-p ()
   "Say whether Gnus is running or not."
   (and (boundp 'gnus-group-buffer)
@@ -971,11 +923,12 @@ ARG is passed to the first function."
       (setq alist (delq entry alist)))
     alist))
 
-(defmacro gnus-pull (key alist)
+(defmacro gnus-pull (key alist &optional assoc-p)
   "Modify ALIST to be without KEY."
   (unless (symbolp alist)
     (error "Not a symbol: %s" alist))
-  `(setq ,alist (delq (assq ,key ,alist) ,alist)))
+  (let ((fun (if assoc-p 'assoc 'assq)))
+    `(setq ,alist (delq (,fun ,key ,alist) ,alist))))
 
 (defun gnus-globalify-regexp (re)
   "Returns a regexp that matches a whole line, iff RE matches a part of it."
@@ -983,6 +936,52 @@ ARG is passed to the first function."
           re
           (unless (string-match "\\$$" re) ".*$")))
 
+(defun gnus-set-window-start (&optional point)
+  "Set the window start to POINT, or (point) if nil."
+  (let ((win (get-buffer-window (current-buffer) t)))
+    (when win
+      (set-window-start win (or point (point))))))
+
+(defun gnus-annotation-in-region-p (b e)
+  (if (= b e)
+      (eq (cadr (memq 'gnus-undeletable (text-properties-at b))) t)
+    (text-property-any b e 'gnus-undeletable t)))
+
+(defun gnus-or (&rest elems)
+  "Return non-nil if any of the elements are non-nil."
+  (catch 'found
+    (while elems
+      (when (pop elems)
+        (throw 'found t)))))
+
+(defun gnus-and (&rest elems)
+  "Return non-nil if all of the elements are non-nil."
+  (catch 'found
+    (while elems
+      (unless (pop elems)
+        (throw 'found nil)))
+    t))
+
+(defun gnus-write-active-file (file hashtb &optional full-names)
+  (let ((coding-system-for-write nnmail-active-file-coding-system))
+    (with-temp-file file
+      (mapatoms
+       (lambda (sym)
+         (when (and sym
+                    (boundp sym)
+                    (symbol-value sym))
+           (insert (format "%S %d %d y\n"
+                           (if full-names
+                               sym
+                             (intern (gnus-group-real-name (symbol-name sym))))
+                           (or (cdr (symbol-value sym))
+                               (car (symbol-value sym)))
+                           (car (symbol-value sym))))))
+       hashtb)
+      (goto-char (point-max))
+      (while (search-backward "\\." nil t)
+        (delete-char 1)))))
+
 (provide 'gnus-util)
 
 ;;; gnus-util.el ends here
diff --git a/lisp/gnus/nnheader.el b/lisp/gnus/nnheader.el
index 395a2085e00..848d7e47a7a 100644
--- a/lisp/gnus/nnheader.el
+++ b/lisp/gnus/nnheader.el
@@ -1,5 +1,8 @@
 ;;; nnheader.el --- header access macros for Gnus and its backends
-;; Copyright (C) 1987,88,89,90,93,94,95,96,97,98 Free Software Foundation, Inc.
+
+;; Copyright (C) 1987, 1988, 1989, 1990, 1993, 1994, 1995, 1996,
+;;        1997, 1998, 2000
+;;        Free Software Foundation, Inc.
 
 ;; Author: Masanobu UMEDA <umerin@flab.flab.fujitsu.junet>
 ;;      Lars Magne Ingebrigtsen <larsi@gnus.org>
@@ -24,24 +27,12 @@
 
 ;;; Commentary:
 
-;; These macros may look very much like the ones in GNUS 4.1.  They
-;; are, in a way, but you should note that the indices they use have
-;; been changed from the internal GNUS format to the NOV format.  The
-;; makes it possible to read headers from XOVER much faster.
-;;
-;; The format of a header is now:
-;; [number subject from date id references chars lines xref]
-;;
-;; (That last entry is defined as "misc" in the NOV format, but Gnus
-;; uses it for xrefs.)
-
 ;;; Code:
 
 (eval-when-compile (require 'cl))
 
-(eval-when-compile (require 'cl))
-
 (require 'mail-utils)
+(require 'mm-util)
 
 (defvar nnheader-max-head-length 4096
   "*Max length of the head of articles.")
@@ -51,23 +42,32 @@
 
 (defvar nnheader-file-name-translation-alist nil
   "*Alist that says how to translate characters in file names.
-For instance, if \":\" is illegal as a file character in file names
+For instance, if \":\" is invalid as a file character in file names
 on your system, you could say something like:
 
 \(setq nnheader-file-name-translation-alist '((?: . ?_)))")
 
 (eval-and-compile
- (autoload 'nnmail-message-id "nnmail")
- (autoload 'mail-position-on-field "sendmail")
- (autoload 'message-remove-header "message")
- (autoload 'cancel-function-timers "timers")
- (autoload 'gnus-point-at-eol "gnus-util")
- (autoload 'gnus-delete-line "gnus-util")
- (autoload 'gnus-buffer-live-p "gnus-util")
- (autoload 'gnus-encode-coding-string "gnus-ems"))
+  (autoload 'nnmail-message-id "nnmail")
+  (autoload 'mail-position-on-field "sendmail")
+  (autoload 'message-remove-header "message")
+  (autoload 'gnus-point-at-eol "gnus-util")
+  (autoload 'gnus-delete-line "gnus-util")
+  (autoload 'gnus-buffer-live-p "gnus-util"))
 
 ;;; Header access macros.
 
+;; These macros may look very much like the ones in GNUS 4.1.  They
+;; are, in a way, but you should note that the indices they use have
+;; been changed from the internal GNUS format to the NOV format.  The
+;; makes it possible to read headers from XOVER much faster.
+;;
+;; The format of a header is now:
+;; [number subject from date id references chars lines xref extra]
+;;
+;; (That next-to-last entry is defined as "misc" in the NOV format,
+;; but Gnus uses it for xrefs.)
+
 (defmacro mail-header-number (header)
   "Return article number in HEADER."
   `(aref ,header 0))
@@ -139,17 +139,26 @@ on your system, you could say something like:
   `(aref ,header 8))
 
 (defmacro mail-header-set-xref (header xref)
-  "Set article xref of HEADER to xref."
+  "Set article XREF of HEADER to xref."
   `(aset ,header 8 ,xref))
 
-(defun make-mail-header (&optional init)
+(defmacro mail-header-extra (header)
+  "Return the extra headers in HEADER."
+  `(aref ,header 9))
+
+(defmacro mail-header-set-extra (header extra)
+  "Set the extra headers in HEADER to EXTRA."
+  `(aset ,header 9 ',extra))
+
+(defsubst make-mail-header (&optional init)
   "Create a new mail header structure initialized with INIT."
-  (make-vector 9 init))
+  (make-vector 10 init))
 
-(defun make-full-mail-header (&optional number subject from date id
-                                        references chars lines xref)
+(defsubst make-full-mail-header (&optional number subject from date id
+                                           references chars lines xref
+                                           extra)
   "Create a new mail header structure initialized with the parameters given."
-  (vector number subject from date id references chars lines xref))
+  (vector number subject from date id references chars lines xref extra))
 
 ;; fake message-ids: generation and detection
 
@@ -235,11 +244,12 @@ on your system, you could say something like:
                ;; promising.
                (if (and (search-forward "\nin-reply-to: " nil t)
                         (setq in-reply-to (nnheader-header-value))
-                        (string-match "<[^>]+>" in-reply-to))
+                        (string-match "<[^\n>]+>" in-reply-to))
                    (let (ref2)
                      (setq ref (substring in-reply-to (match-beginning 0)
                                           (match-end 0)))
-                     (while (string-match "<[^>]+>" in-reply-to (match-end 0))
+                     (while (string-match "<[^\n>]+>"
+                                          in-reply-to (match-end 0))
                        (setq ref2 (substring in-reply-to (match-beginning 0)
                                              (match-end 0)))
                        (when (> (length ref2) (length ref))
@@ -259,7 +269,20 @@ on your system, you could say something like:
            (progn
              (goto-char p)
              (and (search-forward "\nxref: " nil t)
-                  (nnheader-header-value)))))
+                  (nnheader-header-value)))
+
+           ;; Extra.
+           (when nnmail-extra-headers
+             (let ((extra nnmail-extra-headers)
+                   out)
+               (while extra
+                 (goto-char p)
+                 (when (search-forward
+                        (concat "\n" (symbol-name (car extra)) ": ") nil t)
+                   (push (cons (car extra) (nnheader-header-value))
+                         out))
+                 (pop extra))
+               out))))
       (when naked
         (goto-char (point-min))
         (delete-char 1)))))
@@ -272,13 +295,29 @@ on your system, you could say something like:
 
 (defmacro nnheader-nov-read-integer ()
   '(prog1
-       (if (= (following-char) ?\t)
+       (if (eq (char-after) ?\t)
            0
-         (let ((num (ignore-errors (read (current-buffer)))))
+         (let ((num (condition-case nil
+                        (read (current-buffer))
+                      (error nil))))
            (if (numberp num) num 0)))
      (or (eobp) (forward-char 1))))
 
-;; (defvar nnheader-none-counter 0)
+(defmacro nnheader-nov-parse-extra ()
+  '(let (out string)
+     (while (not (memq (char-after) '(?\n nil)))
+       (setq string (nnheader-nov-field))
+       (when (string-match "^\\([^ :]+\\): " string)
+         (push (cons (intern (match-string 1 string))
+                     (substring string (match-end 0)))
+               out)))
+     out))
+
+(defmacro nnheader-nov-read-message-id ()
+  '(let ((id (nnheader-nov-field)))
+     (if (string-match "^<[^>]+>$" id)
+         id
+       (nnheader-generate-fake-message-id))))
 
 (defun nnheader-parse-nov ()
   (let ((eol (gnus-point-at-eol)))
@@ -287,34 +326,60 @@ on your system, you could say something like:
      (nnheader-nov-field)               ; subject
      (nnheader-nov-field)               ; from
      (nnheader-nov-field)               ; date
-     (or (nnheader-nov-field)
-         (nnheader-generate-fake-message-id)) ; id
+     (nnheader-nov-read-message-id)     ; id
      (nnheader-nov-field)               ; refs
      (nnheader-nov-read-integer)        ; chars
      (nnheader-nov-read-integer)        ; lines
-     (if (= (following-char) ?\n)
+     (if (eq (char-after) ?\n)
          nil
-       (nnheader-nov-field))            ; misc
-     )))
+       (if (looking-at "Xref: ")
+           (goto-char (match-end 0)))
+       (nnheader-nov-field))            ; Xref
+     (nnheader-nov-parse-extra))))      ; extra
 
 (defun nnheader-insert-nov (header)
   (princ (mail-header-number header) (current-buffer))
+  (let ((p (point)))
+    (insert
+     "\t"
+     (or (mail-header-subject header) "(none)") "\t"
+     (or (mail-header-from header) "(nobody)") "\t"
+     (or (mail-header-date header) "") "\t"
+     (or (mail-header-id header)
+         (nnmail-message-id))
+     "\t"
+     (or (mail-header-references header) "") "\t")
+    (princ (or (mail-header-chars header) 0) (current-buffer))
+    (insert "\t")
+    (princ (or (mail-header-lines header) 0) (current-buffer))
+    (insert "\t")
+    (when (mail-header-xref header)
+      (insert "Xref: " (mail-header-xref header)))
+    (when (or (mail-header-xref header)
+              (mail-header-extra header))
+      (insert "\t"))
+    (when (mail-header-extra header)
+      (let ((extra (mail-header-extra header)))
+        (while extra
+          (insert (symbol-name (caar extra))
+                  ": " (cdar extra) "\t")
+          (pop extra))))
+    (insert "\n")
+    (backward-char 1)
+    (while (search-backward "\n" p t)
+      (delete-char 1))
+    (forward-line 1)))
+
+(defun nnheader-insert-header (header)
   (insert
-   "\t"
-   (or (mail-header-subject header) "(none)") "\t"
-   (or (mail-header-from header) "(nobody)") "\t"
-   (or (mail-header-date header) "") "\t"
-   (or (mail-header-id header)
-       (nnmail-message-id))
-   "\t"
-   (or (mail-header-references header) "") "\t")
-  (princ (or (mail-header-chars header) 0) (current-buffer))
-  (insert "\t")
+   "Subject: " (or (mail-header-subject header) "(none)") "\n"
+   "From: " (or (mail-header-from header) "(nobody)") "\n"
+   "Date: " (or (mail-header-date header) "") "\n"
+   "Message-ID: " (or (mail-header-id header) (nnmail-message-id)) "\n"
+   "References: " (or (mail-header-references header) "") "\n"
+   "Lines: ")
   (princ (or (mail-header-lines header) 0) (current-buffer))
-  (insert "\t")
-  (when (mail-header-xref header)
-    (insert "Xref: " (mail-header-xref header) "\t"))
-  (insert "\n"))
+  (insert "\n\n"))
 
 (defun nnheader-insert-article-line (article)
   (goto-char (point-min))
@@ -401,6 +466,7 @@ the line could be found."
   (save-excursion
     (unless (gnus-buffer-live-p nntp-server-buffer)
       (setq nntp-server-buffer (get-buffer-create " *nntpd*")))
+    (mm-enable-multibyte)
     (set-buffer nntp-server-buffer)
     (erase-buffer)
     (kill-all-local-variables)
@@ -447,7 +513,7 @@ the line could be found."
       nil
     (narrow-to-region (point-min) (1- (point)))
     (goto-char (point-min))
-    (while (looking-at "[A-Z][^ \t]+:.*\n\\([ \t].*\n\\)*\\|From .*\n")
+    (while (looking-at "[a-zA-Z][^ \t]+:.*\n\\([ \t].*\n\\)*\\|From .*\n")
       (goto-char (match-end 0)))
     (prog1
         (eobp)
@@ -456,7 +522,8 @@ the line could be found."
 (defun nnheader-insert-references (references message-id)
   "Insert a References header based on REFERENCES and MESSAGE-ID."
   (if (and (not references) (not message-id))
-      ()                                ; This is illegal, but not all articles have Message-IDs.
+      ;; This is invalid, but not all articles have Message-IDs.
+      ()
     (mail-position-on-field "References")
     (let ((begin (save-excursion (beginning-of-line) (point)))
           (fill-column 78)
@@ -495,58 +562,12 @@ the line could be found."
 (defun nnheader-set-temp-buffer (name &optional noerase)
   "Set-buffer to an empty (possibly new) buffer called NAME with undo disabled."
   (set-buffer (get-buffer-create name))
-  (buffer-disable-undo (current-buffer))
+  (buffer-disable-undo)
   (unless noerase
     (erase-buffer))
   (current-buffer))
 
-(defmacro nnheader-temp-write (file &rest forms)
-  "Create a new buffer, evaluate FORMS there, and write the buffer to FILE.
-Return the value of FORMS.
-If FILE is nil, just evaluate FORMS and don't save anything.
-If FILE is t, return the buffer contents as a string."
-  (let ((temp-file (make-symbol "temp-file"))
-        (temp-buffer (make-symbol "temp-buffer"))
-        (temp-results (make-symbol "temp-results")))
-    `(save-excursion
-       (let* ((,temp-file ,file)
-              (default-major-mode 'fundamental-mode)
-              (,temp-buffer
-               (set-buffer
-                (get-buffer-create
-                 (generate-new-buffer-name " *nnheader temp*"))))
-              ,temp-results)
-         (unwind-protect
-             (progn
-               (setq ,temp-results (progn ,@forms))
-               (cond
-                ;; Don't save anything.
-                ((null ,temp-file)
-                 ,temp-results)
-                ;; Return the buffer contents.
-                ((eq ,temp-file t)
-                 (set-buffer ,temp-buffer)
-                 (buffer-string))
-                ;; Save a file.
-                (t
-                 (set-buffer ,temp-buffer)
-                 ;; Make sure the directory where this file is
-                 ;; to be saved exists.
-                 (when (not (file-directory-p
-                             (file-name-directory ,temp-file)))
-                   (make-directory (file-name-directory ,temp-file) t))
-                 ;; Save the file.
-                 (write-region (point-min) (point-max)
-                               ,temp-file nil 'nomesg)
-                 ,temp-results)))
-           ;; Kill the buffer.
-           (when (buffer-name ,temp-buffer)
-             (kill-buffer ,temp-buffer)))))))
-
-(put 'nnheader-temp-write 'lisp-indent-function 1)
-(put 'nnheader-temp-write 'edebug-form-spec '(form body))
-
-(defvar jka-compr-compression-info-list)
+(eval-when-compile (defvar jka-compr-compression-info-list))
 (defvar nnheader-numerical-files
   (if (boundp 'jka-compr-compression-info-list)
       (concat "\\([0-9]+\\)\\("
@@ -563,7 +584,7 @@ If FILE is t, return the buffer contents as a string."
   "Regexp that matches numerical full file paths.")
 
 (defsubst nnheader-file-to-number (file)
-  "Take a file name and return the article number."
+  "Take a FILE name and return the article number."
   (if (string= nnheader-numerical-short-files "^[0-9]+$")
       (string-to-int file)
     (string-match nnheader-numerical-short-files file)
@@ -581,7 +602,7 @@ If FILE is t, return the buffer contents as a string."
       second)))
 
 (defun nnheader-directory-articles (dir)
-  "Return a list of all article files in a directory."
+  "Return a list of all article files in directory DIR."
   (mapcar 'nnheader-file-to-number
           (nnheader-directory-files-safe
            dir nil nnheader-numerical-short-files t)))
@@ -607,7 +628,9 @@ If FULL, translate everything."
       (if full
           ;; Do complete translation.
           (setq leaf (copy-sequence file)
-                path "")
+                path ""
+                i (if (and (< 1 (length leaf)) (eq ?: (aref leaf 1)))
+                      2 0))
         ;; We translate -- but only the file name.  We leave the directory
         ;; alone.
         (if (string-match "/[^/]+\\'" file)
@@ -638,7 +661,7 @@ The first string in ARGS can be a format string."
   "Get the most recent report from BACKEND."
   (condition-case ()
       (nnheader-message 5 "%s" (symbol-value (intern (format "%s-status-string"
-                                                  backend))))
+                                                             backend))))
     (error (nnheader-message 5 ""))))
 
 (defun nnheader-insert (format &rest args)
@@ -653,15 +676,33 @@ without formatting."
       (apply 'insert format args))
     t))
 
-(defun nnheader-replace-chars-in-string (string from to)
+(if (fboundp 'subst-char-in-string)
+    (defsubst nnheader-replace-chars-in-string (string from to)
+      (subst-char-in-string from to string))
+  (defun nnheader-replace-chars-in-string (string from to)
+    "Replace characters in STRING from FROM to TO."
+    (let ((string (substring string 0)) ;Copy string.
+          (len (length string))
+          (idx 0))
+      ;; Replace all occurrences of FROM with TO.
+      (while (< idx len)
+        (when (= (aref string idx) from)
+          (aset string idx to))
+        (setq idx (1+ idx)))
+      string)))
+
+(defun nnheader-replace-duplicate-chars-in-string (string from to)
   "Replace characters in STRING from FROM to TO."
   (let ((string (substring string 0))   ;Copy string.
         (len (length string))
-        (idx 0))
+        (idx 0) prev i)
     ;; Replace all occurrences of FROM with TO.
     (while (< idx len)
-      (when (= (aref string idx) from)
+      (setq i (aref string idx))
+      (when (and (eq prev from) (= i from))
+        (aset string (1- idx) to)
         (aset string idx to))
+      (setq prev i)
       (setq idx (1+ idx)))
     string))
 
@@ -690,12 +731,7 @@ without formatting."
   (or (not (numberp gnus-verbose-backends))
       (<= level gnus-verbose-backends)))
 
-(defvar nnheader-pathname-coding-system 'iso-8859-1
-  "*Coding system for pathname.")
-
-;; 1997/8/10 by MORIOKA Tomohiko
-(defvar nnheader-pathname-coding-system
-  'iso-8859-1
+(defvar nnheader-pathname-coding-system 'binary
   "*Coding system for pathname.")
 
 (defun nnheader-group-pathname (group dir &optional file)
@@ -703,14 +739,14 @@ without formatting."
   (concat
    (let ((dir (file-name-as-directory (expand-file-name dir))))
      ;; If this directory exists, we use it directly.
-     (if (file-directory-p (concat dir group))
-         (concat dir group "/")
-       ;; If not, we translate dots into slashes.
-       (concat dir
-               (gnus-encode-coding-string
-                (nnheader-replace-chars-in-string group ?. ?/)
-                nnheader-pathname-coding-system)
-               "/")))
+     (file-name-as-directory
+      (if (file-directory-p (concat dir group))
+          (expand-file-name group dir)
+        ;; If not, we translate dots into slashes.
+        (expand-file-name (mm-encode-coding-string
+                           (nnheader-replace-chars-in-string group ?. ?/)
+                          nnheader-pathname-coding-system)
+                          dir))))
    (cond ((null file) "")
          ((numberp file) (int-to-string file))
          (t file))))
@@ -721,7 +757,7 @@ without formatting."
       (and (listp form) (eq (car form) 'lambda))))
 
 (defun nnheader-concat (dir &rest files)
-  "Concat DIR as directory to FILE."
+  "Concat DIR as directory to FILES."
   (apply 'concat (file-name-as-directory dir) files))
 
 (defun nnheader-ms-strip-cr ()
@@ -770,45 +806,26 @@ If FILE, find the \".../etc/PACKAGE\" file instead."
 (defvar nnheader-file-coding-system 'raw-text
   "Coding system used in file backends of Gnus.")
 
-;; 1997/5/4 by MORIOKA Tomohiko <morioka@jaist.ac.jp>
-(defvar nnheader-file-coding-system nil
-  "Coding system used in file backends of Gnus.")
-
 (defun nnheader-insert-file-contents (filename &optional visit beg end replace)
   "Like `insert-file-contents', q.v., but only reads in the file.
 A buffer may be modified in several ways after reading into the buffer due
 to advanced Emacs features, such as file-name-handlers, format decoding,
 find-file-hooks, etc.
   This function ensures that none of these modifications will take place."
-  (let ((format-alist nil)
-        (auto-mode-alist (nnheader-auto-mode-alist))
-        (default-major-mode 'fundamental-mode)
-        (enable-local-variables nil)
-        (after-insert-file-functions nil)
-        (find-file-hooks nil)
-        (coding-system-for-read nnheader-file-coding-system))
-    (insert-file-contents filename visit beg end replace)))
+  (let ((coding-system-for-read nnheader-file-coding-system))
+    (mm-insert-file-contents filename visit beg end replace)))
 
 (defun nnheader-find-file-noselect (&rest args)
   (let ((format-alist nil)
-        (auto-mode-alist (nnheader-auto-mode-alist))
+        (auto-mode-alist (mm-auto-mode-alist))
         (default-major-mode 'fundamental-mode)
         (enable-local-variables nil)
         (after-insert-file-functions nil)
+        (enable-local-eval nil)
         (find-file-hooks nil)
         (coding-system-for-read nnheader-file-coding-system))
     (apply 'find-file-noselect args)))
 
-(defun nnheader-auto-mode-alist ()
-  "Return an `auto-mode-alist' with only the .gz (etc) thingies."
-  (let ((alist auto-mode-alist)
-        out)
-    (while alist
-      (when (listp (cdar alist))
-        (push (car alist) out))
-      (pop alist))
-    (nreverse out)))
-
 (defun nnheader-directory-regular-files (dir)
   "Return a list of all regular files in DIR."
   (let ((files (directory-files dir t))
@@ -833,8 +850,6 @@ find-file-hooks, etc.
   `(let ((new (generate-new-buffer " *nnheader replace*"))
          (cur (current-buffer))
          (start (point-min)))
-     (set-buffer new)
-     (buffer-disable-undo (current-buffer))
      (set-buffer cur)
      (goto-char (point-min))
      (while (,(if regexp 're-search-forward 'search-forward)
@@ -852,22 +867,22 @@ find-file-hooks, etc.
      (set-buffer cur)))
 
 (defun nnheader-replace-string (from to)
-  "Do a fast replacement of FROM to TO from point to point-max."
+  "Do a fast replacement of FROM to TO from point to `point-max'."
   (nnheader-skeleton-replace from to))
 
 (defun nnheader-replace-regexp (from to)
-  "Do a fast regexp replacement of FROM to TO from point to point-max."
+  "Do a fast regexp replacement of FROM to TO from point to `point-max'."
   (nnheader-skeleton-replace from to t))
 
 (defun nnheader-strip-cr ()
   "Strip all \r's from the current buffer."
   (nnheader-skeleton-replace "\r"))
 
-(fset 'nnheader-run-at-time 'run-at-time)
-(fset 'nnheader-cancel-timer 'cancel-timer)
-(fset 'nnheader-cancel-function-timers 'cancel-function-timers)
+(defalias 'nnheader-run-at-time 'run-at-time)
+(defalias 'nnheader-cancel-timer 'cancel-timer)
+(defalias 'nnheader-cancel-function-timers 'cancel-function-timers)
 
-(when (string-match "XEmacs\\|Lucid" emacs-version)
+(when (string-match "XEmacs" emacs-version)
   (require 'nnheaderxm))
 
 (run-hooks 'nnheader-load-hook)
diff --git a/lisp/gnus/nnkiboze.el b/lisp/gnus/nnkiboze.el
index c47a10d3911..d93800a5b97 100644
--- a/lisp/gnus/nnkiboze.el
+++ b/lisp/gnus/nnkiboze.el
@@ -1,5 +1,7 @@
 ;;; nnkiboze.el --- select virtual news access for Gnus
-;; Copyright (C) 1995,96,97,98 Free Software Foundation, Inc.
+
+;; Copyright (C) 1995, 1996, 1997, 1998, 1999,.2000
+;;      Free Software Foundation, Inc.
 
 ;; Author: Lars Magne Ingebrigtsen <larsi@gnus.org>
 ;; Keywords: news
@@ -34,6 +36,7 @@
 (require 'gnus)
 (require 'gnus-score)
 (require 'nnoo)
+(require 'mm-util)
 (eval-when-compile (require 'cl))
 
 (nnoo-declare nnkiboze)
@@ -55,6 +58,9 @@
 (defvoo nnkiboze-regexp nil
   "Regexp for matching component groups.")
 
+(defvoo nnkiboze-file-coding-system mm-text-coding-system
+  "Coding system for nnkiboze files.")
+
 
 
 (defconst nnkiboze-version "nnkiboze 1.0")
@@ -80,7 +86,8 @@
           (save-excursion
             (set-buffer nntp-server-buffer)
             (erase-buffer)
-            (nnheader-insert-file-contents nov)
+            (let ((nnheader-file-coding-system nnkiboze-file-coding-system))
+              (nnheader-insert-file-contents nov))
             (nnheader-nov-delete-outside-range
              (car articles) (car (last articles)))
             'nov))))))
@@ -119,7 +126,8 @@
           (nnkiboze-request-scan group))
         (if (not (file-exists-p nov-file))
             (nnheader-report 'nnkiboze "Can't select group %s" group)
-          (nnheader-insert-file-contents nov-file)
+          (let ((nnheader-file-coding-system nnkiboze-file-coding-system))
+            (nnheader-insert-file-contents nov-file))
           (if (zerop (buffer-size))
               (nnheader-insert "211 0 0 0 %s\n" group)
             (goto-char (point-min))
@@ -136,15 +144,17 @@
   ;; Remove NOV lines of articles that are marked as read.
   (when (and (file-exists-p (nnkiboze-nov-file-name))
              nnkiboze-remove-read-articles)
-    (nnheader-temp-write (nnkiboze-nov-file-name)
-      (let ((cur (current-buffer)))
-        (nnheader-insert-file-contents (nnkiboze-nov-file-name))
-        (goto-char (point-min))
-        (while (not (eobp))
-          (if (not (gnus-article-read-p (read cur)))
-              (forward-line 1)
-            (gnus-delete-line))))))
-  (setq nnkiboze-current-group nil))
+    (let ((coding-system-for-write nnkiboze-file-coding-system))
+      (with-temp-file (nnkiboze-nov-file-name)
+        (let ((cur (current-buffer)) 
+              (nnheader-file-coding-system nnkiboze-file-coding-system))
+          (nnheader-insert-file-contents (nnkiboze-nov-file-name))
+          (goto-char (point-min))
+          (while (not (eobp))
+            (if (not (gnus-article-read-p (read cur)))
+                (forward-line 1)
+              (gnus-delete-line))))))
+    (setq nnkiboze-current-group nil)))
 
 (deffoo nnkiboze-open-server (server &optional defs)
   (unless (assq 'nnkiboze-regexp defs)
@@ -155,15 +165,15 @@
 (deffoo nnkiboze-request-delete-group (group &optional force server)
   (nnkiboze-possibly-change-group group)
   (when force
-     (let ((files (nconc
-                   (nnkiboze-score-file group)
-                   (list (nnkiboze-nov-file-name)
-                         (nnkiboze-nov-file-name ".newsrc")))))
-       (while files
-         (and (file-exists-p (car files))
-              (file-writable-p (car files))
-              (delete-file (car files)))
-         (setq files (cdr files)))))
+    (let ((files (nconc
+                  (nnkiboze-score-file group)
+                  (list (nnkiboze-nov-file-name)
+                        (nnkiboze-nov-file-name ".newsrc")))))
+      (while files
+        (and (file-exists-p (car files))
+             (file-writable-p (car files))
+             (delete-file (car files)))
+        (setq files (cdr files)))))
   (setq nnkiboze-current-group nil)
   t)
 
@@ -184,6 +194,7 @@
 Finds out what articles are to be part of the nnkiboze groups."
   (interactive)
   (let ((nnmail-spool-file nil)
+        (mail-sources nil)
         (gnus-use-dribble-file nil)
         (gnus-read-active-file t)
         (gnus-expert-user t))
@@ -209,7 +220,7 @@ Finds out what articles are to be part of the nnkiboze groups."
 
 (defun nnkiboze-generate-group (group)
   (let* ((info (nth 2 (gnus-gethash group gnus-newsrc-hashtb)))
-         (newsrc-file (concat nnkiboze-directory 
+         (newsrc-file (concat nnkiboze-directory
                               (nnheader-translate-file-chars
                                (concat group ".newsrc"))))
          (nov-file (concat nnkiboze-directory
@@ -230,95 +241,96 @@ Finds out what articles are to be part of the nnkiboze groups."
     ;; Load the kiboze newsrc file for this group.
     (when (file-exists-p newsrc-file)
       (load newsrc-file))
-    (nnheader-temp-write nov-file
-      (when (file-exists-p nov-file)
-        (insert-file-contents nov-file))
-      (setq nov-buffer (current-buffer))
-      ;; Go through the active hashtb and add new all groups that match the
-      ;; kiboze regexp.
-      (mapatoms
-       (lambda (group)
-         (and (string-match nnkiboze-regexp
-                            (setq gname (symbol-name group))) ; Match
-              (not (assoc gname nnkiboze-newsrc)) ; It isn't registered
-              (numberp (car (symbol-value group))) ; It is active
-              (or (> nnkiboze-level 7)
-                  (and (setq glevel (nth 1 (nth 2 (gnus-gethash
-                                                   gname gnus-newsrc-hashtb))))
-                       (>= nnkiboze-level glevel)))
-              (not (string-match "^nnkiboze:" gname)) ; Exclude kibozes
-              (push (cons gname (1- (car (symbol-value group))))
-                    nnkiboze-newsrc)))
-       gnus-active-hashtb)
-      ;; `newsrc' is set to the list of groups that possibly are
-      ;; component groups to this kiboze group.  This list has elements
-      ;; on the form `(GROUP . NUMBER)', where NUMBER is the highest
-      ;; number that has been kibozed in GROUP in this kiboze group.
-      (setq newsrc nnkiboze-newsrc)
-      (while newsrc
-        (if (not (setq active (gnus-gethash
-                               (caar newsrc) gnus-active-hashtb)))
-            ;; This group isn't active after all, so we remove it from
-            ;; the list of component groups.
-            (setq nnkiboze-newsrc (delq (car newsrc) nnkiboze-newsrc))
-          (setq lowest (cdar newsrc))
-          ;; Ok, we have a valid component group, so we jump to it.
-          (switch-to-buffer gnus-group-buffer)
-          (gnus-group-jump-to-group (caar newsrc))
-          (gnus-message 3 "nnkiboze: Checking %s..." (caar newsrc))
-          (setq ginfo (gnus-get-info (gnus-group-group-name))
-                orig-info (gnus-copy-sequence ginfo)
-                num-unread (car (gnus-gethash (caar newsrc)
-                                              gnus-newsrc-hashtb)))
-          (unwind-protect
-              (progn
-                ;; We set all list of article marks to nil.  Since we operate
-                ;; on copies of the real lists, we can destroy anything we
-                ;; want here.
-                (when (nth 3 ginfo)
-                  (setcar (nthcdr 3 ginfo) nil))
-                ;; We set the list of read articles to be what we expect for
-                ;; this kiboze group -- either nil or `(1 . LOWEST)'.
-                (when ginfo
-                  (setcar (nthcdr 2 ginfo)
-                          (and (not (= lowest 1)) (cons 1 lowest))))
-                (when (and (or (not ginfo)
-                               (> (length (gnus-list-of-unread-articles
-                                           (car ginfo)))
-                                  0))
-                           (progn
-                             (ignore-errors 
-                               (gnus-group-select-group nil))
-                             (eq major-mode 'gnus-summary-mode)))
-                  ;; We are now in the group where we want to be.
-                  (setq method (gnus-find-method-for-group
-                                gnus-newsgroup-name))
-                  (when (eq method gnus-select-method)
-                    (setq method nil))
-                  ;; We go through the list of scored articles.
-                  (while gnus-newsgroup-scored
-                    (when (> (caar gnus-newsgroup-scored) lowest)
-                      ;; If it has a good score, then we enter this article
-                      ;; into the kiboze group.
-                      (nnkiboze-enter-nov
-                       nov-buffer
-                       (gnus-summary-article-header
-                        (caar gnus-newsgroup-scored))
-                       gnus-newsgroup-name))
-                    (setq gnus-newsgroup-scored (cdr gnus-newsgroup-scored)))
-                  ;; That's it.  We exit this group.
-                  (when (eq major-mode 'gnus-summary-mode)
-                    (kill-buffer (current-buffer)))))
-            ;; Restore the proper info.
-            (when ginfo
-              (setcdr ginfo (cdr orig-info)))
-            (setcar (gnus-gethash (caar newsrc) gnus-newsrc-hashtb)
-                    num-unread)))
-        (setcdr (car newsrc) (car active))
-        (gnus-message 3 "nnkiboze: Checking %s...done" (caar newsrc))
-        (setq newsrc (cdr newsrc))))
+    (let ((coding-system-for-write nnkiboze-file-coding-system))
+      (with-temp-file nov-file
+        (when (file-exists-p nov-file)
+          (insert-file-contents nov-file))
+        (setq nov-buffer (current-buffer))
+        ;; Go through the active hashtb and add new all groups that match the
+        ;; kiboze regexp.
+        (mapatoms
+         (lambda (group)
+           (and (string-match nnkiboze-regexp
+                              (setq gname (symbol-name group))) ; Match
+                (not (assoc gname nnkiboze-newsrc)) ; It isn't registered
+                (numberp (car (symbol-value group))) ; It is active
+                (or (> nnkiboze-level 7)
+                    (and (setq glevel (nth 1 (nth 2 (gnus-gethash
+                                                     gname gnus-newsrc-hashtb))))
+                         (>= nnkiboze-level glevel)))
+                (not (string-match "^nnkiboze:" gname)) ; Exclude kibozes
+                (push (cons gname (1- (car (symbol-value group))))
+                      nnkiboze-newsrc)))
+         gnus-active-hashtb)
+        ;; `newsrc' is set to the list of groups that possibly are
+        ;; component groups to this kiboze group.  This list has elements
+        ;; on the form `(GROUP . NUMBER)', where NUMBER is the highest
+        ;; number that has been kibozed in GROUP in this kiboze group.
+        (setq newsrc nnkiboze-newsrc)
+        (while newsrc
+          (if (not (setq active (gnus-gethash
+                                 (caar newsrc) gnus-active-hashtb)))
+              ;; This group isn't active after all, so we remove it from
+              ;; the list of component groups.
+              (setq nnkiboze-newsrc (delq (car newsrc) nnkiboze-newsrc))
+            (setq lowest (cdar newsrc))
+            ;; Ok, we have a valid component group, so we jump to it.
+            (switch-to-buffer gnus-group-buffer)
+            (gnus-group-jump-to-group (caar newsrc))
+            (gnus-message 3 "nnkiboze: Checking %s..." (caar newsrc))
+            (setq ginfo (gnus-get-info (gnus-group-group-name))
+                  orig-info (gnus-copy-sequence ginfo)
+                  num-unread (car (gnus-gethash (caar newsrc)
+                                                gnus-newsrc-hashtb)))
+            (unwind-protect
+                (progn
+                  ;; We set all list of article marks to nil.  Since we operate
+                  ;; on copies of the real lists, we can destroy anything we
+                  ;; want here.
+                  (when (nth 3 ginfo)
+                    (setcar (nthcdr 3 ginfo) nil))
+                  ;; We set the list of read articles to be what we expect for
+                  ;; this kiboze group -- either nil or `(1 . LOWEST)'.
+                  (when ginfo
+                    (setcar (nthcdr 2 ginfo)
+                            (and (not (= lowest 1)) (cons 1 lowest))))
+                  (when (and (or (not ginfo)
+                                 (> (length (gnus-list-of-unread-articles
+                                             (car ginfo)))
+                                    0))
+                             (progn
+                               (ignore-errors
+                                 (gnus-group-select-group nil))
+                               (eq major-mode 'gnus-summary-mode)))
+                    ;; We are now in the group where we want to be.
+                    (setq method (gnus-find-method-for-group
+                                  gnus-newsgroup-name))
+                    (when (eq method gnus-select-method)
+                      (setq method nil))
+                    ;; We go through the list of scored articles.
+                    (while gnus-newsgroup-scored
+                      (when (> (caar gnus-newsgroup-scored) lowest)
+                        ;; If it has a good score, then we enter this article
+                        ;; into the kiboze group.
+                        (nnkiboze-enter-nov
+                         nov-buffer
+                         (gnus-summary-article-header
+                          (caar gnus-newsgroup-scored))
+                         gnus-newsgroup-name))
+                      (setq gnus-newsgroup-scored (cdr gnus-newsgroup-scored)))
+                    ;; That's it.  We exit this group.
+                    (when (eq major-mode 'gnus-summary-mode)
+                      (kill-buffer (current-buffer)))))
+              ;; Restore the proper info.
+              (when ginfo
+                (setcdr ginfo (cdr orig-info)))
+              (setcar (gnus-gethash (caar newsrc) gnus-newsrc-hashtb)
+                      num-unread)))
+          (setcdr (car newsrc) (car active))
+          (gnus-message 3 "nnkiboze: Checking %s...done" (caar newsrc))
+          (setq newsrc (cdr newsrc)))))
     ;; We save the kiboze newsrc for this group.
-    (nnheader-temp-write newsrc-file
+    (with-temp-file newsrc-file
       (insert "(setq nnkiboze-newsrc '")
       (gnus-prin1 nnkiboze-newsrc)
       (insert ")\n")))
@@ -340,19 +352,22 @@ Finds out what articles are to be part of the nnkiboze groups."
             (forward-line 1))
         (setq article 1))
       (mail-header-set-number oheader article)
-      (nnheader-insert-nov oheader)
-      (search-backward "\t" nil t 2)
-      (if (re-search-forward " [^ ]+:[0-9]+" nil t)
-          (goto-char (match-beginning 0))
+      (with-temp-buffer
+        (insert (mail-header-xref oheader))
+        (goto-char (point-min))
+        (if (re-search-forward " [^ ]+:[0-9]+" nil t)
+            (goto-char (match-beginning 0))
         (forward-char 1))
-      ;; The first Xref has to be the group this article
-      ;; really came for - this is the article nnkiboze
-      ;; will request when it is asked for the article.
-      (insert " " group ":"
-              (int-to-string (mail-header-number header)) " ")
-      (while (re-search-forward " [^ ]+:[0-9]+" nil t)
-        (goto-char (1+ (match-beginning 0)))
-        (insert prefix)))))
+        ;; The first Xref has to be the group this article
+        ;; really came for - this is the article nnkiboze
+        ;; will request when it is asked for the article.
+        (insert " " group ":"
+                (int-to-string (mail-header-number header)) " ")
+        (while (re-search-forward " [^ ]+:[0-9]+" nil t)
+          (goto-char (1+ (match-beginning 0)))
+          (insert prefix))
+        (mail-header-set-xref oheader (buffer-string)))
+      (nnheader-insert-nov oheader))))
 
 (defun nnkiboze-nov-file-name (&optional suffix)
   (concat (file-name-as-directory nnkiboze-directory)