Importing Oort Gnus v0.05.

[elisp/gnus.git-] / lisp / gnus.el
diff --git a/lisp/gnus.el b/lisp/gnus.el

index 1663949..2b17690 100644 (file)
--- a/lisp/gnus.el
+++ b/lisp/gnus.el
@@ -1,5 +1,7 @@
  ;;; gnus.el --- a newsreader for GNU Emacs
  ;;; gnus.el --- a newsreader for GNU Emacs
-;; 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, 2001, 2002 Free Software Foundation, Inc.
  
  ;; Author: Masanobu UMEDA <umerin@flab.flab.fujitsu.junet>
  ;;     Lars Magne Ingebrigtsen <larsi@gnus.org>
  
  ;; Author: Masanobu UMEDA <umerin@flab.flab.fujitsu.junet>
  ;;     Lars Magne Ingebrigtsen <larsi@gnus.org>
@@ -29,18 +31,25 @@
  (eval '(run-hooks 'gnus-load-hook))
  
  (eval-when-compile (require 'cl))
  (eval '(run-hooks 'gnus-load-hook))
  
  (eval-when-compile (require 'cl))
-
-(require 'custom)
-(eval-and-compile
-  (if (< emacs-major-version 20)
-      (require 'gnus-load)))
-(require 'message)
+(require 'wid-edit)
+(require 'mm-util)
  
  (defgroup gnus nil
    "The coffee-brewing, all singing, all dancing, kitchen sink newsreader."
    :group 'news
    :group 'mail)
  
  
  (defgroup gnus nil
    "The coffee-brewing, all singing, all dancing, kitchen sink newsreader."
    :group 'news
    :group 'mail)
  
+(defgroup gnus-format nil
+  "Dealing with formatting issues."
+  :group 'news
+  :group 'mail)
+
+(defgroup gnus-charset nil
+  "Group character set issues."
+  :link '(custom-manual "(gnus)Charsets")
+  :version "21.1"
+  :group 'gnus)
+
  (defgroup gnus-cache nil
    "Cache interface."
    :group 'gnus)
  (defgroup gnus-cache nil
    "Cache interface."
    :group 'gnus)
@@ -130,6 +139,10 @@
    :link '(custom-manual "(gnus)Summary Maneuvering")
    :group 'gnus-summary)
  
    :link '(custom-manual "(gnus)Summary Maneuvering")
    :group 'gnus-summary)
  
+(defgroup gnus-picon nil
+  "Show pictures of people, domains, and newsgroups."
+  :group 'gnus-visual)
+
  (defgroup gnus-summary-mail nil
    "Mail group commands."
    :link '(custom-manual "(gnus)Mail Group Commands")
  (defgroup gnus-summary-mail nil
    "Mail group commands."
    :link '(custom-manual "(gnus)Mail Group Commands")
@@ -230,6 +243,11 @@
    "Options related to newsservers and other servers used by Gnus."
    :group 'gnus)
  
    "Options related to newsservers and other servers used by Gnus."
    :group 'gnus)
  
+(defgroup gnus-server-visual nil
+  "Highlighting and menus in the server buffer."
+  :group 'gnus-visual
+  :group 'gnus-server)
+
  (defgroup gnus-message '((message custom-group))
    "Composing replies and followups in Gnus."
    :group 'gnus)
  (defgroup gnus-message '((message custom-group))
    "Composing replies and followups in Gnus."
    :group 'gnus)
@@ -245,15 +263,24 @@ is restarted, and sometimes reloaded."
    :link '(custom-manual "(gnus)Various Various")
    :group 'gnus)
  
    :link '(custom-manual "(gnus)Various Various")
    :group 'gnus)
  
+(defgroup gnus-mime nil
+  "Variables for controlling the Gnus MIME interface."
+  :group 'gnus)
+
  (defgroup gnus-exit nil
    "Exiting gnus."
    :link '(custom-manual "(gnus)Exiting Gnus")
    :group 'gnus)
  
  (defgroup gnus-exit nil
    "Exiting gnus."
    :link '(custom-manual "(gnus)Exiting Gnus")
    :group 'gnus)
  
-(defconst gnus-version-number "5.6.27"
+(defgroup gnus-fun nil
+  "Frivolous Gnus extensions."
+  :link '(custom-manual "(gnus)Exiting Gnus")
+  :group 'gnus)
+
+(defconst gnus-version-number "0.05"
    "Version number for this version of Gnus.")
  
    "Version number for this version of Gnus.")
  
-(defconst gnus-version (format "Gnus v%s" gnus-version-number)
+(defconst gnus-version (format "Oort Gnus v%s" gnus-version-number)
    "Version string for this version of Gnus.")
  
  (defcustom gnus-inhibit-startup-message nil
    "Version string for this version of Gnus.")
  
  (defcustom gnus-inhibit-startup-message nil
@@ -268,28 +295,55 @@ be set in `.emacs' instead."
    :group 'gnus-start
    :type 'boolean)
  
    :group 'gnus-start
    :type 'boolean)
  
-;;; Kludges to help the transition from the old `custom.el'.
+(unless (fboundp 'gnus-group-remove-excess-properties)
+  (defalias 'gnus-group-remove-excess-properties 'ignore))
+
+(unless (fboundp 'gnus-set-text-properties)
+  (defalias 'gnus-set-text-properties 'set-text-properties))
  
  (unless (featurep 'gnus-xmas)
    (defalias 'gnus-make-overlay 'make-overlay)
    (defalias 'gnus-delete-overlay 'delete-overlay)
    (defalias 'gnus-overlay-put 'overlay-put)
    (defalias 'gnus-move-overlay 'move-overlay)
  
  (unless (featurep 'gnus-xmas)
    (defalias 'gnus-make-overlay 'make-overlay)
    (defalias 'gnus-delete-overlay 'delete-overlay)
    (defalias 'gnus-overlay-put 'overlay-put)
    (defalias 'gnus-move-overlay 'move-overlay)
+  (defalias 'gnus-overlay-buffer 'overlay-buffer)
+  (defalias 'gnus-overlay-start 'overlay-start)
    (defalias 'gnus-overlay-end 'overlay-end)
    (defalias 'gnus-extent-detached-p 'ignore)
    (defalias 'gnus-extent-start-open 'ignore)
    (defalias 'gnus-overlay-end 'overlay-end)
    (defalias 'gnus-extent-detached-p 'ignore)
    (defalias 'gnus-extent-start-open 'ignore)
-  (defalias 'gnus-set-text-properties 'set-text-properties)
-  (defalias 'gnus-group-remove-excess-properties 'ignore)
    (defalias 'gnus-appt-select-lowest-window 'appt-select-lowest-window)
    (defalias 'gnus-mail-strip-quoted-names 'mail-strip-quoted-names)
    (defalias 'gnus-character-to-event 'identity)
    (defalias 'gnus-add-text-properties 'add-text-properties)
    (defalias 'gnus-put-text-property 'put-text-property)
    (defalias 'gnus-appt-select-lowest-window 'appt-select-lowest-window)
    (defalias 'gnus-mail-strip-quoted-names 'mail-strip-quoted-names)
    (defalias 'gnus-character-to-event 'identity)
    (defalias 'gnus-add-text-properties 'add-text-properties)
    (defalias 'gnus-put-text-property 'put-text-property)
-  (defalias 'gnus-mode-line-buffer-identification 'identity)
+  (defvar gnus-mode-line-image-cache t)
+  (if (fboundp 'find-image)
+      (defun gnus-mode-line-buffer-identification (line)
+       (let ((str (car-safe line)))
+         (if (and (stringp str)
+                  (string-match "^Gnus:" str))
+             (progn (add-text-properties
+                     0 5
+                     (list 'display
+                           (if (eq t gnus-mode-line-image-cache)
+                               (setq gnus-mode-line-image-cache
+                                     (find-image
+                                      '((:type xpm :file "gnus-pointer.xpm"
+                                               :ascent center)
+                                        (:type xbm :file "gnus-pointer.xbm"
+                                               :ascent center))))
+                             gnus-mode-line-image-cache)
+                           'help-echo "This is Gnus")
+                     str)
+                    (list str))
+           line)))
+    (defalias 'gnus-mode-line-buffer-identification 'identity))
    (defalias 'gnus-characterp 'numberp)
    (defalias 'gnus-deactivate-mark 'deactivate-mark)
    (defalias 'gnus-window-edges 'window-edges)
    (defalias 'gnus-characterp 'numberp)
    (defalias 'gnus-deactivate-mark 'deactivate-mark)
    (defalias 'gnus-window-edges 'window-edges)
-  (defalias 'gnus-key-press-event-p 'numberp))
+  (defalias 'gnus-key-press-event-p 'numberp)
+  ;;(defalias 'gnus-decode-rfc1522 'ignore)
+  )
  
  ;; We define these group faces here to avoid the display
  ;; update forced when creating new faces.
  
  ;; We define these group faces here to avoid the display
  ;; update forced when creating new faces.
@@ -360,6 +414,72 @@ be set in `.emacs' instead."
       ()))
    "Level 3 empty newsgroup face.")
  
       ()))
    "Level 3 empty newsgroup face.")
  
+(defface gnus-group-news-4-face
+  '((((class color)
+      (background dark))
+     (:bold t))
+    (((class color)
+      (background light))
+     (:bold t))
+    (t
+     ()))
+  "Level 4 newsgroup face.")
+
+(defface gnus-group-news-4-empty-face
+  '((((class color)
+      (background dark))
+     ())
+    (((class color)
+      (background light))
+     ())
+    (t
+     ()))
+  "Level 4 empty newsgroup face.")
+
+(defface gnus-group-news-5-face
+  '((((class color)
+      (background dark))
+     (:bold t))
+    (((class color)
+      (background light))
+     (:bold t))
+    (t
+     ()))
+  "Level 5 newsgroup face.")
+
+(defface gnus-group-news-5-empty-face
+  '((((class color)
+      (background dark))
+     ())
+    (((class color)
+      (background light))
+     ())
+    (t
+     ()))
+  "Level 5 empty newsgroup face.")
+
+(defface gnus-group-news-6-face
+  '((((class color)
+      (background dark))
+     (:bold t))
+    (((class color)
+      (background light))
+     (:bold t))
+    (t
+     ()))
+  "Level 6 newsgroup face.")
+
+(defface gnus-group-news-6-empty-face
+  '((((class color)
+      (background dark))
+     ())
+    (((class color)
+      (background light))
+     ())
+    (t
+     ()))
+  "Level 6 empty newsgroup face.")
+
  (defface gnus-group-news-low-face
    '((((class color)
        (background dark))
  (defface gnus-group-news-low-face
    '((((class color)
        (background dark))
@@ -600,6 +720,33 @@ be set in `.emacs' instead."
    "Face used for normal interest read articles.")
  
  
    "Face used for normal interest read articles.")
  
  
+;;;
+;;; Gnus buffers
+;;;
+
+(defvar gnus-buffers nil)
+
+(defun gnus-get-buffer-create (name)
+  "Do the same as `get-buffer-create', but store the created buffer."
+  (or (get-buffer name)
+      (car (push (get-buffer-create name) gnus-buffers))))
+
+(defun gnus-add-buffer ()
+  "Add the current buffer to the list of Gnus buffers."
+  (push (current-buffer) gnus-buffers))
+
+(defun gnus-buffers ()
+  "Return a list of live Gnus buffers."
+  (while (and gnus-buffers
+             (not (buffer-name (car gnus-buffers))))
+    (pop gnus-buffers))
+  (let ((buffers gnus-buffers))
+    (while (cdr buffers)
+      (if (buffer-name (cadr buffers))
+         (pop buffers)
+       (setcdr buffers (cddr buffers)))))
+  gnus-buffers)
+
  ;;; Splash screen.
  
  (defvar gnus-group-buffer "*Group*")
  ;;; Splash screen.
  
  (defvar gnus-group-buffer "*Group*")
@@ -610,17 +757,17 @@ be set in `.emacs' instead."
  (defface gnus-splash-face
    '((((class color)
        (background dark))
  (defface gnus-splash-face
    '((((class color)
        (background dark))
-     (:foreground "ForestGreen"))
+     (:foreground "#888888"))
      (((class color)
        (background light))
      (((class color)
        (background light))
-     (:foreground "ForestGreen"))
+     (:foreground "#888888"))
      (t
       ()))
      (t
       ()))
-  "Level 1 newsgroup face.")
+  "Face for the splash screen.")
  
  (defun gnus-splash ()
    (save-excursion
  
  (defun gnus-splash ()
    (save-excursion
-    (switch-to-buffer (get-buffer-create gnus-group-buffer))
+    (switch-to-buffer (gnus-get-buffer-create gnus-group-buffer))
      (let ((buffer-read-only nil))
        (erase-buffer)
        (unless gnus-inhibit-startup-message
      (let ((buffer-read-only nil))
        (erase-buffer)
        (unless gnus-inhibit-startup-message
@@ -644,12 +791,72 @@ be set in `.emacs' instead."
  
  (defvar gnus-simple-splash nil)
  
  
  (defvar gnus-simple-splash nil)
  
+;;(format "%02x%02x%02x" 114 66 20) "724214"
+
+(defvar gnus-logo-color-alist
+  '((flame "#cc3300" "#ff2200")
+    (pine "#c0cc93" "#f8ffb8")
+    (moss "#a1cc93" "#d2ffb8")
+    (irish "#04cc90" "#05ff97")
+    (sky "#049acc" "#05deff")
+    (tin "#6886cc" "#82b6ff")
+    (velvet "#7c68cc" "#8c82ff")
+    (grape "#b264cc" "#cf7df")
+    (labia "#cc64c2" "#fd7dff")
+    (berry "#cc6485" "#ff7db5")
+    (dino "#724214" "#1e3f03")
+    (oort "#cccccc" "#888888")
+    (storm "#666699" "#99ccff")
+    (pdino "#9999cc" "#99ccff")
+    (purp "#9999cc" "#666699")
+    (neutral "#b4b4b4" "#878787")
+    (september "#bf9900" "#ffcc00"))
+  "Color alist used for the Gnus logo.")
+
+(defcustom gnus-logo-color-style 'oort
+  "*Color styles used for the Gnus logo."
+  :type `(choice ,@(mapcar (lambda (elem) (list 'const (car elem)))
+                          gnus-logo-color-alist))
+  :group 'gnus-xmas)
+
+(defvar gnus-logo-colors
+  (cdr (assq gnus-logo-color-style gnus-logo-color-alist))
+  "Colors used for the Gnus logo.")
+
  (defun gnus-group-startup-message (&optional x y)
    "Insert startup message in current buffer."
    ;; Insert the message.
    (erase-buffer)
  (defun gnus-group-startup-message (&optional x y)
    "Insert startup message in current buffer."
    ;; Insert the message.
    (erase-buffer)
-  (insert
-   (format "              %s
+  (cond
+   ((and
+     (fboundp 'find-image)
+     (display-graphic-p)
+     (let ((image (find-image
+                  `((:type xpm :file "gnus.xpm"
+                           :color-symbols
+                           (("thing" . ,(car gnus-logo-colors))
+                            ("shadow" . ,(cadr gnus-logo-colors))
+                            ("background" . ,(face-background 'default))))
+                    (:type pbm :file "gnus.pbm"
+                           ;; Account for the pbm's blackground.
+                           :background ,(face-foreground 'gnus-splash-face)
+                           :foreground ,(face-background 'default))
+                    (:type xbm :file "gnus.xbm"
+                           ;; Account for the xbm's blackground.
+                           :background ,(face-foreground 'gnus-splash-face)
+                           :foreground ,(face-background 'default))))))
+       (when image
+        (let ((size (image-size image)))
+          (insert-char ?\n (max 0 (round (- (window-height)
+                                            (or y (cdr size)) 1) 2)))
+          (insert-char ?\  (max 0 (round (- (window-width)
+                                            (or x (car size))) 2)))
+          (insert-image image))
+        (setq gnus-simple-splash nil)
+        t))))
+   (t
+    (insert
+     (format "              %s
            _    ___ _             _
            _ ___ __ ___  __    _ ___
            __   _     ___    __  ___
            _    ___ _             _
            _ ___ __ ___  __    _ ___
            __   _     ___    __  ___
@@ -669,35 +876,132 @@ be set in `.emacs' instead."
            __
  
  "
            __
  
  "
-           ""))
-  ;; And then hack it.
-  (gnus-indent-rigidly (point-min) (point-max)
-                      (/ (max (- (window-width) (or x 46)) 0) 2))
-  (goto-char (point-min))
-  (forward-line 1)
-  (let* ((pheight (count-lines (point-min) (point-max)))
-        (wheight (window-height))
-        (rest (- wheight pheight)))
-    (insert (make-string (max 0 (* 2 (/ rest 3))) ?\n)))
-  ;; Fontify some.
-  (put-text-property (point-min) (point-max) 'face 'gnus-splash-face)
+            ""))
+    ;; And then hack it.
+    (gnus-indent-rigidly (point-min) (point-max)
+                        (/ (max (- (window-width) (or x 46)) 0) 2))
+    (goto-char (point-min))
+    (forward-line 1)
+    (let* ((pheight (count-lines (point-min) (point-max)))
+          (wheight (window-height))
+          (rest (- wheight pheight)))
+      (insert (make-string (max 0 (* 2 (/ rest 3))) ?\n)))
+    ;; Fontify some.
+    (put-text-property (point-min) (point-max) 'face 'gnus-splash-face)
+    (setq gnus-simple-splash t)))
    (goto-char (point-min))
    (setq mode-line-buffer-identification (concat " " gnus-version))
    (goto-char (point-min))
    (setq mode-line-buffer-identification (concat " " gnus-version))
-  (setq gnus-simple-splash t)
    (set-buffer-modified-p t))
  
  (eval-when (load)
    (let ((command (format "%s" this-command)))
    (set-buffer-modified-p t))
  
  (eval-when (load)
    (let ((command (format "%s" this-command)))
-    (when (and (string-match "gnus" command)
-              (not (string-match "gnus-other-frame" command)))
-      (gnus-splash))))
+    (if (and (string-match "gnus" command)
+            (not (string-match "gnus-other-frame" command)))
+       (gnus-splash)
+      (gnus-get-buffer-create gnus-group-buffer))))
  
  ;;; Do the rest.
  
  
  ;;; Do the rest.
  
-(require 'custom)
  (require 'gnus-util)
  (require 'nnheader)
  
  (require 'gnus-util)
  (require 'nnheader)
  
+(defcustom gnus-parameters nil
+  "Alist of group parameters.
+
+For example:
+   ((\"mail\\\\..*\"  (gnus-show-threads nil)
+                 (gnus-use-scoring nil)
+                 (gnus-summary-line-format
+                       \"%U%R%z%I%(%[%d:%ub%-23,23f%]%) %s\\n\")
+                 (gcc-self . t)
+                 (display . all))
+     (\"mail\\\\.me\" (gnus-use-scoring  t))
+     (\"list\\\\..*\" (total-expire . t)
+                 (broken-reply-to . t)))"
+  :group 'gnus-group-various
+  :type '(repeat (cons regexp
+                      (repeat sexp))))
+
+(defvar gnus-group-parameters-more nil)
+
+(defmacro gnus-define-group-parameter (param &rest rest)
+  "Define a group parameter PARAM.
+REST is a plist of following:
+:type               One of `bool', `list' or `nil'.
+:function           The name of the function.
+:function-document  The documentation of the function.
+:parameter-type     The type for customizing the parameter.
+:parameter-document The documentation for the parameter.
+:variable           The name of the variable.
+:variable-document  The documentation for the variable.
+:variable-group     The group for customizing the variable.
+:variable-type      The type for customizing the variable.
+:variable-default   The default value of the variable."
+  (let* ((type (plist-get rest :type))
+        (parameter-type (plist-get rest :parameter-type))
+        (parameter-document (plist-get rest :parameter-document))
+        (function (or (plist-get rest :function)
+                      (intern (format "gnus-parameter-%s" param))))
+        (function-document (or (plist-get rest :function-document) ""))
+        (variable (or (plist-get rest :variable)
+                      (intern (format "gnus-parameter-%s-alist" param))))
+        (variable-document (or (plist-get rest :variable-document) ""))
+        (variable-group (plist-get rest :variable-group))
+        (variable-type (or (plist-get rest :variable-type)
+                           `(quote (repeat
+                                    (list (regexp :tag "Group")
+                                          ,(car (cdr parameter-type)))))))
+        (variable-default (plist-get rest :variable-default)))
+    (list
+     'progn
+     `(defcustom ,variable ,variable-default
+       ,variable-document
+       :group 'gnus-group-parameter
+       :group ',variable-group
+       :type ,variable-type)
+     `(setq gnus-group-parameters-more
+           (delq (assq ',param gnus-group-parameters-more)
+                 gnus-group-parameters-more))
+     `(add-to-list 'gnus-group-parameters-more
+                  (list ',param
+                        ,parameter-type
+                        ,parameter-document))
+     (if (eq type 'bool)
+        `(defun ,function (name)
+           ,function-document
+           (let ((params (gnus-group-find-parameter name))
+                 val)
+             (cond
+              ((memq ',param params)
+               t)
+              ((setq val (assq ',param params))
+               (cdr val))
+              ((stringp ,variable)
+               (string-match ,variable name))
+              (,variable
+               (let ((alist ,variable)
+                     elem value)
+                 (while (setq elem (pop alist))
+                   (when (and name
+                              (string-match (car elem) name))
+                     (setq alist nil
+                           value (cdr elem))))
+                 (if (consp value) (car value) value))))))
+       `(defun ,function (name)
+         ,function-document
+         (and name
+              (or (gnus-group-find-parameter name ',param ,(and type t))
+                  (let ((alist ,variable)
+                        elem value)
+                    (while (setq elem (pop alist))
+                      (when (and name
+                                 (string-match (car elem) name))
+                        (setq alist nil
+                              value (cdr elem))))
+                    ,(if type
+                         'value
+                       '(if (consp value) (car value) value))))))))))
+
  (defcustom gnus-home-directory "~/"
    "Directory variable that specifies the \"home\" directory.
  All other Gnus path variables are initialized from this variable."
  (defcustom gnus-home-directory "~/"
    "Directory variable that specifies the \"home\" directory.
  All other Gnus path variables are initialized from this variable."
@@ -753,32 +1057,31 @@ used to 899, you would say something along these lines:
    (or (getenv "NNTPSERVER")
        (and (file-readable-p gnus-nntpserver-file)
            (save-excursion
    (or (getenv "NNTPSERVER")
        (and (file-readable-p gnus-nntpserver-file)
            (save-excursion
-            (set-buffer (get-buffer-create " *gnus nntp*"))
-            (buffer-disable-undo (current-buffer))
+            (set-buffer (gnus-get-buffer-create " *gnus nntp*"))
              (insert-file-contents gnus-nntpserver-file)
              (let ((name (buffer-string)))
                (prog1
              (insert-file-contents gnus-nntpserver-file)
              (let ((name (buffer-string)))
                (prog1
-                  (if (string-match "^[ \t\n]*$" name)
+                  (if (string-match "\\'[ \t\n]*$" name)
                        nil
                      name)
                  (kill-buffer (current-buffer))))))))
  
  (defcustom gnus-select-method
    (condition-case nil
                        nil
                      name)
                  (kill-buffer (current-buffer))))))))
  
  (defcustom gnus-select-method
    (condition-case nil
-    (nconc
-     (list 'nntp (or (condition-case nil
-                        (gnus-getenv-nntpserver)
-                      (error nil))
-                    (when (and gnus-default-nntp-server
-                               (not (string= gnus-default-nntp-server "")))
-                      gnus-default-nntp-server)
-                    "news"))
-     (if (or (null gnus-nntp-service)
-            (equal gnus-nntp-service "nntp"))
-        nil
-       (list gnus-nntp-service)))
+      (nconc
+       (list 'nntp (or (condition-case nil
+                          (gnus-getenv-nntpserver)
+                        (error nil))
+                      (when (and gnus-default-nntp-server
+                                 (not (string= gnus-default-nntp-server "")))
+                        gnus-default-nntp-server)
+                      "news"))
+       (if (or (null gnus-nntp-service)
+              (equal gnus-nntp-service "nntp"))
+          nil
+        (list gnus-nntp-service)))
      (error nil))
      (error nil))
-  "*Default method for selecting a newsgroup.
+  "Default method for selecting a newsgroup.
  This variable should be a list, where the first element is how the
  news is to be fetched, the second is the address.
  
  This variable should be a list, where the first element is how the
  news is to be fetched, the second is the address.
  
@@ -798,20 +1101,9 @@ see the manual for details."
    :group 'gnus-server
    :type 'gnus-select-method)
  
    :group 'gnus-server
    :type 'gnus-select-method)
  
-(defcustom gnus-message-archive-method
-  `(nnfolder
-    "archive"
-    (nnfolder-directory ,(nnheader-concat message-directory "archive"))
-    (nnfolder-active-file
-     ,(nnheader-concat message-directory "archive/active"))
-    (nnfolder-get-new-mail nil)
-    (nnfolder-inhibit-expiry t))
+(defcustom gnus-message-archive-method "archive"
    "*Method used for archiving messages you've sent.
    "*Method used for archiving messages you've sent.
-This should be a mail method.
-
-It's probably not a very effective to change this variable once you've
-run Gnus once.  After doing that, you must edit this server from the
-server buffer."
+This should be a mail method."
    :group 'gnus-server
    :group 'gnus-message
    :type 'gnus-select-method)
    :group 'gnus-server
    :group 'gnus-message
    :type 'gnus-select-method)
@@ -827,9 +1119,9 @@ If you want to save your mail in one group and the news articles you
  write in another group, you could say something like:
  
   \(setq gnus-message-archive-group
  write in another group, you could say something like:
  
   \(setq gnus-message-archive-group
-        '((if (message-news-p)
-              \"misc-news\"
-            \"misc-mail\")))
+       '((if (message-news-p)
+             \"misc-news\"
+           \"misc-mail\")))
  
  Normally the group names returned by this variable should be
  unprefixed -- which implicitly means \"store on the archive server\".
  
  Normally the group names returned by this variable should be
  unprefixed -- which implicitly means \"store on the archive server\".
@@ -838,6 +1130,7 @@ that case, just return a fully prefixed name of the group --
  \"nnml+private:mail.misc\", for instance."
    :group 'gnus-message
    :type '(choice (const :tag "none" nil)
  \"nnml+private:mail.misc\", for instance."
    :group 'gnus-message
    :type '(choice (const :tag "none" nil)
+                function
                  sexp
                  string))
  
                  sexp
                  string))
  
@@ -865,8 +1158,8 @@ If, for instance, you want to read your mail with the nnml backend,
  you could set this variable:
  
  \(setq gnus-secondary-select-methods '((nnml \"\")))"
  you could set this variable:
  
  \(setq gnus-secondary-select-methods '((nnml \"\")))"
-:group 'gnus-server
-:type '(repeat gnus-select-method))
+  :group 'gnus-server
+  :type '(repeat gnus-select-method))
  
  (defvar gnus-backup-default-subscribed-newsgroups
    '("news.announce.newusers" "news.groups.questions" "gnu.emacs.gnus")
  
  (defvar gnus-backup-default-subscribed-newsgroups
    '("news.announce.newusers" "news.groups.questions" "gnu.emacs.gnus")
@@ -876,7 +1169,7 @@ Should be set in paths.el, and shouldn't be touched by the user.")
  (defcustom gnus-local-domain nil
    "Local domain name without a host name.
  The DOMAINNAME environment variable is used instead if it is defined.
  (defcustom gnus-local-domain nil
    "Local domain name without a host name.
  The DOMAINNAME environment variable is used instead if it is defined.
-If the `system-name' function returns the full Internet name, there is
+If the function `system-name' returns the full Internet name, there is
  no need to set this variable."
    :group 'gnus-message
    :type '(choice (const :tag "default" nil)
  no need to set this variable."
    :group 'gnus-message
    :type '(choice (const :tag "default" nil)
@@ -895,17 +1188,30 @@ articles by Message-ID is painfully slow.  By setting this method to an
  nntp method, you might get acceptable results.
  
  The value of this variable must be a valid select method as discussed
  nntp method, you might get acceptable results.
  
  The value of this variable must be a valid select method as discussed
-in the documentation of `gnus-select-method'."
+in the documentation of `gnus-select-method'.
+
+It can also be a list of select methods, as well as the special symbol
+`current', which means to use the current select method.  If it is a
+list, Gnus will try all the methods in the list until it finds a match."
    :group 'gnus-server
    :type '(choice (const :tag "default" nil)
    :group 'gnus-server
    :type '(choice (const :tag "default" nil)
-                gnus-select-method))
+                (const :tag "DejaNews" (nnweb "refer" (nnweb-type dejanews)))
+                gnus-select-method
+                (repeat :menu-tag "Try multiple"
+                        :tag "Multiple"
+                        :value (current (nnweb "refer" (nnweb-type dejanews)))
+                        (choice :tag "Method"
+                                (const current)
+                                (const :tag "DejaNews"
+                                       (nnweb "refer" (nnweb-type dejanews)))
+                                gnus-select-method))))
  
  (defcustom gnus-group-faq-directory
    '("/ftp@mirrors.aol.com:/pub/rtfm/usenet/"
  
  (defcustom gnus-group-faq-directory
    '("/ftp@mirrors.aol.com:/pub/rtfm/usenet/"
-    "/ftp@sunsite.auc.dk:/pub/usenet/"
      "/ftp@sunsite.doc.ic.ac.uk:/pub/usenet/news-faqs/"
      "/ftp@src.doc.ic.ac.uk:/usenet/news-FAQS/"
      "/ftp@ftp.seas.gwu.edu:/pub/rtfm/"
      "/ftp@sunsite.doc.ic.ac.uk:/pub/usenet/news-faqs/"
      "/ftp@src.doc.ic.ac.uk:/usenet/news-FAQS/"
      "/ftp@ftp.seas.gwu.edu:/pub/rtfm/"
+    "/ftp@ftp.pasteur.fr:/pub/FAQ/"
      "/ftp@rtfm.mit.edu:/pub/usenet/"
      "/ftp@ftp.uni-paderborn.de:/pub/FAQ/"
      "/ftp@ftp.sunet.se:/pub/usenet/"
      "/ftp@rtfm.mit.edu:/pub/usenet/"
      "/ftp@ftp.uni-paderborn.de:/pub/FAQ/"
      "/ftp@ftp.sunet.se:/pub/usenet/"
@@ -930,9 +1236,9 @@ If the default site is too slow, try one of these:
                   ftp.seas.gwu.edu               /pub/rtfm
                   rtfm.mit.edu                   /pub/usenet
     Europe:       ftp.uni-paderborn.de           /pub/FAQ
                   ftp.seas.gwu.edu               /pub/rtfm
                   rtfm.mit.edu                   /pub/usenet
     Europe:       ftp.uni-paderborn.de           /pub/FAQ
-                  src.doc.ic.ac.uk               /usenet/news-FAQS
+                 src.doc.ic.ac.uk               /usenet/news-FAQS
                   ftp.sunet.se                   /pub/usenet
                   ftp.sunet.se                   /pub/usenet
-                 sunsite.auc.dk                 /pub/usenet
+                 ftp.pasteur.fr                 /pub/FAQ
     Asia:         nctuccca.edu.tw                /USENET/FAQ
                   hwarang.postech.ac.kr          /pub/usenet
                   ftp.hk.super.net               /mirror/faqs"
     Asia:         nctuccca.edu.tw                /USENET/FAQ
                   hwarang.postech.ac.kr          /pub/usenet
                   ftp.hk.super.net               /mirror/faqs"
@@ -957,15 +1263,11 @@ newsgroups."
    :group 'gnus-summary-marks
    :type 'character)
  
    :group 'gnus-summary-marks
    :type 'character)
  
-(defcustom gnus-asynchronous nil
-  "*If non-nil, Gnus will supply backends with data needed for async article fetching."
-  :group 'gnus-asynchronous
-  :type 'boolean)
-
  (defcustom gnus-large-newsgroup 200
    "*The number of articles which indicates a large newsgroup.
  If the number of articles in a newsgroup is greater than this value,
  (defcustom gnus-large-newsgroup 200
    "*The number of articles which indicates a large newsgroup.
  If the number of articles in a newsgroup is greater than this value,
-confirmation is required for selecting the newsgroup."
+confirmation is required for selecting the newsgroup.
+If it is `nil', no confirmation is required."
    :group 'gnus-group-select
    :type 'integer)
  
    :group 'gnus-group-select
    :type 'integer)
  
@@ -1053,21 +1355,11 @@ articles.  This is not a good idea."
    :group 'gnus-meta
    :type 'boolean)
  
    :group 'gnus-meta
    :type 'boolean)
  
-(defcustom gnus-use-demon nil
-  "If non-nil, Gnus might use some demons."
-  :group 'gnus-meta
-  :type 'boolean)
-
  (defcustom gnus-use-scoring t
    "*If non-nil, enable scoring."
    :group 'gnus-meta
    :type 'boolean)
  
  (defcustom gnus-use-scoring t
    "*If non-nil, enable scoring."
    :group 'gnus-meta
    :type 'boolean)
  
-(defcustom gnus-use-picons nil
-  "*If non-nil, display picons."
-  :group 'gnus-meta
-  :type 'boolean)
-
  (defcustom gnus-summary-prepare-exit-hook
    '(gnus-summary-expire-articles)
    "*A hook called when preparing to exit from the summary buffer.
  (defcustom gnus-summary-prepare-exit-hook
    '(gnus-summary-expire-articles)
    "*A hook called when preparing to exit from the summary buffer.
@@ -1125,7 +1417,7 @@ slower."
      ("nnspool" post address)
      ("nnvirtual" post-mail virtual prompt-address)
      ("nnmbox" mail respool address)
      ("nnspool" post address)
      ("nnvirtual" post-mail virtual prompt-address)
      ("nnmbox" mail respool address)
-    ("nnml" mail respool address)
+    ("nnml" post-mail respool address)
      ("nnmh" mail respool address)
      ("nndir" post-mail prompt-address physical-address)
      ("nneething" none address prompt-address physical-address)
      ("nnmh" mail respool address)
      ("nndir" post-mail prompt-address physical-address)
      ("nneething" none address prompt-address physical-address)
@@ -1137,8 +1429,15 @@ slower."
      ("nnfolder" mail respool address)
      ("nngateway" post-mail address prompt-address physical-address)
      ("nnweb" none)
      ("nnfolder" mail respool address)
      ("nngateway" post-mail address prompt-address physical-address)
      ("nnweb" none)
+    ("nnslashdot" post)
+    ("nnultimate" none)
+    ("nnrss" none)
+    ("nnwfm" none)
+    ("nnwarchive" none)
      ("nnlistserv" none)
      ("nnlistserv" none)
-    ("nnagent" post-mail))
+    ("nnagent" post-mail)
+    ("nnimap" post-mail address prompt-address physical-address)
+    ("nnmaildir" mail respool address))
    "*An alist of valid select methods.
  The first element of each list lists should be a string with the name
  of the select method.  The other elements may be the category of
    "*An alist of valid select methods.
  The first element of each list lists should be a string with the name
  of the select method.  The other elements may be the category of
@@ -1159,18 +1458,27 @@ this variable.  I think."
                                    (const :format "%v " virtual)
                                    (const respool)))))
  
                                    (const :format "%v " virtual)
                                    (const respool)))))
  
-(define-widget 'gnus-select-method 'list
-  "Widget for entering a select method."
-  :args `((choice :tag "Method"
-                 ,@(mapcar (lambda (entry)
-                             (list 'const :format "%v\n"
-                                   (intern (car entry))))
-                           gnus-valid-select-methods))
-         (string :tag "Address")
-         (editable-list  :inline t
-                         (list :format "%v"
-                               variable
-                               (sexp :tag "Value")))))
+(defun gnus-redefine-select-method-widget ()
+  "Recomputes the select-method widget based on the value of
+`gnus-valid-select-methods'."
+  (define-widget 'gnus-select-method 'list
+    "Widget for entering a select method."
+    :value '(nntp "")
+    :tag "Select Method"
+    :args `((choice :tag "Method"
+                   ,@(mapcar (lambda (entry)
+                               (list 'const :format "%v\n"
+                                     (intern (car entry))))
+                             gnus-valid-select-methods)
+                   (symbol :tag "other"))
+           (string :tag "Address")
+           (repeat :tag "Options"
+                   :inline t
+                   (list :format "%v"
+                         variable
+                         (sexp :tag "Value"))))))
+
+(gnus-redefine-select-method-widget)
  
  (defcustom gnus-updated-mode-lines '(group article summary tree)
    "List of buffers that should update their mode lines.
  
  (defcustom gnus-updated-mode-lines '(group article summary tree)
    "List of buffers that should update their mode lines.
@@ -1194,23 +1502,144 @@ to be desirable; see the manual for further details."
    :type '(choice (const nil)
                  integer))
  
    :type '(choice (const nil)
                  integer))
  
-(defcustom gnus-auto-expirable-newsgroups nil
-  "*Groups in which to automatically mark read articles as expirable.
+;; There should be special validation for this.
+(define-widget 'gnus-email-address 'string
+  "An email address")
+
+(gnus-define-group-parameter
+ to-address
+ :function-document
+ "Return GROUP's to-address."
+ :variable-document
+ "*Alist of group regexps and correspondent to-addresses."
+ :parameter-type '(gnus-email-address :tag "To Address")
+ :parameter-document "\
+This will be used when doing followups and posts.
+
+This is primarily useful in mail groups that represent closed
+mailing lists--mailing lists where it's expected that everybody that
+writes to the mailing list is subscribed to it.  Since using this
+parameter ensures that the mail only goes to the mailing list itself,
+it means that members won't receive two copies of your followups.
+
+Using `to-address' will actually work whether the group is foreign or
+not.  Let's say there's a group on the server that is called
+`fa.4ad-l'.  This is a real newsgroup, but the server has gotten the
+articles from a mail-to-news gateway.  Posting directly to this group
+is therefore impossible--you have to send mail to the mailing list
+address instead.
+
+The gnus-group-split mail splitting mechanism will behave as if this
+address was listed in gnus-group-split Addresses (see below).")
+
+(gnus-define-group-parameter
+ to-list
+ :function-document
+ "Return GROUP's to-list."
+ :variable-document
+ "*Alist of group regexps and correspondent to-lists."
+ :parameter-type '(gnus-email-address :tag "To List")
+ :parameter-document "\
+This address will be used when doing a `a' in the group.
+
+It is totally ignored when doing a followup--except that if it is
+present in a news group, you'll get mail group semantics when doing
+`f'.
+
+The gnus-group-split mail splitting mechanism will behave as if this
+address was listed in gnus-group-split Addresses (see below).")
+
+(gnus-define-group-parameter
+ auto-expire
+ :type bool
+ :function gnus-group-auto-expirable-p
+ :function-document
+ "Check whether GROUP is auto-expirable or not."
+ :variable gnus-auto-expirable-newsgroups
+ :variable-default nil
+ :variable-document
+ "*Groups in which to automatically mark read articles as expirable.
  If non-nil, this should be a regexp that should match all groups in
  which to perform auto-expiry.  This only makes sense for mail groups."
  If non-nil, this should be a regexp that should match all groups in
  which to perform auto-expiry.  This only makes sense for mail groups."
-  :group 'nnmail-expire
-  :type '(choice (const nil)
-                regexp))
-
-(defcustom gnus-total-expirable-newsgroups nil
-  "*Groups in which to perform expiry of all read articles.
+ :variable-group nnmail-expire
+ :variable-type '(choice (const nil)
+                        regexp)
+ :parameter-type '(const :tag "Automatic Expire" t)
+ :parameter-document
+ "All articles that are read will be marked as expirable.")
+
+(gnus-define-group-parameter
+ total-expire
+ :type bool
+ :function gnus-group-total-expirable-p
+ :function-document
+ "Check whether GROUP is total-expirable or not."
+ :variable gnus-total-expirable-newsgroups
+ :variable-default nil
+ :variable-document
+ "*Groups in which to perform expiry of all read articles.
  Use with extreme caution.  All groups that match this regexp will be
  expiring - which means that all read articles will be deleted after
  \(say) one week.        (This only goes for mail groups and the like, of
  course.)"
  Use with extreme caution.  All groups that match this regexp will be
  expiring - which means that all read articles will be deleted after
  \(say) one week.        (This only goes for mail groups and the like, of
  course.)"
-  :group 'nnmail-expire
-  :type '(choice (const nil)
-                regexp))
+ :variable-group nnmail-expire
+ :variable-type '(choice (const nil)
+                        regexp)
+ :parameter-type '(const :tag "Total Expire" t)
+ :parameter-document
+ "All read articles will be put through the expiry process
+
+This happens even if they are not marked as expirable.
+Use with caution.")
+
+(gnus-define-group-parameter
+ charset
+ :function-document
+ "Return the default charset of GROUP."
+ :variable gnus-group-charset-alist
+ :variable-default
+ '(("\\(^\\|:\\)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))
+ :variable-document
+ "Alist of regexps (to match group names) and default charsets to be used when reading."
+ :variable-group gnus-charset
+ :variable-type '(repeat (list (regexp :tag "Group")
+                              (symbol :tag "Charset")))
+ :parameter-type '(symbol :tag "Charset")
+ :parameter-document "\
+The default charset to use in the group.")
+
+(gnus-define-group-parameter
+ post-method
+ :type list
+ :function-document
+ "Return a posting method for GROUP."
+ :variable gnus-post-method-alist
+ :variable-document
+ "Alist of regexps (to match group names) and method to be used when
+posting an article."
+ :variable-group gnus-group-foreign
+ :parameter-type
+ '(choice :tag "Posting Method"
+         (const :tag "Use native server" native)
+         (const :tag "Use current server" current)
+         (list :convert-widget
+               (lambda (widget)
+                 (list 'sexp :tag "Methods"
+                       :value gnus-select-method))))
+ :parameter-document
+ "Posting method for this group.")
  
  (defcustom gnus-group-uncollapsed-levels 1
    "Number of group name elements to leave alone when making a short group name."
  
  (defcustom gnus-group-uncollapsed-levels 1
    "Number of group name elements to leave alone when making a short group name."
@@ -1253,7 +1682,7 @@ following hook:
  (defcustom gnus-group-change-level-function nil
    "Function run when a group level is changed.
  It is called with three parameters -- GROUP, LEVEL and OLDLEVEL."
  (defcustom gnus-group-change-level-function nil
    "Function run when a group level is changed.
  It is called with three parameters -- GROUP, LEVEL and OLDLEVEL."
-  :group 'gnus-group-level
+  :group 'gnus-group-levels
    :type 'function)
  
  ;;; Face thingies.
    :type 'function)
  
  ;;; Face thingies.
@@ -1301,6 +1730,18 @@ and `grouplens-menu'."
               (const pick-menu)
               (const grouplens-menu)))
  
               (const pick-menu)
               (const grouplens-menu)))
  
+;; Byte-compiler warning.
+(defvar gnus-visual)
+;; Find out whether the gnus-visual TYPE is wanted.
+(defun gnus-visual-p (&optional type class)
+  (and gnus-visual                     ; Has to be non-nil, at least.
+       (if (not type)                  ; We don't care about type.
+          gnus-visual
+        (if (listp gnus-visual)        ; It's a list, so we check it.
+            (or (memq type gnus-visual)
+                (memq class gnus-visual))
+          t))))
+
  (defcustom gnus-mouse-face
    (condition-case ()
        (if (gnus-visual-p 'mouse-face 'highlight)
  (defcustom gnus-mouse-face
    (condition-case ()
        (if (gnus-visual-p 'mouse-face 'highlight)
@@ -1315,60 +1756,6 @@ face."
    :group 'gnus-visual
    :type 'face)
  
    :group 'gnus-visual
    :type 'face)
  
-(defcustom gnus-article-display-hook
-  (if (and (string-match "XEmacs" emacs-version)
-          (featurep 'xface))
-      '(gnus-article-hide-headers-if-wanted
-       gnus-article-hide-boring-headers
-       gnus-article-treat-overstrike
-       gnus-article-maybe-highlight
-       gnus-article-display-x-face)
-    '(gnus-article-hide-headers-if-wanted
-      gnus-article-hide-boring-headers
-      gnus-article-treat-overstrike
-      gnus-article-maybe-highlight))
-  "*Controls how the article buffer will look.
-
-If you leave the list empty, the article will appear exactly as it is
-stored on the disk.  The list entries will hide or highlight various
-parts of the article, making it easier to find the information you
-want."
-  :group 'gnus-article-highlight
-  :group 'gnus-visual
-  :type 'hook
-  :options '(gnus-article-add-buttons
-            gnus-article-add-buttons-to-head
-            gnus-article-emphasize
-            gnus-article-fill-cited-article
-            gnus-article-remove-cr
-            gnus-article-de-quoted-unreadable
-            gnus-summary-stop-page-breaking
-            ;; gnus-summary-caesar-message
-            ;; gnus-summary-verbose-headers
-            gnus-summary-toggle-mime
-            gnus-article-hide
-            gnus-article-hide-headers
-            gnus-article-hide-boring-headers
-            gnus-article-hide-signature
-            gnus-article-hide-citation
-            gnus-article-hide-pgp
-            gnus-article-hide-pem
-            gnus-article-highlight
-            gnus-article-highlight-headers
-            gnus-article-highlight-citation
-            gnus-article-highlight-signature
-            gnus-article-date-ut
-            gnus-article-date-local
-            gnus-article-date-lapsed
-            gnus-article-date-original
-            gnus-article-remove-trailing-blank-lines
-            gnus-article-strip-leading-blank-lines
-            gnus-article-strip-multiple-blank-lines
-            gnus-article-strip-blank-lines
-            gnus-article-treat-overstrike
-            gnus-article-display-x-face
-            gnus-smiley-display))
-
  (defcustom gnus-article-save-directory gnus-directory
    "*Name of the directory articles will be saved in (default \"~/News\")."
    :group 'gnus-article-saving
  (defcustom gnus-article-save-directory gnus-directory
    "*Name of the directory articles will be saved in (default \"~/News\")."
    :group 'gnus-article-saving
@@ -1377,9 +1764,23 @@ want."
  (defvar gnus-plugged t
    "Whether Gnus is plugged or not.")
  
  (defvar gnus-plugged t
    "Whether Gnus is plugged or not.")
  
+(defvar gnus-agent-cache t
+  "Whether Gnus use agent cache.")
+
+(defcustom gnus-default-charset 'iso-8859-1
+  "Default charset assumed to be used when viewing non-ASCII characters.
+This variable is overridden on a group-to-group basis by the
+gnus-group-charset-alist variable and is only used on groups not
+covered by that variable."
+  :type 'symbol
+  :group 'gnus-charset)
+
  \f
  ;;; Internal variables
  
  \f
  ;;; Internal variables
  
+(defvar gnus-agent-gcc-header "X-Gnus-Agent-Gcc")
+(defvar gnus-agent-meta-information-header "X-Gnus-Agent-Meta-Information")
+(defvar gnus-draft-meta-information-header "X-Draft-From")
  (defvar gnus-group-get-parameter-function 'gnus-group-get-parameter)
  (defvar gnus-original-article-buffer " *Original Article*")
  (defvar gnus-newsgroup-name nil)
  (defvar gnus-group-get-parameter-function 'gnus-group-get-parameter)
  (defvar gnus-original-article-buffer " *Original Article*")
  (defvar gnus-newsgroup-name nil)
@@ -1388,6 +1789,11 @@ want."
  (defvar gnus-agent nil
    "Whether we want to use the Gnus agent or not.")
  
  (defvar gnus-agent nil
    "Whether we want to use the Gnus agent or not.")
  
+(defvar gnus-agent-fetching nil
+  "Whether Gnus agent is in fetching mode.")
+
+(defvar gnus-agent-covered-methods nil)
+
  (defvar gnus-command-method nil
    "Dynamically bound variable that says what the current backend is.")
  
  (defvar gnus-command-method nil
    "Dynamically bound variable that says what the current backend is.")
  
@@ -1420,11 +1826,11 @@ want."
  
  (defvar gnus-predefined-server-alist
    `(("cache"
  
  (defvar gnus-predefined-server-alist
    `(("cache"
-     (nnspool "cache"
-             (nnspool-spool-directory gnus-cache-directory)
-             (nnspool-nov-directory gnus-cache-directory)
-             (nnspool-active-file
-              (nnheader-concat gnus-cache-directory "active")))))
+     nnspool "cache"
+     (nnspool-spool-directory ,gnus-cache-directory)
+     (nnspool-nov-directory ,gnus-cache-directory)
+     (nnspool-active-file
+      ,(nnheader-concat gnus-cache-directory "active"))))
    "List of predefined (convenience) servers.")
  
  (defvar gnus-topic-indentation "") ;; Obsolete variable.
    "List of predefined (convenience) servers.")
  
  (defvar gnus-topic-indentation "") ;; Obsolete variable.
@@ -1435,7 +1841,27 @@ want."
      (bookmarks . bookmark) (dormant . dormant)
      (scored . score) (saved . save)
      (cached . cache) (downloadable . download)
      (bookmarks . bookmark) (dormant . dormant)
      (scored . score) (saved . save)
      (cached . cache) (downloadable . download)
-    (unsendable . unsend)))
+    (unsendable . unsend) (forwarded . forward)
+    (recent . recent) (seen . seen)))
+
+(defconst gnus-article-special-mark-lists
+  '((seen range)
+    (killed range)
+    (bookmark tuple)
+    (score tuple)))
+
+;; Propagate flags to server, with the following exceptions:
+;; `seen' is private to each gnus installation
+;; `cache' is a internal gnus flag for each gnus installation
+;; `download' is a agent flag private to each gnus installation
+;; `unsend' are for nndraft groups only
+;; `score' is not a proper mark
+(defconst gnus-article-unpropagated-mark-lists
+  '(seen cache download unsend score)
+  "Marks that shouldn't be propagated to backends.
+Typical marks are those that make no sense in a standalone backend,
+such as a mark that says whether an article is stored in the cache
+(which doesn't make sense in a standalone backend).")
  
  (defvar gnus-headers-retrieved-by nil)
  (defvar gnus-article-reply nil)
  
  (defvar gnus-headers-retrieved-by nil)
  (defvar gnus-article-reply nil)
@@ -1452,11 +1878,10 @@ want."
    "The mail address of the Gnus maintainers.")
  
  (defvar gnus-info-nodes
    "The mail address of the Gnus maintainers.")
  
  (defvar gnus-info-nodes
-  '((gnus-group-mode "(gnus)The Group Buffer")
-    (gnus-summary-mode "(gnus)The Summary Buffer")
-    (gnus-article-mode "(gnus)The Article Buffer")
-    (mime/viewer-mode "(gnus)The Article Buffer")
-    (gnus-server-mode "(gnus)The Server Buffer")
+  '((gnus-group-mode "(gnus)Group Buffer")
+    (gnus-summary-mode "(gnus)Summary Buffer")
+    (gnus-article-mode "(gnus)Article Buffer")
+    (gnus-server-mode "(gnus)Server Buffer")
      (gnus-browse-mode "(gnus)Browse Foreign Server")
      (gnus-tree-mode "(gnus)Tree Display"))
    "Alist of major modes and related Info nodes.")
      (gnus-browse-mode "(gnus)Browse Foreign Server")
      (gnus-tree-mode "(gnus)Tree Display"))
    "Alist of major modes and related Info nodes.")
@@ -1466,9 +1891,6 @@ want."
  (defvar gnus-article-buffer "*Article*")
  (defvar gnus-server-buffer "*Server*")
  
  (defvar gnus-article-buffer "*Article*")
  (defvar gnus-server-buffer "*Server*")
  
-(defvar gnus-buffer-list nil
-  "Gnus buffers that should be killed on exit.")
-
  (defvar gnus-slave nil
    "Whether this Gnus is a slave or not.")
  
  (defvar gnus-slave nil
    "Whether this Gnus is a slave or not.")
  
@@ -1477,11 +1899,11 @@ want."
  
  (defvar gnus-variable-list
    '(gnus-newsrc-options gnus-newsrc-options-n
  
  (defvar gnus-variable-list
    '(gnus-newsrc-options gnus-newsrc-options-n
-    gnus-newsrc-last-checked-date
-    gnus-newsrc-alist gnus-server-alist
-    gnus-killed-list gnus-zombie-list
-    gnus-topic-topology gnus-topic-alist
-    gnus-format-specs)
+                       gnus-newsrc-last-checked-date
+                       gnus-newsrc-alist gnus-server-alist
+                       gnus-killed-list gnus-zombie-list
+                       gnus-topic-topology gnus-topic-alist
+                       gnus-format-specs)
    "Gnus variables saved in the quick startup file.")
  
  (defvar gnus-newsrc-alist nil
    "Gnus variables saved in the quick startup file.")
  
  (defvar gnus-newsrc-alist nil
@@ -1522,6 +1944,9 @@ gnus-newsrc-hashtb should be kept so that both hold the same information.")
  
  (defvar gnus-dead-summary nil)
  
  
  (defvar gnus-dead-summary nil)
  
+(defvar gnus-invalid-group-regexp "[: `'\"/]\\|^$"
+  "Regexp matching invalid groups.")
+
  ;;; End of variables.
  
  ;; Define some autoload functions Gnus might use.
  ;;; End of variables.
  
  ;; Define some autoload functions Gnus might use.
@@ -1538,26 +1963,24 @@ gnus-newsrc-hashtb should be kept so that both hold the same information.")
             (when (consp function)
               (setq keymap (car (memq 'keymap function)))
               (setq function (car function)))
             (when (consp function)
               (setq keymap (car (memq 'keymap function)))
               (setq function (car function)))
-           (autoload function (car package) nil interactive keymap)))
+           (unless (fboundp function)
+             (autoload function (car package) nil interactive keymap))))
         (if (eq (nth 1 package) ':interactive)
         (if (eq (nth 1 package) ':interactive)
-           (cdddr package)
+           (nthcdr 3 package)
           (cdr package)))))
           (cdr package)))))
-   '(("metamail" metamail-buffer)
-     ("info" Info-goto-node)
-     ("hexl" hexl-hex-string-to-integer)
-     ("pp" pp pp-to-string pp-eval-expression)
+   '(("info" :interactive t Info-goto-node)
+     ("pp" pp-to-string)
+     ("qp" quoted-printable-decode-region quoted-printable-decode-string)
       ("ps-print" ps-print-preprint)
       ("ps-print" ps-print-preprint)
-     ("mail-extr" mail-extract-address-components)
-     ("browse-url" browse-url)
       ("message" :interactive t
        message-send-and-exit message-yank-original)
       ("message" :interactive t
        message-send-and-exit message-yank-original)
-     ("nnmail" nnmail-split-fancy nnmail-article-group nnmail-date-to-time)
+     ("babel" babel-as-string)
+     ("nnmail" nnmail-split-fancy nnmail-article-group)
       ("nnvirtual" nnvirtual-catchup-group nnvirtual-convert-headers)
       ("nnvirtual" nnvirtual-catchup-group nnvirtual-convert-headers)
-     ("timezone" timezone-make-date-arpa-standard timezone-fix-time
-      timezone-make-sortable-date timezone-make-time-string)
-     ("rmailout" rmail-output)
+     ("rmailout" rmail-output rmail-output-to-rmail-file)
       ("rmail" rmail-insert-rmail-file-header rmail-count-new-messages
       ("rmail" rmail-insert-rmail-file-header rmail-count-new-messages
-      rmail-show-message)
+      rmail-show-message rmail-summary-exists
+      rmail-select-summary rmail-update-summary)
       ("gnus-audio" :interactive t gnus-audio-play)
       ("gnus-xmas" gnus-xmas-splash)
       ("gnus-soup" :interactive t
       ("gnus-audio" :interactive t gnus-audio-play)
       ("gnus-xmas" gnus-xmas-splash)
       ("gnus-soup" :interactive t
@@ -1574,6 +1997,8 @@ gnus-newsrc-hashtb should be kept so that both hold the same information.")
        gnus-demon-remove-handler)
       ("gnus-demon" :interactive t
        gnus-demon-init gnus-demon-cancel)
        gnus-demon-remove-handler)
       ("gnus-demon" :interactive t
        gnus-demon-init gnus-demon-cancel)
+     ("gnus-fun" gnus-convert-gray-x-face-to-xpm gnus-display-x-face-in-from
+      gnus-convert-image-to-gray-x-face)
       ("gnus-salt" gnus-highlight-selected-tree gnus-possibly-generate-tree
        gnus-tree-open gnus-tree-close gnus-carpal-setup-buffer)
       ("gnus-nocem" gnus-nocem-scan-groups gnus-nocem-close
       ("gnus-salt" gnus-highlight-selected-tree gnus-possibly-generate-tree
        gnus-tree-open gnus-tree-close gnus-carpal-setup-buffer)
       ("gnus-nocem" gnus-nocem-scan-groups gnus-nocem-close
@@ -1587,31 +2012,33 @@ gnus-newsrc-hashtb should be kept so that both hold the same information.")
        gnus-article-hide-citation-in-followups)
       ("gnus-kill" gnus-kill gnus-apply-kill-file-internal
        gnus-kill-file-edit-file gnus-kill-file-raise-followups-to-author
        gnus-article-hide-citation-in-followups)
       ("gnus-kill" gnus-kill gnus-apply-kill-file-internal
        gnus-kill-file-edit-file gnus-kill-file-raise-followups-to-author
-      gnus-execute gnus-expunge)
+      gnus-execute gnus-expunge gnus-batch-kill gnus-batch-score)
       ("gnus-cache" gnus-cache-possibly-enter-article gnus-cache-save-buffers
        gnus-cache-possibly-remove-articles gnus-cache-request-article
        gnus-cache-retrieve-headers gnus-cache-possibly-alter-active
        gnus-cache-enter-remove-article gnus-cached-article-p
       ("gnus-cache" gnus-cache-possibly-enter-article gnus-cache-save-buffers
        gnus-cache-possibly-remove-articles gnus-cache-request-article
        gnus-cache-retrieve-headers gnus-cache-possibly-alter-active
        gnus-cache-enter-remove-article gnus-cached-article-p
-      gnus-cache-open gnus-cache-close gnus-cache-update-article)
-      ("gnus-cache" :interactive t gnus-jog-cache gnus-cache-enter-article
-       gnus-cache-remove-article gnus-summary-insert-cached-articles)
-      ("gnus-score" :interactive t
-       gnus-summary-increase-score gnus-summary-set-score
-       gnus-summary-raise-thread gnus-summary-raise-same-subject
-       gnus-summary-raise-score gnus-summary-raise-same-subject-and-select
-       gnus-summary-lower-thread gnus-summary-lower-same-subject
-       gnus-summary-lower-score gnus-summary-lower-same-subject-and-select
-       gnus-summary-current-score gnus-score-default
-       gnus-score-flush-cache gnus-score-close
-       gnus-possibly-score-headers gnus-score-followup-article
-       gnus-score-followup-thread)
-      ("gnus-score"
-       (gnus-summary-score-map keymap) gnus-score-save gnus-score-headers
+      gnus-cache-open gnus-cache-close gnus-cache-update-article
+      gnus-cache-articles-in-group)
+     ("gnus-cache" :interactive t gnus-jog-cache gnus-cache-enter-article
+      gnus-cache-remove-article gnus-summary-insert-cached-articles)
+     ("gnus-score" :interactive t
+      gnus-summary-increase-score gnus-summary-set-score
+      gnus-summary-raise-thread gnus-summary-raise-same-subject
+      gnus-summary-raise-score gnus-summary-raise-same-subject-and-select
+      gnus-summary-lower-thread gnus-summary-lower-same-subject
+      gnus-summary-lower-score gnus-summary-lower-same-subject-and-select
+      gnus-summary-current-score gnus-score-delta-default
+      gnus-score-flush-cache gnus-score-close
+      gnus-possibly-score-headers gnus-score-followup-article
+      gnus-score-followup-thread)
+     ("gnus-score"
+      (gnus-summary-score-map keymap) gnus-score-save gnus-score-headers
        gnus-current-score-file-nondirectory gnus-score-adaptive
        gnus-score-find-trace gnus-score-file-name)
       ("gnus-cus" :interactive t gnus-group-customize gnus-score-customize)
       ("gnus-topic" :interactive t gnus-topic-mode)
        gnus-current-score-file-nondirectory gnus-score-adaptive
        gnus-score-find-trace gnus-score-file-name)
       ("gnus-cus" :interactive t gnus-group-customize gnus-score-customize)
       ("gnus-topic" :interactive t gnus-topic-mode)
-     ("gnus-topic" gnus-topic-remove-group gnus-topic-set-parameters)
+     ("gnus-topic" gnus-topic-remove-group gnus-topic-set-parameters
+      gnus-subscribe-topics)
       ("gnus-salt" :interactive t gnus-pick-mode gnus-binary-mode)
       ("gnus-uu" (gnus-uu-extract-map keymap) (gnus-uu-mark-map keymap))
       ("gnus-uu" :interactive t
       ("gnus-salt" :interactive t gnus-pick-mode gnus-binary-mode)
       ("gnus-uu" (gnus-uu-extract-map keymap) (gnus-uu-mark-map keymap))
       ("gnus-uu" :interactive t
@@ -1624,25 +2051,28 @@ gnus-newsrc-hashtb should be kept so that both hold the same information.")
        gnus-uu-decode-binhex gnus-uu-decode-uu-view
        gnus-uu-decode-uu-and-save-view gnus-uu-decode-unshar-view
        gnus-uu-decode-unshar-and-save-view gnus-uu-decode-save-view
        gnus-uu-decode-binhex gnus-uu-decode-uu-view
        gnus-uu-decode-uu-and-save-view gnus-uu-decode-unshar-view
        gnus-uu-decode-unshar-and-save-view gnus-uu-decode-save-view
-      gnus-uu-decode-binhex-view gnus-uu-unmark-thread)
-     ("gnus-uu" gnus-uu-delete-work-dir gnus-quote-arg-for-sh-or-csh
-      gnus-uu-unmark-thread)
+      gnus-uu-decode-binhex-view gnus-uu-unmark-thread
+      gnus-uu-mark-over gnus-uu-post-news)
+     ("gnus-uu" gnus-uu-delete-work-dir gnus-uu-unmark-thread)
       ("gnus-msg" (gnus-summary-send-map keymap)
        gnus-article-mail gnus-copy-article-buffer gnus-extended-version)
       ("gnus-msg" :interactive t
       ("gnus-msg" (gnus-summary-send-map keymap)
        gnus-article-mail gnus-copy-article-buffer gnus-extended-version)
       ("gnus-msg" :interactive t
-      gnus-group-post-news gnus-group-mail gnus-summary-post-news
+      gnus-group-post-news gnus-group-mail gnus-group-news
+      gnus-summary-post-news gnus-summary-news-other-window
        gnus-summary-followup gnus-summary-followup-with-original
        gnus-summary-cancel-article gnus-summary-supersede-article
        gnus-post-news gnus-summary-reply gnus-summary-reply-with-original
        gnus-summary-mail-forward gnus-summary-mail-other-window
        gnus-summary-resend-message gnus-summary-resend-bounced-mail
        gnus-summary-followup gnus-summary-followup-with-original
        gnus-summary-cancel-article gnus-summary-supersede-article
        gnus-post-news gnus-summary-reply gnus-summary-reply-with-original
        gnus-summary-mail-forward gnus-summary-mail-other-window
        gnus-summary-resend-message gnus-summary-resend-bounced-mail
-      gnus-bug)
-     ("gnus-picon" :interactive t gnus-article-display-picons
-      gnus-group-display-picons gnus-picons-article-display-x-face
-      gnus-picons-display-x-face)
+      gnus-summary-wide-reply gnus-summary-followup-to-mail
+      gnus-summary-followup-to-mail-with-original gnus-bug
+      gnus-summary-wide-reply-with-original
+      gnus-summary-post-forward gnus-summary-wide-reply-with-original
+      gnus-summary-post-forward)
+     ("gnus-picon" :interactive t gnus-treat-from-picon)
       ("gnus-gl" bbb-login bbb-logout bbb-grouplens-group-p
        gnus-grouplens-mode)
       ("gnus-gl" bbb-login bbb-logout bbb-grouplens-group-p
        gnus-grouplens-mode)
-     ("smiley" :interactive t gnus-smiley-display)
+     ("smiley" :interactive t smiley-region)
       ("gnus-win" gnus-configure-windows gnus-add-configuration)
       ("gnus-sum" gnus-summary-insert-line gnus-summary-read-group
        gnus-list-of-unread-articles gnus-list-of-read-articles
       ("gnus-win" gnus-configure-windows gnus-add-configuration)
       ("gnus-sum" gnus-summary-insert-line gnus-summary-read-group
        gnus-list-of-unread-articles gnus-list-of-read-articles
@@ -1655,8 +2085,7 @@ gnus-newsrc-hashtb should be kept so that both hold the same information.")
        gnus-group-set-mode-line gnus-group-set-info gnus-group-save-newsrc
        gnus-group-setup-buffer gnus-group-get-new-news
        gnus-group-make-help-group gnus-group-update-group
        gnus-group-set-mode-line gnus-group-set-info gnus-group-save-newsrc
        gnus-group-setup-buffer gnus-group-get-new-news
        gnus-group-make-help-group gnus-group-update-group
-      gnus-clear-inboxes-moved gnus-group-iterate
-      gnus-group-group-name)
+      gnus-group-iterate gnus-group-group-name)
       ("gnus-bcklg" gnus-backlog-request-article gnus-backlog-enter-article
        gnus-backlog-remove-article)
       ("gnus-art" gnus-article-read-summary-keys gnus-article-save
       ("gnus-bcklg" gnus-backlog-request-article gnus-backlog-enter-article
        gnus-backlog-remove-article)
       ("gnus-art" gnus-article-read-summary-keys gnus-article-save
@@ -1664,23 +2093,27 @@ gnus-newsrc-hashtb should be kept so that both hold the same information.")
        gnus-article-next-page gnus-article-prev-page
        gnus-request-article-this-buffer gnus-article-mode
        gnus-article-setup-buffer gnus-narrow-to-page
        gnus-article-next-page gnus-article-prev-page
        gnus-request-article-this-buffer gnus-article-mode
        gnus-article-setup-buffer gnus-narrow-to-page
-      gnus-article-delete-invisible-text gnus-hack-decode-rfc1522)
+      gnus-article-delete-invisible-text gnus-treat-article)
       ("gnus-art" :interactive t
        gnus-article-hide-headers gnus-article-hide-boring-headers
       ("gnus-art" :interactive t
        gnus-article-hide-headers gnus-article-hide-boring-headers
-      gnus-article-treat-overstrike gnus-article-word-wrap
+      gnus-article-treat-overstrike
        gnus-article-remove-cr gnus-article-remove-trailing-blank-lines
        gnus-article-display-x-face gnus-article-de-quoted-unreadable
        gnus-article-remove-cr gnus-article-remove-trailing-blank-lines
        gnus-article-display-x-face gnus-article-de-quoted-unreadable
-      gnus-article-mime-decode-quoted-printable gnus-article-hide-pgp
+      gnus-article-de-base64-unreadable
+      gnus-article-decode-HZ
+      gnus-article-wash-html
+      gnus-article-hide-pgp
        gnus-article-hide-pem gnus-article-hide-signature
        gnus-article-strip-leading-blank-lines gnus-article-date-local
        gnus-article-date-original gnus-article-date-lapsed
        gnus-article-hide-pem gnus-article-hide-signature
        gnus-article-strip-leading-blank-lines gnus-article-date-local
        gnus-article-date-original gnus-article-date-lapsed
-      gnus-article-show-all-headers
+;;      gnus-article-show-all-headers
        gnus-article-edit-mode gnus-article-edit-article
        gnus-article-edit-mode gnus-article-edit-article
-      gnus-article-edit-done gnus-decode-rfc1522 article-decode-rfc1522
-      gnus-start-date-timer gnus-stop-date-timer)
+      gnus-article-edit-done gnus-article-decode-encoded-words
+      gnus-start-date-timer gnus-stop-date-timer
+      gnus-mime-view-all-parts)
       ("gnus-int" gnus-request-type)
       ("gnus-start" gnus-newsrc-parse-options gnus-1 gnus-no-server-1
       ("gnus-int" gnus-request-type)
       ("gnus-start" gnus-newsrc-parse-options gnus-1 gnus-no-server-1
-      gnus-dribble-enter gnus-read-init-file)
+      gnus-dribble-enter gnus-read-init-file gnus-dribble-touch)
       ("gnus-dup" gnus-dup-suppress-articles gnus-dup-unsuppress-article
        gnus-dup-enter-articles)
       ("gnus-range" gnus-copy-sequence)
       ("gnus-dup" gnus-dup-suppress-articles gnus-dup-unsuppress-article
        gnus-dup-enter-articles)
       ("gnus-range" gnus-copy-sequence)
@@ -1695,17 +2128,22 @@ gnus-newsrc-hashtb should be kept so that both hold the same information.")
       ("gnus-agent" gnus-open-agent gnus-agent-get-function
        gnus-agent-save-groups gnus-agent-save-active gnus-agent-method-p
        gnus-agent-get-undownloaded-list gnus-agent-fetch-session
       ("gnus-agent" gnus-open-agent gnus-agent-get-function
        gnus-agent-save-groups gnus-agent-save-active gnus-agent-method-p
        gnus-agent-get-undownloaded-list gnus-agent-fetch-session
-      gnus-summary-set-agent-mark gnus-agent-save-group-info)
+      gnus-summary-set-agent-mark gnus-agent-save-group-info
+      gnus-agent-request-article gnus-agent-retrieve-headers)
       ("gnus-agent" :interactive t
        gnus-unplugged gnus-agentize gnus-agent-batch)
       ("gnus-vm" :interactive t gnus-summary-save-in-vm
        gnus-summary-save-article-vm)
       ("gnus-agent" :interactive t
        gnus-unplugged gnus-agentize gnus-agent-batch)
       ("gnus-vm" :interactive t gnus-summary-save-in-vm
        gnus-summary-save-article-vm)
-     ("gnus-draft" :interactive t gnus-draft-mode gnus-group-send-drafts))))
+     ("compface" uncompface)
+     ("gnus-draft" :interactive t gnus-draft-mode gnus-group-send-queue)
+     ("gnus-mlspl" gnus-group-split gnus-group-split-fancy)
+     ("gnus-mlspl" :interactive t gnus-group-split-setup
+      gnus-group-split-update))))
  
  ;;; gnus-sum.el thingies
  
  
  
  ;;; gnus-sum.el thingies
  
  
-(defcustom gnus-summary-line-format "%U%R%z%I%(%[%4L: %-20,20n%]%) %s\n"
+(defcustom gnus-summary-line-format "%U%R%z%I%(%[%4L: %-23,23f%]%) %s\n"
    "*The format specification of the lines in the summary buffer.
  
  It works along the same lines as a normal formatting string,
    "*The format specification of the lines in the summary buffer.
  
  It works along the same lines as a normal formatting string,
@@ -1718,14 +2156,18 @@ with some simple extensions.
  %a   Extracted name of the poster (string)
  %A   Extracted address of the poster (string)
  %F   Contents of the From: header (string)
  %a   Extracted name of the poster (string)
  %A   Extracted address of the poster (string)
  %F   Contents of the From: header (string)
+%f   Contents of the From: or To: headers (string)
  %x   Contents of the Xref: header (string)
  %D   Date of the article (string)
  %d   Date of the article (string) in DD-MMM format
  %x   Contents of the Xref: header (string)
  %D   Date of the article (string)
  %d   Date of the article (string) in DD-MMM format
+%o   Date of the article (string) in YYYYMMDD`T'HHMMSS format
  %M   Message-id of the article (string)
  %r   References of the article (string)
  %c   Number of characters in the article (integer)
  %L   Number of lines in the article (integer)
  %I   Indentation based on thread level (a string of spaces)
  %M   Message-id of the article (string)
  %r   References of the article (string)
  %c   Number of characters in the article (integer)
  %L   Number of lines in the article (integer)
  %I   Indentation based on thread level (a string of spaces)
+%B   A complex trn-style thread tree (string)
+     The variables `gnus-sum-thread-*' can be used for customization.
  %T   A string with two possible values: 80 spaces if the article
       is on thread level two or larger and 0 spaces on level one
  %R   \"A\" if this article has been replied to, \" \" otherwise (character)
  %T   A string with two possible values: 80 spaces if the article
       is on thread level two or larger and 0 spaces on level one
  %R   \"A\" if this article has been replied to, \" \" otherwise (character)
@@ -1749,21 +2191,21 @@ with some simple extensions.
       will be inserted into the summary just like information from any other
       summary specifier.
  
       will be inserted into the summary just like information from any other
       summary specifier.
  
-Text between %( and %) will be highlighted with `gnus-mouse-face'
-when the mouse point is placed inside the area.         There can only be one
-such area.
-
  The %U (status), %R (replied) and %z (zcore) specs have to be handled
  with care.  For reasons of efficiency, Gnus will compute what column
  these characters will end up in, and \"hard-code\" that.  This means that
  The %U (status), %R (replied) and %z (zcore) specs have to be handled
  with care.  For reasons of efficiency, Gnus will compute what column
  these characters will end up in, and \"hard-code\" that.  This means that
-it is illegal to have these specs after a variable-length spec.         Well,
+it is invalid to have these specs after a variable-length spec.         Well,
  you might not be arrested, but your summary buffer will look strange,
  which is bad enough.
  
  you might not be arrested, but your summary buffer will look strange,
  which is bad enough.
  
-The smart choice is to have these specs as for to the left as
+The smart choice is to have these specs as far to the left as
  possible.
  
  possible.
  
-This restriction may disappear in later versions of Gnus."
+This restriction may disappear in later versions of Gnus.
+
+General format specifiers can also be used.  
+See (gnus)Formatting Variables."
+  :link '(custom-manual "(gnus)Formatting Variables")
    :type 'string
    :group 'gnus-summary-format)
  
    :type 'string
    :group 'gnus-summary-format)
  
@@ -1778,7 +2220,7 @@ This restriction may disappear in later versions of Gnus."
        (define-key keymap (pop keys) 'undefined))))
  
  (defvar gnus-article-mode-map
        (define-key keymap (pop keys) 'undefined))))
  
  (defvar gnus-article-mode-map
-  (let ((keymap (make-keymap)))
+  (let ((keymap (make-sparse-keymap)))
      (gnus-suppress-keymap keymap)
      keymap))
  (defvar gnus-summary-mode-map
      (gnus-suppress-keymap keymap)
      keymap))
  (defvar gnus-summary-mode-map
@@ -1807,6 +2249,12 @@ This restriction may disappear in later versions of Gnus."
    "Get hash value of STRING in HASHTABLE."
    `(symbol-value (intern-soft ,string ,hashtable)))
  
    "Get hash value of STRING in HASHTABLE."
    `(symbol-value (intern-soft ,string ,hashtable)))
  
+(defmacro gnus-gethash-safe (string hashtable)
+  "Get hash value of STRING in HASHTABLE.
+Return nil if not defined."
+  `(let ((sym (intern-soft ,string ,hashtable)))
+     (and (boundp sym) (symbol-value sym))))
+
  (defmacro gnus-sethash (string value hashtable)
    "Set hash value.  Arguments are STRING, VALUE, and HASHTABLE."
    `(set (intern ,string ,hashtable) ,value))
  (defmacro gnus-sethash (string value hashtable)
    "Set hash value.  Arguments are STRING, VALUE, and HASHTABLE."
    `(set (intern ,string ,hashtable) ,value))
@@ -1892,18 +2340,6 @@ This restriction may disappear in later versions of Gnus."
  (defmacro gnus-get-info (group)
    `(nth 2 (gnus-gethash ,group gnus-newsrc-hashtb)))
  
  (defmacro gnus-get-info (group)
    `(nth 2 (gnus-gethash ,group gnus-newsrc-hashtb)))
  
-;; Byte-compiler warning.
-(defvar gnus-visual)
-;; Find out whether the gnus-visual TYPE is wanted.
-(defun gnus-visual-p (&optional type class)
-  (and gnus-visual                     ; Has to be non-nil, at least.
-       (if (not type)                  ; We don't care about type.
-          gnus-visual
-        (if (listp gnus-visual)        ; It's a list, so we check it.
-            (or (memq type gnus-visual)
-                (memq class gnus-visual))
-          t))))
-
  ;;; Load the compatability functions.
  
  (require 'gnus-ems)
  ;;; Load the compatability functions.
  
  (require 'gnus-ems)
@@ -1932,6 +2368,20 @@ This restriction may disappear in later versions of Gnus."
  ;;; Gnus Utility Functions
  ;;;
  
  ;;; Gnus Utility Functions
  ;;;
  
+(defun gnus-find-subscribed-addresses ()
+  "Return a regexp matching the addresses of all subscribed mail groups.
+It consists of the `to-address' or `to-list' parameter of all groups
+with a `subscribed' parameter."
+  (let (group address addresses)
+    (dolist (entry (cdr gnus-newsrc-alist))
+      (setq group (car entry))
+      (when (gnus-group-find-parameter group 'subscribed)
+       (setq address (or (gnus-group-fast-parameter group 'to-address)
+                         (gnus-group-fast-parameter group 'to-list)))
+       (when address
+         (push address addresses))))
+    (list (mapconcat 'regexp-quote addresses "\\|"))))
+
  (defmacro gnus-string-or (&rest strings)
    "Return the first element of STRINGS that is a non-blank string.
  STRINGS will be evaluated in normal `or' order."
  (defmacro gnus-string-or (&rest strings)
    "Return the first element of STRINGS that is a non-blank string.
  STRINGS will be evaluated in normal `or' order."
@@ -1946,61 +2396,51 @@ STRINGS will be evaluated in normal `or' order."
         (setq strings nil)))
      string))
  
         (setq strings nil)))
      string))
  
-;; Add the current buffer to the list of buffers to be killed on exit.
-(defun gnus-add-current-to-buffer-list ()
-  (or (memq (current-buffer) gnus-buffer-list)
-      (push (current-buffer) gnus-buffer-list)))
-
  (defun gnus-version (&optional arg)
    "Version number of this version of Gnus.
  If ARG, insert string at point."
    (interactive "P")
  (defun gnus-version (&optional arg)
    "Version number of this version of Gnus.
  If ARG, insert string at point."
    (interactive "P")
-  (let ((methods gnus-valid-select-methods)
-       (mess gnus-version)
-       meth)
-    ;; Go through all the legal select methods and add their version
-    ;; numbers to the total version string.  Only the backends that are
-    ;; currently in use will have their message numbers taken into
-    ;; consideration.
-    (while methods
-      (setq meth (intern (concat (caar methods) "-version")))
-      (and (boundp meth)
-          (stringp (symbol-value meth))
-          (setq mess (concat mess "; " (symbol-value meth))))
-      (setq methods (cdr methods)))
-    (if arg
-       (insert (message mess))
-      (message mess))))
+  (if arg
+      (insert (message gnus-version))
+    (message gnus-version)))
  
  
-(defun gnus-continuum-version (version)
+(defun gnus-continuum-version (&optional version)
    "Return VERSION as a floating point number."
    "Return VERSION as a floating point number."
+  (interactive)
+  (unless version
+    (setq version gnus-version))
    (when (or (string-match "^\\([^ ]+\\)? ?Gnus v?\\([0-9.]+\\)$" version)
             (string-match "^\\(.?\\)gnus-\\([0-9.]+\\)$" version))
    (when (or (string-match "^\\([^ ]+\\)? ?Gnus v?\\([0-9.]+\\)$" version)
             (string-match "^\\(.?\\)gnus-\\([0-9.]+\\)$" version))
-    (let* ((alpha (and (match-beginning 1) (match-string 1 version)))
-          (number (match-string 2 version))
-          major minor least)
-      (string-match "\\([0-9]\\)\\.\\([0-9]+\\)\\.?\\([0-9]+\\)?" number)
-      (setq major (string-to-number (match-string 1 number)))
-      (setq minor (string-to-number (match-string 2 number)))
-      (setq least (if (match-beginning 3)
+    (let ((alpha (and (match-beginning 1) (match-string 1 version)))
+         (number (match-string 2 version))
+         major minor least)
+      (unless (string-match
+              "\\([0-9]\\)\\.\\([0-9]+\\)\\.?\\([0-9]+\\)?" number)
+       (error "Invalid version string: %s" version))
+      (setq major (string-to-number (match-string 1 number))
+           minor (string-to-number (match-string 2 number))
+           least (if (match-beginning 3)
                       (string-to-number (match-string 3 number))
                     0))
        (string-to-number
         (if (zerop major)
                       (string-to-number (match-string 3 number))
                     0))
        (string-to-number
         (if (zerop major)
-          (format "%s00%02d%02d"
-                  (cond
-                   ((member alpha '("(ding)" "d")) "4.99")
-                   ((member alpha '("September" "s")) "5.01")
-                   ((member alpha '("Red" "r")) "5.03"))
-                  minor least)
+            (format "%s00%02d%02d"
+                    (if (member alpha '("(ding)" "d"))
+                        "4.99"
+                      (+ 5 (* 0.02
+                              (abs
+                               (- (mm-char-int (aref (downcase alpha) 0))
+                                  (mm-char-int ?t))))
+                         -0.01))
+                    minor least)
          (format "%d.%02d%02d" major minor least))))))
  
          (format "%d.%02d%02d" major minor least))))))
  
-(defun gnus-info-find-node ()
+(defun gnus-info-find-node (&optional nodename)
    "Find Info documentation of Gnus."
    (interactive)
    ;; Enlarge info window if needed.
    (let (gnus-info-buffer)
    "Find Info documentation of Gnus."
    (interactive)
    ;; Enlarge info window if needed.
    (let (gnus-info-buffer)
-    (Info-goto-node (cadr (assq major-mode gnus-info-nodes)))
+    (Info-goto-node (or nodename (cadr (assq major-mode gnus-info-nodes))))
      (setq gnus-info-buffer (current-buffer))
      (gnus-configure-windows 'info)))
  
      (setq gnus-info-buffer (current-buffer))
      (gnus-configure-windows 'info)))
  
@@ -2034,7 +2474,7 @@ g -- Group name."
         (setq prompt (match-string 1 string)))
        (setq i (match-end 0))
        ;; We basically emulate just about everything that
         (setq prompt (match-string 1 string)))
        (setq i (match-end 0))
        ;; We basically emulate just about everything that
-      ;; `interactive' does, but adds the "g" and "G" specs.
+      ;; `interactive' does, but add the specs listed above.
        (push
         (cond
         ((= c ?a)
        (push
         (cond
         ((= c ?a)
@@ -2101,8 +2541,8 @@ g -- Group name."
         out)
        (cond
         ((= c ?r)
         out)
        (cond
         ((= c ?r)
-       (push (if (< (point) (mark) (point) (mark))) out)
-       (push (if (> (point) (mark) (point) (mark))) out))))
+       (push (if (< (point) (mark)) (point) (mark)) out)
+       (push (if (> (point) (mark)) (point) (mark)) out))))
      (setq out (delq 'gnus-prefix-nil out))
      (nreverse out)))
  
      (setq out (delq 'gnus-prefix-nil out))
      (nreverse out)))
  
@@ -2142,30 +2582,6 @@ that that variable is buffer-local to the summary buffers."
    (let ((group (or group gnus-newsgroup-name)))
      (not (gnus-check-backend-function 'request-replace-article group))))
  
    (let ((group (or group gnus-newsgroup-name)))
      (not (gnus-check-backend-function 'request-replace-article group))))
  
-(defun gnus-group-total-expirable-p (group)
-  "Check whether GROUP is total-expirable or not."
-  (let ((params (gnus-group-find-parameter group))
-       val)
-    (cond
-     ((memq 'total-expire params)
-      t)
-     ((setq val (assq 'total-expire params)) ; (auto-expire . t)
-      (cdr val))
-     (gnus-total-expirable-newsgroups  ; Check var.
-      (string-match gnus-total-expirable-newsgroups group)))))
-
-(defun gnus-group-auto-expirable-p (group)
-  "Check whether GROUP is auto-expirable or not."
-  (let ((params (gnus-group-find-parameter group))
-       val)
-    (cond
-     ((memq 'auto-expire params)
-      t)
-     ((setq val (assq 'auto-expire params)) ; (auto-expire . t)
-      (cdr val))
-     (gnus-auto-expirable-newsgroups   ; Check var.
-      (string-match gnus-auto-expirable-newsgroups group)))))
-
  (defun gnus-virtual-group-p (group)
    "Say whether GROUP is virtual or not."
    (memq 'virtual (assoc (symbol-name (car (gnus-find-method-for-group group)))
  (defun gnus-virtual-group-p (group)
    "Say whether GROUP is virtual or not."
    (memq 'virtual (assoc (symbol-name (car (gnus-find-method-for-group group)))
@@ -2173,16 +2589,18 @@ that that variable is buffer-local to the summary buffers."
  
  (defun gnus-news-group-p (group &optional article)
    "Return non-nil if GROUP (and ARTICLE) come from a news server."
  
  (defun gnus-news-group-p (group &optional article)
    "Return non-nil if GROUP (and ARTICLE) come from a news server."
-  (or (gnus-member-of-valid 'post group) ; Ordinary news group.
-      (and (gnus-member-of-valid 'post-mail group) ; Combined group.
-          (if (or (null article)
-                  (not (< article 0)))
-              (eq (gnus-request-type group article) 'news)
-            (if (not (vectorp article))
-                nil
-              ;; It's a real article.
-              (eq (gnus-request-type group (mail-header-id article))
-                  'news))))))
+  (cond ((gnus-member-of-valid 'post group) ;Ordinary news group
+        t)                             ;is news of course.
+       ((not (gnus-member-of-valid 'post-mail group)) ;Non-combined.
+        nil)                           ;must be mail then.
+       ((vectorp article)              ;Has header info.
+        (eq (gnus-request-type group (mail-header-id article)) 'news))
+       ((null article)                 ;Hasn't header info
+        (eq (gnus-request-type group) 'news)) ;(unknown ==> mail)
+       ((< article 0)                  ;Virtual message
+        nil)                           ;we don't know, guess mail.
+       (t                              ;Has positive number
+        (eq (gnus-request-type group article) 'news)))) ;use it.
  
  ;; Returns a list of writable groups.
  (defun gnus-writable-groups ()
  
  ;; Returns a list of writable groups.
  (defun gnus-writable-groups ()
@@ -2251,9 +2669,11 @@ that that variable is buffer-local to the summary buffers."
          (gnus-server-to-method method))
         ((equal method gnus-select-method)
          gnus-select-method)
          (gnus-server-to-method method))
         ((equal method gnus-select-method)
          gnus-select-method)
-       ((and (stringp (car method)) group)
+       ((and (stringp (car method))
+             group)
          (gnus-server-extend-method group method))
          (gnus-server-extend-method group method))
-       ((and method (not group)
+       ((and method
+             (not group)
               (equal (cadr method) ""))
          method)
         (t
               (equal (cadr method) ""))
          method)
         (t
@@ -2277,7 +2697,14 @@ that that variable is buffer-local to the summary buffers."
                  (not (equal server (format "%s:%s" (caaar opened)
                                             (cadaar opened)))))
         (pop opened))
                  (not (equal server (format "%s:%s" (caaar opened)
                                             (cadaar opened)))))
         (pop opened))
-     (caar opened))))
+     (caar opened))
+   ;; It could be a named method, search all servers
+   (let ((servers gnus-secondary-select-methods))
+     (while (and servers
+                (not (equal server (format "%s:%s" (caar servers)
+                                           (cadar servers)))))
+       (pop servers))
+     (car servers))))
  
  (defmacro gnus-method-equal (ss1 ss2)
    "Say whether two servers are equal."
  
  (defmacro gnus-method-equal (ss1 ss2)
    "Say whether two servers are equal."
@@ -2290,6 +2717,15 @@ that that variable is buffer-local to the summary buffers."
                   (setq s1 (cdr s1)))
                 (null s1))))))
  
                   (setq s1 (cdr s1)))
                 (null s1))))))
  
+(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)))))))
+
  (defun gnus-server-equal (m1 m2)
    "Say whether two methods are equal."
    (let ((m1 (cond ((null m1) gnus-select-method)
  (defun gnus-server-equal (m1 m2)
    "Say whether two methods are equal."
    (let ((m1 (cond ((null m1) gnus-select-method)
@@ -2324,21 +2760,28 @@ that that variable is buffer-local to the summary buffers."
        (and active
            (file-exists-p active))))))
  
        (and active
            (file-exists-p active))))))
  
+(defsubst gnus-method-to-server-name (method)
+  (concat
+   (format "%s" (car method))
+   (when (and
+         (or (assoc (format "%s" (car method))
+                    (gnus-methods-using 'address))
+             (gnus-server-equal method gnus-message-archive-method))
+         (nth 1 method)
+         (not (string= (nth 1 method) "")))
+     (concat "+" (nth 1 method)))))
+
+(defsubst gnus-method-to-full-server-name (method)
+  (format "%s+%s" (car method) (nth 1 method)))
+
  (defun gnus-group-prefixed-name (group method)
    "Return the whole name from GROUP and METHOD."
    (and (stringp method) (setq method (gnus-server-to-method method)))
    (if (or (not method)
  (defun gnus-group-prefixed-name (group method)
    "Return the whole name from GROUP and METHOD."
    (and (stringp method) (setq method (gnus-server-to-method method)))
    (if (or (not method)
-         (gnus-server-equal method "native"))
+         (gnus-server-equal method "native")
+         (string-match ":" group))
        group
        group
-    (concat (format "%s" (car method))
-           (when (and
-                  (or (assoc (format "%s" (car method))
-                             (gnus-methods-using 'address))
-                      (gnus-server-equal method gnus-message-archive-method))
-                  (nth 1 method)
-                  (not (string= (nth 1 method) "")))
-             (concat "+" (nth 1 method)))
-           ":" group)))
+    (concat (gnus-method-to-server-name method) ":" group)))
  
  (defun gnus-group-real-prefix (group)
    "Return the prefix of the current group name."
  
  (defun gnus-group-real-prefix (group)
    "Return the prefix of the current group name."
@@ -2371,16 +2814,32 @@ You should probably use `gnus-find-method-for-group' instead."
             possible
             (list backend server))))))
  
             possible
             (list backend server))))))
  
+(defsubst gnus-native-method-p (method)
+  "Return whether METHOD is the native select method."
+  (gnus-method-equal method gnus-select-method))
+
  (defsubst gnus-secondary-method-p (method)
    "Return whether METHOD is a secondary select method."
    (let ((methods gnus-secondary-select-methods)
         (gmethod (gnus-server-get-method nil method)))
      (while (and methods
  (defsubst gnus-secondary-method-p (method)
    "Return whether METHOD is a secondary select method."
    (let ((methods gnus-secondary-select-methods)
         (gmethod (gnus-server-get-method nil method)))
      (while (and methods
-               (not (equal (gnus-server-get-method nil (car methods))
-                           gmethod)))
+               (not (gnus-method-equal
+                     (gnus-server-get-method nil (car methods))
+                     gmethod)))
        (setq methods (cdr methods)))
      methods))
  
        (setq methods (cdr methods)))
      methods))
  
+(defun gnus-method-simplify (method)
+  "Return the shortest uniquely identifying string or method for METHOD."
+  (cond ((stringp method)
+        method)
+       ((gnus-native-method-p method)
+        nil)
+       ((gnus-secondary-method-p method)
+        (format "%s:%s" (nth 0 method) (nth 1 method)))
+       (t
+        method)))
+
  (defun gnus-groups-from-server (server)
    "Return a list of all groups that are fetched from SERVER."
    (let ((alist (cdr gnus-newsrc-alist))
  (defun gnus-groups-from-server (server)
    "Return a list of all groups that are fetched from SERVER."
    (let ((alist (cdr gnus-newsrc-alist))
@@ -2403,15 +2862,84 @@ You should probably use `gnus-find-method-for-group' instead."
    "Say whether the group is secondary or not."
    (gnus-secondary-method-p (gnus-find-method-for-group group)))
  
    "Say whether the group is secondary or not."
    (gnus-secondary-method-p (gnus-find-method-for-group group)))
  
+(defun gnus-parameters-get-parameter (group)
+  "Return the group parameters for GROUP from `gnus-parameters'."
+  (let (params-list)
+    (dolist (elem gnus-parameters)
+      (when (string-match (car elem) group)
+       (setq params-list
+             (nconc (gnus-expand-group-parameters
+                     (car elem) (cdr elem) group)
+                    params-list))))
+    params-list))
+
+(defun gnus-expand-group-parameter (match value group)
+  "Use MATCH to expand VALUE in GROUP."
+  (with-temp-buffer
+    (insert group)
+    (goto-char (point-min))
+    (while (re-search-forward match nil t)
+      (replace-match value))
+    (buffer-string)))
+
+(defun gnus-expand-group-parameters (match parameters group)
+  "Go through PARAMETERS and expand them according to the match data."
+  (let (new)
+    (dolist (elem parameters)
+      (if (and (stringp (cdr elem))
+              (string-match "\\\\[0-9&]" (cdr elem)))
+         (push (cons (car elem)
+                     (gnus-expand-group-parameter match (cdr elem) group))
+               new)
+       (push elem new)))
+    new))
+
+(defun gnus-group-fast-parameter (group symbol &optional allow-list)
+  "For GROUP, return the value of SYMBOL.
+
+You should call this in the `gnus-group-buffer' buffer.
+The function `gnus-group-find-parameter' will do that for you."
+  ;; The speed trick:  No cons'ing and quit early.
+  (or (let ((params (funcall gnus-group-get-parameter-function group)))
+       ;; Start easy, check the "real" group parameters.
+       (gnus-group-parameter-value params symbol allow-list))
+      ;; We didn't found it there, try `gnus-parameters'.
+      (let ((result nil)
+           (head nil)
+           (tail gnus-parameters))
+       ;; A good old-fashioned non-cl loop.
+       (while tail
+         (setq head (car tail)
+               tail (cdr tail))
+         ;; The car is regexp matching for matching the group name.
+         (when (string-match (car head) group)
+           ;; The cdr is the parameters.
+           (setq result (gnus-group-parameter-value (cdr head)
+                                                    symbol allow-list))
+           (when result
+             ;; Expand if necessary.
+             (if (and (stringp result) (string-match "\\\\" result))
+                 (setq result (gnus-expand-group-parameter (car head)
+                                                           result group)))
+             ;; Exit the loop early.
+             (setq tail nil))))
+       ;; Done.
+       result)))
+
  (defun gnus-group-find-parameter (group &optional symbol allow-list)
    "Return the group parameters for GROUP.
  (defun gnus-group-find-parameter (group &optional symbol allow-list)
    "Return the group parameters for GROUP.
-If SYMBOL, return the value of that symbol in the group parameters."
+If SYMBOL, return the value of that symbol in the group parameters.
+
+If you call this function inside a loop, consider using the faster
+`gnus-group-fast-parameter' instead."
    (save-excursion
      (set-buffer gnus-group-buffer)
    (save-excursion
      (set-buffer gnus-group-buffer)
-    (let ((parameters (funcall gnus-group-get-parameter-function group)))
-      (if symbol
-         (gnus-group-parameter-value parameters symbol allow-list)
-       parameters))))
+    (if symbol
+       (gnus-group-fast-parameter group symbol allow-list)
+      (nconc
+       (copy-sequence
+       (funcall gnus-group-get-parameter-function group))
+       (gnus-parameters-get-parameter group)))))
  
  (defun gnus-group-get-parameter (group &optional symbol allow-list)
    "Return the group parameters for GROUP.
  
  (defun gnus-group-get-parameter (group &optional symbol allow-list)
    "Return the group parameters for GROUP.
@@ -2480,7 +3008,6 @@ If SCORE is nil, add 1 to the score of GROUP."
      (when info
        (gnus-info-set-score info (+ (gnus-info-score info) (or score 1))))))
  
      (when info
        (gnus-info-set-score info (+ (gnus-info-score info) (or score 1))))))
  
-;; Function written by Stainless Steel Rat <ratinox@peorth.gweep.net>
  (defun gnus-short-group-name (group &optional levels)
    "Collapse GROUP name LEVELS.
  Select methods are stripped and any remote host name is stripped down to
  (defun gnus-short-group-name (group &optional levels)
    "Collapse GROUP name LEVELS.
  Select methods are stripped and any remote host name is stripped down to
@@ -2490,40 +3017,51 @@ just the host name."
          (depth 0)
          (skip 1)
          (levels (or levels
          (depth 0)
          (skip 1)
          (levels (or levels
+                    gnus-group-uncollapsed-levels
                      (progn
                        (while (string-match "\\." group skip)
                          (setq skip (match-end 0)
                                depth (+ depth 1)))
                        depth))))
                      (progn
                        (while (string-match "\\." group skip)
                          (setq skip (match-end 0)
                                depth (+ depth 1)))
                        depth))))
-    ;; separate foreign select method from group name and collapse.
-    ;; if method contains a server, collapse to non-domain server name,
-    ;; otherwise collapse to select method
-    (when (string-match ":" group)
-      (cond ((string-match "+" group)
-            (let* ((plus (string-match "+" group))
-                   (colon (string-match ":" group (or plus 0)))
-                   (dot (string-match "\\." group)))
-              (setq foreign (concat
-                             (substring group (+ 1 plus)
-                                        (cond ((null dot) colon)
-                                              ((< colon dot) colon)
-                                              ((< dot colon) dot)))
-                             ":")
-                    group (substring group (+ 1 colon)))))
-           (t
-            (let* ((colon (string-match ":" group)))
-              (setq foreign (concat (substring group 0 (+ 1 colon)))
-                    group (substring group (+ 1 colon)))))))
-    ;; collapse group name leaving LEVELS uncollapsed elements
-    (while group
-      (if (and (string-match "\\." group) (> levels 0))
-         (setq name (concat name (substring group 0 1))
-               group (substring group (match-end 0))
-               levels (- levels 1)
-               name (concat name "."))
-       (setq name (concat foreign name group)
-             group nil)))
-    name))
+    ;; Separate foreign select method from group name and collapse.
+   ;; If method contains a server, collapse to non-domain server name,
+    ;; otherwise collapse to select method.
+    (let* ((colon (string-match ":" group))
+          (server (and colon (substring group 0 colon)))
+          (plus (and server (string-match "+" server))))
+      (when server
+       (if plus
+           (setq foreign (substring server (+ 1 plus)
+                                    (string-match "\\." server))
+                 group (substring group (+ 1 colon)))
+         (setq foreign server
+               group (substring group (+ 1 colon))))
+       (setq foreign (concat foreign ":")))
+      ;; Collapse group name leaving LEVELS uncollapsed elements
+      (let* ((slist (split-string group "/"))
+            (slen (length slist))
+            (dlist (split-string group "\\."))
+            (dlen (length dlist))
+            glist
+            glen
+            gsep
+            res)
+       (if (> slen dlen)
+           (setq glist slist
+                 glen slen
+                 gsep "/")
+         (setq glist dlist
+               glen dlen
+               gsep "."))
+       (setq levels (- glen levels))
+       (dolist (g glist)
+         (push (if (>= (decf levels) 0)
+                   (if (zerop (length g))
+                       ""
+                     (substring g 0 1))
+                 g)
+               res))
+       (concat foreign (mapconcat 'identity (nreverse res) gsep))))))
  
  (defun gnus-narrow-to-body ()
    "Narrow to the body of an article."
  
  (defun gnus-narrow-to-body ()
    "Narrow to the body of an article."
@@ -2601,6 +3139,7 @@ If NEWSGROUP is nil, return the global kill file name instead."
    (let ((opened gnus-opened-servers))
      (while (and method opened)
        (when (and (equal (cadr method) (cadaar opened))
    (let ((opened gnus-opened-servers))
      (while (and method opened)
        (when (and (equal (cadr method) (cadaar opened))
+                (equal (car method) (caaar opened))
                  (not (equal method (caar opened))))
         (setq method nil))
        (pop opened))
                  (not (equal method (caar opened))))
         (setq method nil))
        (pop opened))
@@ -2632,11 +3171,22 @@ If NEWSGROUP is nil, return the global kill file name instead."
           (list (intern server) "")))
      gnus-select-method))
  
           (list (intern server) "")))
      gnus-select-method))
  
+(defun gnus-server-string (server)
+  "Return a readable string that describes SERVER."
+  (let* ((server (gnus-server-to-method server))
+        (address (nth 1 server)))
+    (if (and address
+            (not (zerop (length address))))
+       (format "%s via %s" address (car server))
+      (format "%s" (car server)))))
+
  (defun gnus-find-method-for-group (group &optional info)
    "Find the select method that GROUP uses."
    (or gnus-override-method
        (and (not group)
            gnus-select-method)
  (defun gnus-find-method-for-group (group &optional info)
    "Find the select method that GROUP uses."
    (or gnus-override-method
        (and (not group)
            gnus-select-method)
+      (and (not (gnus-group-entry group)) ;; a new group
+          (gnus-group-name-to-method group))
        (let ((info (or info (gnus-get-info group)))
             method)
         (if (or (not info)
        (let ((info (or info (gnus-get-info group)))
             method)
         (if (or (not info)
@@ -2669,57 +3219,85 @@ If NEWSGROUP is nil, return the global kill file name instead."
  
  (defun gnus-read-group (prompt &optional default)
    "Prompt the user for a group name.
  
  (defun gnus-read-group (prompt &optional default)
    "Prompt the user for a group name.
-Disallow illegal group names."
+Disallow invalid group names."
    (let ((prefix "")
         group)
      (while (not group)
        (when (string-match
    (let ((prefix "")
         group)
      (while (not group)
        (when (string-match
-            "[: `'\"/]\\|^$"
+            gnus-invalid-group-regexp
              (setq group (read-string (concat prefix prompt)
                                       (cons (or default "") 0)
                                       'gnus-group-history)))
              (setq group (read-string (concat prefix prompt)
                                       (cons (or default "") 0)
                                       'gnus-group-history)))
-       (setq prefix (format "Illegal group name: \"%s\".  " group)
+       (setq prefix (format "Invalid group name: \"%s\".  " group)
               group nil)))
      group))
  
  (defun gnus-read-method (prompt)
    "Prompt the user for a method.
  Allow completion over sensible values."
               group nil)))
      group))
  
  (defun gnus-read-method (prompt)
    "Prompt the user for a method.
  Allow completion over sensible values."
-  (let ((method
-        (completing-read
-         prompt (append gnus-valid-select-methods gnus-predefined-server-alist
-                        gnus-server-alist)
-         nil t nil 'gnus-method-history)))
+  (let* ((open-servers
+         (mapcar (lambda (i) (cons (format "%s:%s" (caar i) (cadar i)) i))
+                 gnus-opened-servers))
+        (valid-methods
+         (let (methods)
+           (dolist (method gnus-valid-select-methods)
+             (if (or (memq 'prompt-address method)
+                     (not (assoc (format "%s:" (car method)) open-servers)))
+                 (push method methods)))
+           methods))
+        (servers
+         (append valid-methods
+                 open-servers
+                 gnus-predefined-server-alist
+                 gnus-server-alist))
+        (method
+         (completing-read
+          prompt servers
+          nil t nil 'gnus-method-history)))
      (cond
       ((equal method "")
        (setq method gnus-select-method))
       ((assoc method gnus-valid-select-methods)
      (cond
       ((equal method "")
        (setq method gnus-select-method))
       ((assoc method gnus-valid-select-methods)
-      (list (intern method)
-           (if (memq 'prompt-address
-                     (assoc method gnus-valid-select-methods))
-               (read-string "Address: ")
-             "")))
-     ((assoc method gnus-server-alist)
+      (let ((address (if (memq 'prompt-address
+                              (assoc method gnus-valid-select-methods))
+                        (read-string "Address: ")
+                      "")))
+       (or (cadr (assoc (format "%s:%s" method address) open-servers))
+           (list (intern method) address))))
+     ((assoc method servers)
        method)
       (t
        (list (intern method) "")))))
  
        method)
       (t
        (list (intern method) "")))))
  
+;;; Agent functions
+
+(defun gnus-agent-method-p (method)
+  "Say whether METHOD is covered by the agent."
+  (member method gnus-agent-covered-methods))
+
+(defun gnus-online (method)
+  (not
+   (if gnus-plugged
+       (eq (cadr (assoc method gnus-opened-servers)) 'offline)
+     (gnus-agent-method-p method))))
+
  ;;; User-level commands.
  
  ;;;###autoload
  (defun gnus-slave-no-server (&optional arg)
  ;;; User-level commands.
  
  ;;;###autoload
  (defun gnus-slave-no-server (&optional arg)
-  "Read network news as a slave, without connecting to local server."
+  "Read network news as a slave, without connecting to the local server."
    (interactive "P")
    (gnus-no-server arg t))
  
  ;;;###autoload
  (defun gnus-no-server (&optional arg slave)
    "Read network news.
    (interactive "P")
    (gnus-no-server arg t))
  
  ;;;###autoload
  (defun gnus-no-server (&optional arg slave)
    "Read network news.
-If ARG is a positive number, Gnus will use that as the
-startup level. If ARG is nil, Gnus will be started at level 2.
-If ARG is non-nil and not a positive number, Gnus will
-prompt the user for the name of an NNTP server to use.
-As opposed to `gnus', this command will not connect to the local server."
+If ARG is a positive number, Gnus will use that as the startup
+level. If ARG is nil, Gnus will be started at level 2.  If ARG is
+non-nil and not a positive number, Gnus will prompt the user for the
+name of an NNTP server to use.
+As opposed to `gnus', this command will not connect to the local
+server."
    (interactive "P")
    (gnus-no-server-1 arg slave))
  
    (interactive "P")
    (gnus-no-server-1 arg slave))
  
@@ -2736,12 +3314,13 @@ As opposed to `gnus', this command will not connect to the local server."
    (let ((window (get-buffer-window gnus-group-buffer)))
      (cond (window
            (select-frame (window-frame window)))
    (let ((window (get-buffer-window gnus-group-buffer)))
      (cond (window
            (select-frame (window-frame window)))
-         ((= (length (frame-list)) 1)
-          (select-frame (make-frame)))
           (t
           (t
-          (other-frame 1))))
+          (select-frame (make-frame)))))
    (gnus arg))
  
    (gnus arg))
  
+;;(setq thing ?                                ; this is a comment
+;;      more 'yes)
+
  ;;;###autoload
  (defun gnus (&optional arg dont-connect slave)
    "Read network news.
  ;;;###autoload
  (defun gnus (&optional arg dont-connect slave)
    "Read network news.
@@ -2749,6 +3328,9 @@ If ARG is non-nil and a positive number, Gnus will use that as the
  startup level. If ARG is non-nil and not a positive number, Gnus will
  prompt the user for the name of an NNTP server to use."
    (interactive "P")
  startup level. If ARG is non-nil and not a positive number, Gnus will
  prompt the user for the name of an NNTP server to use."
    (interactive "P")
+  (unless (byte-code-function-p (symbol-function 'gnus))
+    (message "You should byte-compile Gnus")
+    (sit-for 2))
    (gnus-1 arg dont-connect slave))
  
  ;; Allow redefinition of Gnus functions.
    (gnus-1 arg dont-connect slave))
  
  ;; Allow redefinition of Gnus functions.