Initial revision

7 files changed, 9160 insertions, 0 deletions

diff --git a/lisp/compare-w.el b/lisp/compare-w.el
new file mode 100644
index 00000000000..0ae9f37673b
--- /dev/null
+++ b/lisp/compare-w.el
@@ -0,0 +1,129 @@
+;; Compare text between windows for Emacs.
+;; Copyright (C) 1986, 1989 Free Software Foundation, Inc.
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 1, or (at your option)
+;; any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs; see the file COPYING.  If not, write to
+;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+(provide 'compare-w)
+
+(defvar compare-windows-whitespace " \t\n"
+  "*String of characters considered whitespace for \\[compare-windows].
+Changes in whitespace are optionally ignored.
+
+The value of `compare-windows-whitespace' may instead be a function; this
+function is called in each buffer, with point at the current scanning point.
+The function's job is to categorize any whitespace around (including before)
+point; it should also advance past any whitespace.
+
+The function is passed one argument, the point where `compare-windows'
+was originally called; it should not consider any text before that point.
+If the function returns the same value for both buffers, then the
+whitespace is considered to match, and is skipped.")
+
+(defvar compare-ignore-case nil
+  "*Non-nil means \\[compare-windows] ignores case differences.")
+
+;;;###autoload
+(defun compare-windows (ignore-whitespace)
+  "Compare text in current window with text in next window.
+Compares the text starting at point in each window,
+moving over text in each one as far as they match.
+
+A prefix arg means ignore changes in whitespace.
+The variable `compare-windows-whitespace' controls how whitespace is skipped.
+If `compare-ignore-case' is non-nil, changes in case are also ignored."
+  (interactive "P")
+  (let* (p1 p2 maxp1 maxp2 b1 b2 w2
+            success size
+            (opoint1 (point))
+            opoint2
+            (skip-whitespace (if ignore-whitespace
+                                 compare-windows-whitespace))
+            (skip-whitespace-regexp (concat "[" skip-whitespace "]+")))
+    (setq p1 (point) b1 (current-buffer))
+    (setq w2 (next-window (selected-window)))
+    (if (eq w2 (selected-window))
+        (error "No other window"))
+    (setq p2 (window-point w2)
+          b2 (window-buffer w2))
+    (setq opoint2 p2)
+    (setq maxp1 (point-max))
+    (save-excursion
+      (set-buffer b2)
+      (setq maxp2 (point-max)))
+
+    (setq success t)
+    (while success
+      (setq success nil)
+      ;; if interrupted, show how far we've gotten
+      (goto-char p1)
+      (set-window-point w2 p2)
+
+      ;; If both buffers have whitespace next to point,
+      ;; optionally skip over it.
+
+      (and skip-whitespace
+           (save-excursion
+             (let (p1a p2a w1 w2 result1 result2)
+               (if (stringp skip-whitespace)
+                   (progn
+                     (if (not (eobp))
+                         (skip-chars-backward skip-whitespace opoint1))
+                     (and (looking-at skip-whitespace-regexp)
+                          (setq p1a (match-end 0) result1 t)))
+                 (setq result1 (funcall skip-whitespace opoint1))
+                 (setq p1a (point)))
+               (set-buffer b2)
+               (goto-char p2)
+               (if (stringp skip-whitespace)
+                   (progn
+                     (if (not (eobp))
+                         (skip-chars-backward skip-whitespace opoint2))
+                     (and (looking-at skip-whitespace-regexp)
+                          (setq p2a (match-end 0) result2 t)))
+                 (setq result2 (funcall skip-whitespace opoint2))
+                 (setq p2a (point)))
+               (and result1 result2 (eq result1 result2)
+                    (setq p1 p1a
+                          p2 p2a)))))
+
+      ;; Try advancing comparing 1000 chars at a time.
+      ;; When that fails, go 500 chars at a time, and so on.
+      (let ((size 1000)
+            success-1)
+        (while (> size 0)
+          (setq success-1 t)
+          (while success-1
+            (setq size (min size (- maxp1 p1) (- maxp2 p2)))
+            (save-excursion
+              (set-buffer b2)
+              (setq s2 (buffer-substring p2 (+ size p2))))
+            (setq success-1
+                  (and (> size 0)
+                       (if compare-ignore-case
+                           (let ((case-fold-search t))
+                             (save-excursion
+                               (search-forward s2 (+ p1 size) t)))
+                         (equal (buffer-substring p1 (+ size p1)) s2))))
+            (if success-1
+                (setq p1 (+ p1 size) p2 (+ p2 size)
+                      success t)))
+          (setq size (/ size 2)))))
+
+    (goto-char p1)
+    (set-window-point w2 p2)
+    (if (= (point) opoint1)
+        (ding))))
diff --git a/lisp/emacs-lisp/cl-indent.el b/lisp/emacs-lisp/cl-indent.el
new file mode 100644
index 00000000000..4e4543725c8
--- /dev/null
+++ b/lisp/emacs-lisp/cl-indent.el
@@ -0,0 +1,466 @@
+;; Lisp mode, and its idiosyncratic commands.
+;; Copyright (C) 1987 Free Software Foundation, Inc.
+;; Written by Richard Mlynarik July 1987
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 1, or (at your option)
+;; any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs; see the file COPYING.  If not, write to
+;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+;;>> TODO
+;; :foo
+;;   bar
+;; :baz
+;;   zap
+;; &key (like &body)??
+
+;; &rest 1 in lambda-lists doesn't work
+;;  -- really want (foo bar
+;;                  baz)
+;;     not (foo bar
+;;              baz)
+;;  Need something better than &rest for such cases
+
+
+;;; Hairy lisp indentation.
+
+(defvar lisp-indent-maximum-backtracking 3
+  "*Maximum depth to backtrack out from a sublist for structured indentation.
+If this variable is  0, no backtracking will occur and forms such as flet
+may not be correctly indented.")
+
+(defvar lisp-tag-indentation 1
+  "*Indentation of tags relative to containing list.
+This variable is used by the function `lisp-indent-tagbody'.")
+
+(defvar lisp-tag-body-indentation 3
+  "*Indentation of non-tagged lines relative to containing list.
+This variable is used by the function `lisp-indent-tagbody' to indent normal
+lines (lines without tags).
+The indentation is relative to the indentation of the parenthesis enclosing
+the special form.  If the value is t, the body of tags will be indented
+as a block at the same indentation as the first s-expression following
+the tag.  In this case, any forms before the first tag are indented
+by `lisp-body-indent'.")
+
+
+;;;###autoload
+(defun common-lisp-indent-function (indent-point state)
+  (let ((normal-indent (current-column)))
+    ;; Walk up list levels until we see something
+    ;;  which does special things with subforms.
+    (let ((depth 0)
+          ;; Path describes the position of point in terms of
+          ;;  list-structure with respect to contining lists.
+          ;; `foo' has a path of (0 4 1) in `((a b c (d foo) f) g)'
+          (path ())
+          ;; set non-nil when somebody works out the indentation to use
+          calculated
+          (last-point indent-point)
+          ;; the position of the open-paren of the innermost containing list
+          (containing-form-start (elt state 1))
+          ;; the column of the above
+          sexp-column)
+      ;; Move to start of innermost containing list
+      (goto-char containing-form-start)
+      (setq sexp-column (current-column))
+      ;; Look over successively less-deep containing forms
+      (while (and (not calculated)
+                  (< depth lisp-indent-maximum-backtracking))
+        (let ((containing-sexp (point)))
+          (forward-char 1)
+          (parse-partial-sexp (point) indent-point 1 t)
+          ;; Move to the car of the relevant containing form
+          (let (tem function method)
+            (if (not (looking-at "\\sw\\|\\s_"))
+                ;; This form doesn't seem to start with a symbol
+                (setq function nil method nil)
+              (setq tem (point))
+              (forward-sexp 1)
+              (setq function (downcase (buffer-substring tem (point))))
+              (goto-char tem)
+              (setq tem (intern-soft function)
+                    method (get tem 'common-lisp-indent-function))
+              (cond ((and (null method)
+                          (string-match ":[^:]+" function))
+                     ;; The pleblisp package feature
+                     (setq function (substring function
+                                               (1+ (match-beginning 0)))
+                           method (get (intern-soft function)
+                                       'common-lisp-indent-function)))
+                    ((and (null method))
+                     ;; backwards compatibility
+                     (setq method (get tem 'lisp-indent-function)))))
+            (let ((n 0))
+              ;; How far into the containing form is the current form?
+              (if (< (point) indent-point)
+                  (while (condition-case ()
+                             (progn
+                               (forward-sexp 1)
+                               (if (>= (point) indent-point)
+                                   nil
+                                 (parse-partial-sexp (point)
+                                                     indent-point 1 t)
+                                 (setq n (1+ n))
+                                 t))
+                           (error nil))))
+              (setq path (cons n path)))
+
+            ;; backwards compatibility.
+            (cond ((null function))
+                  ((null method)
+                   (if (null (cdr path))
+                       ;; (package prefix was stripped off above)
+                       (setq method (cond ((string-match "\\`def"
+                                                         function)
+                                           '(4 (&whole 4 &rest 1) &body))
+                                          ((string-match "\\`\\(with\\|do\\)-"
+                                                         function)
+                                           '(4 &body))))))
+                  ;; backwards compatibility.  Bletch.
+                  ((eq method 'defun)
+                   (setq method '(4 (&whole 4 &rest 1) &body))))
+
+            (cond ((and (memq (char-after (1- containing-sexp)) '(?\' ?\`))
+                        (not (eql (char-after (- containing-sexp 2)) ?\#)))
+                   ;; No indentation for "'(...)" elements
+                   (setq calculated (1+ sexp-column)))
+                  ((or (eql (char-after (1- containing-sexp)) ?\,)
+                       (and (eql (char-after (1- containing-sexp)) ?\@)
+                            (eql (char-after (- containing-sexp 2)) ?\,)))
+                   ;; ",(...)" or ",@(...)"
+                   (setq calculated normal-indent))
+                  ((eql (char-after (1- containing-sexp)) ?\#)
+                   ;; "#(...)"
+                   (setq calculated (1+ sexp-column)))
+                  ((null method))
+                  ((integerp method)
+                   ;; convenient top-level hack.
+                   ;;  (also compatible with lisp-indent-function)
+                   ;; The number specifies how many `distinguished'
+                   ;;  forms there are before the body starts
+                   ;; Equivalent to (4 4 ... &body)
+                   (setq calculated (cond ((cdr path)
+                                           normal-indent)
+                                          ((<= (car path) method)
+                                           ;; `distinguished' form
+                                           (list (+ sexp-column 4)
+                                                 containing-form-start))
+                                          ((= (car path) (1+ method))
+                                           ;; first body form.
+                                           (+ sexp-column lisp-body-indent))
+                                          (t
+                                           ;; other body form
+                                           normal-indent))))
+                  ((symbolp method)
+                   (setq calculated (funcall method
+                                             path state indent-point
+                                             sexp-column normal-indent)))
+                  (t
+                   (setq calculated (lisp-indent-259
+                                      method path state indent-point
+                                      sexp-column normal-indent)))))
+          (goto-char containing-sexp)
+          (setq last-point containing-sexp)
+          (if (not calculated)
+              (condition-case ()
+                   (progn (backward-up-list 1)
+                          (setq depth (1+ depth)))
+                (error (setq depth lisp-indent-maximum-backtracking))))))
+      calculated)))
+
+
+(defun lisp-indent-report-bad-format (m)
+  (error "%s has a badly-formed %s property: %s"
+         ;; Love those free variable references!!
+         function 'common-lisp-indent-function m))
+
+;; Blame the crufty control structure on dynamic scoping
+;;  -- not on me!
+(defun lisp-indent-259 (method path state indent-point
+                        sexp-column normal-indent)
+  (catch 'exit
+    (let ((p path)
+          (containing-form-start (elt state 1))
+          n tem tail)
+      ;; Isn't tail-recursion wonderful?
+      (while p
+        ;; This while loop is for destructuring.
+        ;; p is set to (cdr p) each iteration.
+        (if (not (consp method)) (lisp-indent-report-bad-format method))
+        (setq n (1- (car p))
+              p (cdr p)
+              tail nil)
+        (while n
+          ;; This while loop is for advancing along a method
+          ;; until the relevant (possibly &rest/&body) pattern
+          ;; is reached.
+          ;; n is set to (1- n) and method to (cdr method)
+          ;; each iteration.
+          (setq tem (car method))
+
+          (or (eq tem 'nil)             ;default indentation
+;             (eq tem '&lambda)         ;abbrev for (&whole 4 (&rest 1))
+              (and (eq tem '&body) (null (cdr method)))
+              (and (eq tem '&rest)
+                   (consp (cdr method)) (null (cdr (cdr method))))
+              (integerp tem)            ;explicit indentation specified
+              (and (consp tem)          ;destructuring
+                   (eq (car tem) '&whole)
+                   (or (symbolp (car (cdr tem)))
+                       (integerp (car (cdr tem)))))
+              (and (symbolp tem)        ;a function to call to do the work.
+                   (null (cdr method)))
+              (lisp-indent-report-bad-format method))
+
+          (cond ((and tail (not (consp tem)))
+                 ;; indent tail of &rest in same way as first elt of rest
+                 (throw 'exit normal-indent))
+                ((eq tem '&body)
+                 ;; &body means (&rest <lisp-body-indent>)
+                 (throw 'exit
+                   (if (and (= n 0)     ;first body form
+                            (null p))   ;not in subforms
+                       (+ sexp-column
+                          lisp-body-indent)
+                       normal-indent)))
+                ((eq tem '&rest)
+                 ;; this pattern holds for all remaining forms
+                 (setq tail (> n 0)
+                       n 0
+                       method (cdr method)))
+                ((> n 0)
+                 ;; try next element of pattern
+                 (setq n (1- n)
+                       method (cdr method))
+                 (if (< n 0)
+                     ;; Too few elements in pattern.
+                     (throw 'exit normal-indent)))
+                ((eq tem 'nil)
+                 (throw 'exit (list normal-indent containing-form-start)))
+;               ((eq tem '&lambda)
+;                ;; abbrev for (&whole 4 &rest 1)
+;                (throw 'exit
+;                  (cond ((null p)
+;                         (list (+ sexp-column 4) containing-form-start))
+;                        ((null (cdr p))
+;                         (+ sexp-column 1))
+;                        (t normal-indent))))
+                ((integerp tem)
+                 (throw 'exit
+                   (if (null p)         ;not in subforms
+                       (list (+ sexp-column tem) containing-form-start)
+                       normal-indent)))
+                ((symbolp tem)          ;a function to call
+                 (throw 'exit
+                   (funcall tem path state indent-point
+                            sexp-column normal-indent)))
+                (t
+                 ;; must be a destructing frob
+                 (if (not (null p))
+                     ;; descend
+                     (setq method (cdr (cdr tem))
+                           n nil)
+                   (setq tem (car (cdr tem)))
+                   (throw 'exit
+                     (cond (tail
+                            normal-indent)
+                           ((eq tem 'nil)
+                            (list normal-indent
+                                  containing-form-start))
+                           ((integerp tem)
+                            (list (+ sexp-column tem)
+                                  containing-form-start))
+                           (t
+                            (funcall tem path state indent-point
+                                     sexp-column normal-indent))))))))))))
+
+(defun lisp-indent-tagbody (path state indent-point sexp-column normal-indent)
+  (if (not (null (cdr path)))
+      normal-indent
+    (save-excursion
+      (goto-char indent-point)
+      (beginning-of-line)
+      (skip-chars-forward " \t")
+      (list (cond ((looking-at "\\sw\\|\\s_")
+                   ;; a tagbody tag
+                   (+ sexp-column lisp-tag-indentation))
+                  ((integerp lisp-tag-body-indentation)
+                   (+ sexp-column lisp-tag-body-indentation))
+                  ((eq lisp-tag-body-indentation 't)
+                   (condition-case ()
+                       (progn (backward-sexp 1) (current-column))
+                     (error (1+ sexp-column))))
+                  (t (+ sexp-column lisp-body-indent)))
+;            (cond ((integerp lisp-tag-body-indentation)
+;                   (+ sexp-column lisp-tag-body-indentation))
+;                  ((eq lisp-tag-body-indentation 't)
+;                   normal-indent)
+;                  (t
+;                   (+ sexp-column lisp-body-indent)))
+            (elt state 1)
+            ))))
+
+(defun lisp-indent-do (path state indent-point sexp-column normal-indent)
+  (if (>= (car path) 3)
+      (let ((lisp-tag-body-indentation lisp-body-indent))
+        (funcall (function lisp-indent-tagbody)
+                 path state indent-point sexp-column normal-indent))
+    (funcall (function lisp-indent-259)
+             '((&whole nil &rest
+                ;; the following causes wierd indentation
+                ;;(&whole 1 1 2 nil)
+                )
+               (&whole nil &rest 1))
+             path state indent-point sexp-column normal-indent)))
+
+(defun lisp-indent-function-lambda-hack (path state indent-point
+                                         sexp-column normal-indent)
+  ;; indent (function (lambda () <newline> <body-forms>)) kludgily.
+  (if (or (cdr path) ; wtf?
+          (> (car path) 3))
+      ;; line up under previous body form
+      normal-indent
+    ;; line up under function rather than under lambda in order to
+    ;;  conserve horizontal space.  (Which is what #' is for.)
+    (condition-case ()
+        (save-excursion
+          (backward-up-list 2)
+          (forward-char 1)
+          (if (looking-at "\\(lisp:+\\)?function\\(\\Sw\\|\\S_\\)")
+              (+ lisp-body-indent -1 (current-column))
+              (+ sexp-column lisp-body-indent)))
+       (error (+ sexp-column lisp-body-indent)))))
+
+
+(let ((l '((block 1)
+           (catch 1)
+           (case        (4 &rest (&whole 2 &rest 1)))
+           (ccase . case) (ecase . case)
+           (typecase . case) (etypecase . case) (ctypecase . case)
+           (catch 1)
+           (cond        (&rest (&whole 2 &rest 1)))
+           (block 1)
+           (defvar      (4 2 2))
+           (defconstant . defvar) (defparameter . defvar)
+           (define-modify-macro
+                        (4 &body))
+           (define-setf-method
+                        (4 (&whole 4 &rest 1) &body))
+           (defsetf     (4 (&whole 4 &rest 1) 4 &body))
+           (defun       (4 (&whole 4 &rest 1) &body))
+           (defmacro . defun) (deftype . defun)
+           (defstruct   ((&whole 4 &rest (&whole 2 &rest 1))
+                         &rest (&whole 2 &rest 1)))
+           (destructuring-bind
+                        ((&whole 6 &rest 1) 4 &body))
+           (do          lisp-indent-do)
+           (do* . do)
+           (dolist      ((&whole 4 2 1) &body))
+           (dotimes . dolist)
+           (eval-when   1)
+           (flet        ((&whole 4 &rest (&whole 1 (&whole 4 &rest 1) &body))
+                         &body))
+           (labels . flet)
+           (macrolet . flet)
+           ;; `else-body' style
+           (if          (nil nil &body))
+           ;; single-else style (then and else equally indented)
+           (if          (&rest nil))
+           ;(lambda     ((&whole 4 &rest 1) &body))
+           (lambda      ((&whole 4 &rest 1)
+                         &rest lisp-indent-function-lambda-hack))
+           (let         ((&whole 4 &rest (&whole 1 1 2)) &body))
+           (let* . let)
+           (compiler-let . let) ;barf
+           (locally     1)
+           ;(loop ...)
+           (multiple-value-bind
+                        ((&whole 6 &rest 1) 4 &body))
+           (multiple-value-call
+                        (4 &body))
+           (multiple-value-list 1)
+           (multiple-value-prog1 1)
+           (multiple-value-setq
+                        (4 2))
+           ;; Combines the worst features of BLOCK, LET and TAGBODY
+           (prog        ((&whole 4 &rest 1) &rest lisp-indent-tagbody))
+           (prog* . prog)
+           (prog1 1)
+           (prog2 2)
+           (progn 0)
+           (progv       (4 4 &body))
+           (return 0)
+           (return-from (nil &body))
+           (tagbody     lisp-indent-tagbody)
+           (throw 1)
+           (unless 1)
+           (unwind-protect
+                        (5 &body))
+           (when 1))))
+  (while l
+    (put (car (car l)) 'common-lisp-indent-function
+         (if (symbolp (cdr (car l)))
+             (get (cdr (car l)) 'common-lisp-indent-function)
+             (car (cdr (car l)))))
+    (setq l (cdr l))))
+
+
+;(defun foo (x)
+;  (tagbody
+;   foo
+;     (bar)
+;   baz
+;     (when (losing)
+;       (with-big-loser
+;           (yow)
+;         ((lambda ()
+;            foo)
+;          big)))
+;     (flet ((foo (bar baz zap)
+;              (zip))
+;            (zot ()
+;              quux))
+;       (do ()
+;           ((lose)
+;            (foo 1))
+;         (quux)
+;        foo
+;         (lose))
+;       (cond ((x)
+;              (win 1 2
+;                   (foo)))
+;             (t
+;              (lose
+;                3))))))
+          
+
+;(put 'while    'common-lisp-indent-function 1)
+;(put 'defwrapper'common-lisp-indent-function ...)
+;(put 'def 'common-lisp-indent-function ...)
+;(put 'defflavor        'common-lisp-indent-function ...)
+;(put 'defsubst 'common-lisp-indent-function ...)
+
+;(put 'with-restart 'common-lisp-indent-function '((1 4 ((* 1))) (2 &body)))
+;(put 'restart-case 'common-lisp-indent-function '((1 4) (* 2 ((0 1) (* 1)))))
+;(put 'define-condition 'common-lisp-indent-function '((1 6) (2 6 ((* 1))) (3 4 ((* 1))) (4 &body)))
+;(put 'with-condition-handler 'common-lisp-indent-function '((1 4 ((* 1))) (2 &body)))
+;(put 'condition-case 'common-lisp-indent-function '((1 4) (* 2 ((0 1) (1 3) (2 &body)))))
+
+
+;;;; Turn it on.
+;(setq lisp-indent-function 'common-lisp-indent-function)
+
+;; To disable this stuff, (setq lisp-indent-function 'lisp-indent-function)
+
diff --git a/lisp/gnus.el b/lisp/gnus.el
new file mode 100644
index 00000000000..d37072dd6a6
--- /dev/null
+++ b/lisp/gnus.el
@@ -0,0 +1,6081 @@
+;;; GNUS: an NNTP-based News Reader for GNU Emacs
+;; Copyright (C) 1987, 1988, 1989 Fujitsu Laboratories LTD.
+;; Copyright (C) 1987, 1988, 1989, 1990 Masanobu UMEDA
+;; $Header: gnus.el,v 3.13 90/03/23 13:24:27 umerin Locked $
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY.  No author or distributor
+;; accepts responsibility to anyone for the consequences of using it
+;; or for whether it serves any particular purpose or works at all,
+;; unless he says so in writing.  Refer to the GNU Emacs General Public
+;; License for full details.
+
+;; Everyone is granted permission to copy, modify and redistribute
+;; GNU Emacs, but only under the conditions described in the
+;; GNU Emacs General Public License.   A copy of this license is
+;; supposed to have been given to you along with GNU Emacs so you
+;; can know your rights and responsibilities.  It should be in a
+;; file named COPYING.  Among other things, the copyright notice
+;; and this notice must be preserved on all copies.
+
+;; GNUS Mailing List:
+;; There are two mailing lists for GNUS lovers in the world:
+;;
+;;      info-gnus@flab.fujitsu.co.jp, and
+;;      info-gnus-english@tut.cis.ohio-state.edu.
+;;
+;; They are intended to exchange useful information about GNUS, such
+;; as bug fixes, useful hooks, and extensions.  The major difference
+;; between the lists is what the official language is.  Both Japanese
+;; and English are available in info-gnus, while English is only
+;; available in info-gnus-english. There is no need to subscribe to
+;; info-gnus if you cannot read Japanese messages, because most of the
+;; discussion and important announcements will be sent to
+;; info-gnus-english. Moreover, if you can read gnu.emacs.gnus
+;; newsgroup of USENET, you need not, either. info-gnus-english and
+;; gnu.emacs.gnus are linked each other.
+;;
+;; Please send subscription request to:
+;;
+;;      info-gnus-request@flab.fujitsu.co.jp, or
+;;      info-gnus-english-request@cis.ohio-state.edu
+
+;; TO DO:
+;; (1) Incremental update of active info.
+;; (2) GNUS own poster.
+;; (3) Multi-GNUS (Talking to many hosts same time).
+;; (4) Asynchronous transmission of large messages.
+
+(provide 'gnus)
+(require 'nntp)
+(require 'mail-utils)
+
+(defvar gnus-nntp-server (or (getenv "NNTPSERVER") gnus-default-nntp-server)
+  "The name of the host running NNTP server.
+If it is a string such as `:DIRECTORY', the user's private DIRECTORY
+is used as a news spool.
+Initialized from the NNTPSERVER environment variable.")
+
+(defvar gnus-signature-file "~/.signature"
+  "*Your .signature file. Use `.signature-DISTRIBUTION' instead if exists.")
+
+(defvar gnus-use-cross-reference t
+  "Specifies what to do with cross references (Xref: field).
+If nil, ignore cross references.  If t, mark articles as read in subscribed
+newsgroups.  Otherwise, mark articles as read in all newsgroups.")
+
+(defvar gnus-use-followup-to t
+  "*Specifies what to do with Followup-To: field.
+If nil, ignore followup-to: field.  If t, use its value execpt for
+`poster'.  Otherewise, if not nil nor t, always use its value.")
+
+(defvar gnus-large-newsgroup 50
+  "*The number of articles which indicates a large newsgroup.
+If the number of articles in a newsgroup is greater than the value,
+confirmation is required for selecting the newsgroup.")
+
+(defvar gnus-author-copy (getenv "AUTHORCOPY")
+  "*Filename for saving a copy of an article posted using FCC: field.
+Initialized from the AUTHORCOPY environment variable.
+
+Articles are saved using a function specified by the the variable
+`gnus-author-copy-saver' (`rmail-output' is the default) if a file name
+is given.  Instead, if the first character of the name is `|', the
+contents of the article is piped out to the named program.  It is
+possible to save an article in an MH folder as follows:
+
+    (setq gnus-author-copy \"|/usr/local/lib/mh/rcvstore +Article\")")
+
+(defvar gnus-author-copy-saver (function rmail-output)
+  "*A function called with a file name to save an author copy to.
+The default function is `rmail-output' which saves in Unix mailbox format.")
+
+(defvar gnus-use-long-file-name
+  (not (memq system-type '(usg-unix-v xenix)))
+  "Non-nil means that a newsgroup name is used as a default file name
+to save articles to.  If nil, the directory form of a newsgroup is
+used instead.")
+
+(defvar gnus-article-save-directory (getenv "SAVEDIR")
+  "*The directory in which to save articles; defaults to ~/News.
+Initialized from the SAVEDIR environment variable.")
+
+(defvar gnus-default-article-saver (function gnus-Subject-save-in-rmail)
+  "A function used to save articles in your favorite format.
+The function must be interactively callable (in other words, it must
+be an Emacs command).
+
+GNUS provides the following functions:
+        gnus-Subject-save-in-rmail (in Rmail format)
+        gnus-Subject-save-in-mail (in Unix mail format)
+        gnus-Subject-save-in-folder (in an MH folder)
+        gnus-Subject-save-in-file (in article format).")
+
+(defvar gnus-rmail-save-name (function gnus-plain-save-name)
+  "A function generating a file name to save articles in Rmail format.
+The function is called with NEWSGROUP, HEADERS, and optional LAST-FILE.")
+
+(defvar gnus-mail-save-name (function gnus-plain-save-name)
+  "A function generating a file name to save articles in Unix mail format.
+The function is called with NEWSGROUP, HEADERS, and optional LAST-FILE.")
+
+(defvar gnus-folder-save-name (function gnus-folder-save-name)
+  "A function generating a file name to save articles in MH folder.
+The function is called with NEWSGROUP, HEADERS, and optional LAST-FOLDER.")
+
+(defvar gnus-file-save-name (function gnus-numeric-save-name)
+  "A function generating a file name to save articles in article format.
+The function is called with NEWSGROUP, HEADERS, and optional LAST-FILE.")
+
+(defvar gnus-kill-file-name "KILL"
+  "File name of a KILL file.")
+
+(defvar gnus-default-distribution "local"
+  "*Use this value as distribution if no distribution is specified.")
+
+(defvar gnus-novice-user t
+  "*Non-nil means that you are a novice to USENET.
+If non-nil, verbose messages may be displayed or your confirmation
+may be required.")
+
+(defvar gnus-interactive-post t
+  "*Newsgroup, subject, and distribution will be asked for if non-nil.")
+
+(defvar gnus-user-login-name nil
+  "*The login name of the user.
+Uses USER and LOGNAME environment variables if undefined.")
+
+(defvar gnus-user-full-name nil
+  "*The full name of the user.
+Uses from the NAME environment variable if undefined.")
+
+(defvar gnus-show-threads t
+  "*Show conversation threads in Subject Mode if non-nil.")
+
+(defvar gnus-thread-hide-subject t
+  "*Non-nil means hide subjects for thread subtrees.")
+
+(defvar gnus-thread-hide-subtree nil
+  "*Non-nil means hide thread subtrees initially.
+If non-nil, you have to run the command `gnus-Subject-show-thread' by
+hand or by using `gnus-Select-article-hook' to show hidden threads.")
+
+(defvar gnus-thread-hide-killed t
+  "*Non-nil means hide killed thread subtrees automatically.")
+
+(defvar gnus-thread-ignore-subject nil
+  "*Don't take care of subject differences, but only references if non-nil.
+If it is non-nil, some commands work with subjects do not work properly.")
+
+(defvar gnus-thread-indent-level 4
+  "Indentation of thread subtrees.")
+
+(defvar gnus-ignored-headers
+  "^Path:\\|^Posting-Version:\\|^Article-I.D.:\\|^Expires:\\|^Date-Received:\\|^References:\\|^Control:\\|^Xref:\\|^Lines:\\|^Posted:\\|^Relay-Version:\\|^Message-ID:\\|^Nf-ID:\\|^Nf-From:\\|^Approved:\\|^Sender:\\|^In-Reply-To:"
+  "Regexp matching headers not to display in messages.")
+
+(defvar gnus-show-all-headers nil
+  "*Show all headers of an article if non-nil.")
+
+(defvar gnus-save-all-headers nil
+  "*Save all headers of an article if non-nil.")
+
+(defvar gnus-optional-headers (function gnus-optional-lines-and-from)
+  "A function generating a optional string displayed in GNUS Subject
+mode buffer.  The function is called with an article HEADER. The
+result must be a string excluding `[' and `]'.")
+
+(defvar gnus-auto-extend-newsgroup t
+  "*Extend visible articles to forward and backward if non-nil.")
+
+(defvar gnus-auto-select-first t
+  "*Select the first unread article automagically if non-nil.
+If you want to prevent automatic selection of the first unread article
+in some newsgroups, set the variable to nil in `gnus-Select-group-hook'
+or `gnus-Apply-kill-hook'.")
+
+(defvar gnus-auto-select-next t
+  "*Select the next newsgroup automagically if non-nil.
+If the value is t and the next newsgroup is empty, GNUS will exit
+Subject mode and go back to Group mode.  If the value is neither nil
+nor t, GNUS will select the following unread newsgroup. Especially, if
+the value is the symbol `quietly', the next unread newsgroup will be
+selected without any confirmations.")
+
+(defvar gnus-auto-select-same nil
+  "*Select the next article with the same subject automagically if non-nil.")
+
+(defvar gnus-auto-center-subject t
+  "*Always center the current subject in GNUS Subject mode window if non-nil.")
+
+(defvar gnus-break-pages t
+  "*Break an article into pages if non-nil.
+Page delimiter is specified by the variable `gnus-page-delimiter'.")
+
+(defvar gnus-page-delimiter "^\^L"
+  "*Regexp describing line-beginnings that separate pages of news article.")
+
+(defvar gnus-digest-show-summary t
+  "*Show a summary of undigestified messages if non-nil.")
+
+(defvar gnus-digest-separator "^Subject:[ \t]"
+  "*Regexp that separates messages in a digest article.")
+
+(defvar gnus-use-full-window t
+  "*Non-nil means to take up the entire screen of Emacs.")
+
+(defvar gnus-window-configuration
+  '((SelectNewsgroup (0 1 0))
+    (ExitNewsgroup   (1 0 0))
+    (SelectArticle   (0 3 10))
+    (ExpandSubject   (0 1 0)))
+  "Specify window configurations for each action.
+The format of the variable is a list of (ACTION (G S A)), where
+G, S, and A are the relative height of Group, Subject, and Article
+windows, respectively.  ACTION is `SelectNewsgroup', `ExitNewsgroup',
+`SelectArticle', or `ExpandSubject'.")
+
+(defvar gnus-mail-reply-method
+  (function gnus-mail-reply-using-mail)
+  "A function to compose reply mail.
+The function `gnus-mail-reply-using-mail' uses usual the sendmail mail
+program.  The function `gnus-mail-reply-using-mhe' uses the mh-e mail
+program.  You can use yet another program by customizing this variable.")
+
+(defvar gnus-mail-other-window-method
+  (function gnus-mail-other-window-using-mail)
+  "A function to compose mail in other window.
+The function `gnus-mail-other-window-using-mail' uses usual sendmail
+mail program.  The function `gnus-mail-other-window-using-mhe' uses mh-e
+mail program.  You can use yet another program by customizing this variable.")
+
+(defvar gnus-subscribe-newsgroup-method
+  (function
+   (lambda (newsgroup)
+     (gnus-subscribe-newsgroup newsgroup
+                               (car (car gnus-newsrc-assoc)))))
+  "A function called with a newsgroup name when it is created.")
+
+(defvar gnus-Group-mode-hook nil
+  "A hook for GNUS Group Mode.")
+
+(defvar gnus-Subject-mode-hook nil
+  "A hook for GNUS Subject Mode.")
+
+(defvar gnus-Article-mode-hook nil
+  "A hook for GNUS Article Mode.")
+
+(defvar gnus-Kill-file-mode-hook nil
+  "A hook for GNUS KILL File Mode.")
+
+(defvar gnus-Open-server-hook nil
+  "A hook called just before opening connection to news server.")
+
+(defvar gnus-Startup-hook nil
+  "A hook called at start up time.
+This hook is called after GNUS is connected to the NNTP server.
+So, it is possible to change the behavior of GNUS according to the
+selected NNTP server.")
+
+(defvar gnus-Group-prepare-hook nil
+  "A hook called after newsgroup list is created in the Newsgroup buffer.
+If you want to modify the Newsgroup buffer, you can use this hook.")
+
+(defvar gnus-Subject-prepare-hook nil
+  "A hook called after subject list is created in the Subject buffer.
+If you want to modify the Subject buffer, you can use this hook.")
+
+(defvar gnus-Article-prepare-hook nil
+  "A hook called after an article is prepared in the Article buffer.
+If you want to run a special decoding program like nkf, use this hook.")
+
+(defvar gnus-Select-group-hook nil
+  "A hook called when a newsgroup is selected.
+If you want to sort Subject buffer by date and then by subject, you
+can use the following hook:
+
+(setq gnus-Select-group-hook
+      '(lambda ()
+         ;; First of all, sort by date.
+         (gnus-sort-headers
+          '(lambda (a b)
+             (gnus-date-lessp (gnus-header-date a)
+                              (gnus-header-date b))))
+         ;; Then sort by subject string ignoring `Re:'.
+         ;; If case-fold-search is non-nil, case of letters is ignored.
+         (gnus-sort-headers
+          '(lambda (a b)
+             (gnus-string-lessp
+              (gnus-simplify-subject (gnus-header-subject a) 're)
+              (gnus-simplify-subject (gnus-header-subject b) 're)
+              )))))
+
+If you'd like to simplify subjects like the `gnus-Subject-next-same-subject'
+command does, you can use the following hook:
+
+(setq gnus-Select-group-hook
+      '(lambda ()
+         (mapcar (function
+                  (lambda (header)
+                    (nntp-set-header-subject
+                     header
+                     (gnus-simplify-subject
+                      (gnus-header-subject header) 're-only))))
+                 gnus-newsgroup-headers)))
+
+In some newsgroups author name is meaningless.  It is possible to
+prevent listing author names in the GNUS Subject buffer as follows:
+
+(setq gnus-Select-group-hook
+      '(lambda ()
+         (cond ((string-equal \"comp.sources.unix\" gnus-newsgroup-name)
+                (setq gnus-optional-headers
+                      (function gnus-optional-lines)))
+               (t
+                (setq gnus-optional-headers
+                      (function gnus-optional-lines-and-from))))))")
+
+(defvar gnus-Select-article-hook
+  (function (lambda () (gnus-Subject-show-thread)))
+  "Hook called when an article is selected.
+The default hook automatically shows conversation thread subtrees
+of the selected article as follows:
+
+(setq gnus-Select-article-hook
+      '(lambda ()
+         (gnus-Subject-show-thread)))
+
+If you'd like to run RMAIL on a digest article automagically, you can
+use the following hook:
+
+(setq gnus-Select-article-hook
+      '(lambda ()
+         (gnus-Subject-show-thread)
+         (cond ((string-equal \"comp.sys.sun\" gnus-newsgroup-name)
+                (gnus-Subject-rmail-digest))
+               ((and (string-equal \"comp.text\" gnus-newsgroup-name)
+                     (string-match \"^TeXhax Digest\"
+                                   (gnus-header-subject gnus-current-headers)))
+                (gnus-Subject-rmail-digest)
+                ))))")
+
+(defvar gnus-Select-digest-hook
+  (function
+   (lambda ()
+     ;; Reply-To: is required by `undigestify-rmail-message'.
+     (or (mail-position-on-field "Reply-to" t)
+         (progn
+           (mail-position-on-field "Reply-to")
+           (insert (gnus-fetch-field "From"))))))
+  "A hook called when reading digest messages using Rmail.
+This hook can be used to modify incomplete digest articles as follows
+(this is the default):
+
+(setq gnus-Select-digest-hook
+      '(lambda ()
+         ;; Reply-To: is required by `undigestify-rmail-message'.
+         (or (mail-position-on-field \"Reply-to\" t)
+             (progn
+               (mail-position-on-field \"Reply-to\")
+               (insert (gnus-fetch-field \"From\"))))))")
+
+(defvar gnus-Rmail-digest-hook nil
+  "A hook called when reading digest messages using Rmail.
+This hook is intended to customize Rmail mode for reading digest articles.")
+
+(defvar gnus-Apply-kill-hook (function gnus-apply-kill-file)
+  "A hook called when a newsgroup is selected and subject list is prepared.
+This hook is intended to apply a KILL file to the selected newsgroup.
+The function `gnus-apply-kill-file' is called defaultly.
+
+Since a general KILL file is too heavy to use for only a few
+newsgroups, we recommend you use a lighter hook function.  For
+example, if you'd like to apply a KILL file to articles which contains
+a string `rmgroup' in subject in newsgroup `control', you can use the
+following hook:
+
+(setq gnus-Apply-kill-hook
+      '(lambda ()
+         (cond ((string-match \"control\" gnus-newsgroup-name)
+                (gnus-kill \"Subject\" \"rmgroup\")
+                (gnus-expunge \"X\")))))")
+
+(defvar gnus-Mark-article-hook
+  (function
+   (lambda ()
+     (or (memq gnus-current-article gnus-newsgroup-marked)
+         (gnus-Subject-mark-as-read gnus-current-article))
+     (gnus-Subject-set-current-mark "+")))
+  "A hook called when an article is selected for the first time.
+The hook is intended to mark an article as read when it is selected.
+If you'd like to mark as unread (-) instead, use the following hook:
+
+(setq gnus-Mark-article-hook
+      '(lambda ()
+         (gnus-Subject-mark-as-unread gnus-current-article)
+         (gnus-Subject-set-current-mark \"+\")))")
+
+(defvar gnus-Inews-article-hook nil
+  "A hook called before posting an article.
+If you'd like to run a special encoding program, use this hook.")
+
+(defvar gnus-Exit-group-hook nil
+  "A hook called when exiting (not quitting) Subject mode.
+If your machine is so slow that exiting from Subject mode takes a
+long time, set the variable `gnus-newsgroup-headers' to nil.  This
+inhibits marking articles as read using cross-reference information.")
+
+(defvar gnus-Suspend-gnus-hook nil
+  "A hook called when suspending (not exiting) GNUS.")
+
+(defvar gnus-Exit-gnus-hook nil
+  "A hook called when exiting (not suspending) GNUS.")
+
+(defvar gnus-Save-newsrc-hook nil
+  "A hook called when saving the newsrc file.
+This hook is called before saving .newsrc file.")
+
+(defvar gnus-your-domain nil
+  "*Your domain name without your host name like: \"stars.flab.Fujitsu.CO.JP\"
+The environment variable DOMAINNAME is used instead if defined.  If
+the function `system-name' returns the full internet name, there is no
+need to define this variable.")
+
+(defvar gnus-your-organization nil
+  "*Your organization like: \"Fujitsu Laboratories Ltd., Kawasaki, Japan.\"
+The `ORGANIZATION' environment variable is used instead if defined.")
+
+(defvar gnus-use-generic-from nil
+  "*If nil, prepend local host name to the defined domain in the From:
+field; if stringp, use this; if non-nil, strip of the local host name.")
+
+(defvar gnus-use-generic-path nil
+  "*If nil, use the NNTP server name in the Path: field; if stringp,
+use this; if non-nil, use no host name (user name only)")
+
+;; Internal variables.
+
+(defconst gnus-version "GNUS 3.13"
+  "Version numbers of this version of GNUS.")
+
+(defvar gnus-Info-nodes
+  '((gnus-Group-mode . "(gnus)Newsgroup Commands")
+    (gnus-Subject-mode . "(gnus)Subject Commands")
+    (gnus-Article-mode . "(gnus)Article Commands")
+    (gnus-Kill-file-mode . "(gnus)KILL File")
+    (gnus-Browse-killed-mode . "(gnus)Maintenance"))
+  "Assoc list of major modes and related Info nodes.")
+
+(defvar gnus-access-methods
+  '((nntp
+     (gnus-retrieve-headers .   nntp-retrieve-headers)
+     (gnus-open-server .        nntp-open-server)
+     (gnus-close-server .       nntp-close-server)
+     (gnus-server-opened .      nntp-server-opened)
+     (gnus-status-message .     nntp-status-message)
+     (gnus-request-article .    nntp-request-article)
+     (gnus-request-group .      nntp-request-group)
+     (gnus-request-list .       nntp-request-list)
+     (gnus-request-post .       nntp-request-post))
+    (nnspool
+     (gnus-retrieve-headers .   nnspool-retrieve-headers)
+     (gnus-open-server .        nnspool-open-server)
+     (gnus-close-server .       nnspool-close-server)
+     (gnus-server-opened .      nnspool-server-opened)
+     (gnus-status-message .     nnspool-status-message)
+     (gnus-request-article .    nnspool-request-article)
+     (gnus-request-group .      nnspool-request-group)
+     (gnus-request-list .       nnspool-request-list)
+     (gnus-request-post .       nnspool-request-post))
+    (mhspool
+     (gnus-retrieve-headers .   mhspool-retrieve-headers)
+     (gnus-open-server .        mhspool-open-server)
+     (gnus-close-server .       mhspool-close-server)
+     (gnus-server-opened .      mhspool-server-opened)
+     (gnus-status-message .     mhspool-status-message)
+     (gnus-request-article .    mhspool-request-article)
+     (gnus-request-group .      mhspool-request-group)
+     (gnus-request-list .       mhspool-request-list)
+     (gnus-request-post .       mhspool-request-post)))
+  "Access method for NNTP, nnspool, and mhspool.")
+
+(defvar gnus-Group-buffer "*Newsgroup*")
+(defvar gnus-Subject-buffer "*Subject*")
+(defvar gnus-Article-buffer "*Article*")
+(defvar gnus-Digest-buffer "GNUS Digest")
+(defvar gnus-Digest-summary-buffer "GNUS Digest-summary")
+
+(defvar gnus-buffer-list
+  (list gnus-Group-buffer gnus-Subject-buffer gnus-Article-buffer
+        gnus-Digest-buffer gnus-Digest-summary-buffer)
+  "GNUS buffer names which should be killed when exiting.")
+
+(defvar gnus-variable-list
+  '(gnus-newsrc-options
+    gnus-newsrc-options-n-yes gnus-newsrc-options-n-no
+    gnus-newsrc-assoc gnus-killed-assoc gnus-marked-assoc)
+  "GNUS variables saved in the quick startup file.")
+
+(defvar gnus-overload-functions
+  '((news-inews gnus-inews-news "rnewspost")
+    (caesar-region gnus-caesar-region "rnews"))
+  "Functions overloaded by gnus.
+It is a list of `(original overload &optional file)'.")
+
+(defvar gnus-newsrc-options nil
+  "Options line in the .newsrc file.")
+
+(defvar gnus-newsrc-options-n-yes nil
+  "Regexp representing subscribed newsgroups.")
+
+(defvar gnus-newsrc-options-n-no nil
+  "Regexp representing unsubscribed newsgroups.")
+
+(defvar gnus-newsrc-assoc nil
+  "Assoc list of read articles.")
+
+(defvar gnus-killed-assoc nil
+  "Assoc list of newsgroups removed from `gnus-newsrc-assoc'.")
+
+(defvar gnus-marked-assoc nil
+  "Assoc list of articles marked as unread.")
+
+(defvar gnus-unread-hashtb nil
+  "Hashtable of unread articles.")
+
+(defvar gnus-active-hashtb nil
+  "Hashtable of active articles.")
+
+(defvar gnus-octive-hashtb nil
+  "Hashtable of OLD active articles.")
+
+(defvar gnus-current-startup-file nil
+  "Startup file for the current host.")
+
+(defvar gnus-last-search-regexp nil
+  "Default regexp for article search command.")
+
+(defvar gnus-last-shell-command nil
+  "Default shell command on article.")
+
+(defvar gnus-have-all-newsgroups nil)
+
+(defvar gnus-newsgroup-name nil)
+(defvar gnus-newsgroup-begin nil)
+(defvar gnus-newsgroup-end nil)
+(defvar gnus-newsgroup-last-rmail nil)
+(defvar gnus-newsgroup-last-mail nil)
+(defvar gnus-newsgroup-last-folder nil)
+(defvar gnus-newsgroup-last-file nil)
+
+(defvar gnus-newsgroup-unreads nil
+  "List of unread articles in the current newsgroup.")
+
+(defvar gnus-newsgroup-unselected nil
+  "List of unselected unread articles in the current newsgroup.")
+
+(defvar gnus-newsgroup-marked nil
+  "List of marked articles in the current newsgroup (a subset of unread art).")
+
+(defvar gnus-newsgroup-headers nil
+  "List of article headers in the current newsgroup.")
+
+(defvar gnus-current-article nil)
+(defvar gnus-current-headers nil)
+(defvar gnus-current-history nil)
+(defvar gnus-have-all-headers nil)
+(defvar gnus-last-article nil)
+(defvar gnus-current-kill-article nil)
+
+;; Save window configuration.
+(defvar gnus-winconf-kill-file nil)
+
+(defvar gnus-Group-mode-map nil)
+(defvar gnus-Subject-mode-map nil)
+(defvar gnus-Article-mode-map nil)
+(defvar gnus-Kill-file-mode-map nil)
+
+(defvar rmail-last-file (expand-file-name "~/XMBOX"))
+(defvar rmail-last-rmail-file (expand-file-name "~/XNEWS"))
+
+;; Define GNUS Subsystems.
+(autoload 'gnus-Group-post-news "gnuspost"
+          "Post an article." t)
+(autoload 'gnus-Subject-post-news "gnuspost"
+          "Post an article." t)
+(autoload 'gnus-Subject-post-reply "gnuspost"
+          "Post a reply article." t)
+(autoload 'gnus-Subject-post-reply-with-original "gnuspost"
+          "Post a reply article with original article." t)
+(autoload 'gnus-Subject-cancel-article "gnuspost"
+          "Cancel an article you posted." t)
+
+(autoload 'gnus-Subject-mail-reply "gnusmail"
+          "Reply mail to news author." t)
+(autoload 'gnus-Subject-mail-reply-with-original "gnusmail"
+          "Reply mail to news author with original article." t)
+(autoload 'gnus-Subject-mail-other-window "gnusmail"
+          "Compose mail in other window." t)
+
+(autoload 'gnus-Group-kill-group "gnusmisc"
+          "Kill newsgroup on current line." t)
+(autoload 'gnus-Group-yank-group "gnusmisc"
+          "Yank the last killed newsgroup on current line." t)
+(autoload 'gnus-Browse-killed-groups "gnusmisc"
+          "Browse the killed newsgroups." t)
+
+(autoload 'rmail-output "rmailout"
+          "Append this message to Unix mail file named FILE-NAME." t)
+(autoload 'mail-position-on-field "sendmail")
+(autoload 'mh-find-path "mh-e")
+(autoload 'mh-prompt-for-folder "mh-e")
+
+(put 'gnus-Group-mode 'mode-class 'special)
+(put 'gnus-Subject-mode 'mode-class 'special)
+(put 'gnus-Article-mode 'mode-class 'special)
+
+
+;;(put 'gnus-eval-in-buffer-window 'lisp-indent-function 1)
+
+(defmacro gnus-eval-in-buffer-window (buffer &rest forms)
+  "Pop to BUFFER, evaluate FORMS, and then returns to original window."
+  (` (let ((GNUSStartBufferWindow (selected-window)))
+       (unwind-protect
+           (progn
+             (pop-to-buffer (, buffer))
+             (,@ forms))
+         (select-window GNUSStartBufferWindow)))))
+
+(defmacro gnus-make-hashtable ()
+  '(make-abbrev-table))
+
+(defmacro gnus-gethash (string hashtable)
+  "Get hash value of STRING in HASHTABLE."
+  ;;(` (symbol-value (abbrev-symbol (, string) (, hashtable))))
+  (` (abbrev-expansion (, string) (, hashtable))))
+
+(defmacro gnus-sethash (string value hashtable)
+  "Set hash value. Arguments are STRING, VALUE, and HASHTABLE."
+  ;; We cannot use define-abbrev since it only accepts string as value.
+  (` (set (intern (, string) (, hashtable)) (, value))))
+
+;; Note: Macros defined here are also defined in nntp.el. I don't like
+;; to put them here, but many users got troubled with the old
+;; definitions in nntp.elc. These codes are NNTP 3.10 version.
+
+(defmacro nntp-header-number (header)
+  "Return article number in HEADER."
+  (` (aref (, header) 0)))
+
+(defmacro nntp-set-header-number (header number)
+  "Set article number of HEADER to NUMBER."
+  (` (aset (, header) 0 (, number))))
+
+(defmacro nntp-header-subject (header)
+  "Return subject string in HEADER."
+  (` (aref (, header) 1)))
+
+(defmacro nntp-set-header-subject (header subject)
+  "Set article subject of HEADER to SUBJECT."
+  (` (aset (, header) 1 (, subject))))
+
+(defmacro nntp-header-from (header)
+  "Return author string in HEADER."
+  (` (aref (, header) 2)))
+
+(defmacro nntp-set-header-from (header from)
+  "Set article author of HEADER to FROM."
+  (` (aset (, header) 2 (, from))))
+
+(defmacro nntp-header-xref (header)
+  "Return xref string in HEADER."
+  (` (aref (, header) 3)))
+
+(defmacro nntp-set-header-xref (header xref)
+  "Set article xref of HEADER to xref."
+  (` (aset (, header) 3 (, xref))))
+
+(defmacro nntp-header-lines (header)
+  "Return lines in HEADER."
+  (` (aref (, header) 4)))
+
+(defmacro nntp-set-header-lines (header lines)
+  "Set article lines of HEADER to LINES."
+  (` (aset (, header) 4 (, lines))))
+
+(defmacro nntp-header-date (header)
+  "Return date in HEADER."
+  (` (aref (, header) 5)))
+
+(defmacro nntp-set-header-date (header date)
+  "Set article date of HEADER to DATE."
+  (` (aset (, header) 5 (, date))))
+
+(defmacro nntp-header-id (header)
+  "Return Id in HEADER."
+  (` (aref (, header) 6)))
+
+(defmacro nntp-set-header-id (header id)
+  "Set article Id of HEADER to ID."
+  (` (aset (, header) 6 (, id))))
+
+(defmacro nntp-header-references (header)
+  "Return references in HEADER."
+  (` (aref (, header) 7)))
+
+(defmacro nntp-set-header-references (header ref)
+  "Set article references of HEADER to REF."
+  (` (aset (, header) 7 (, ref))))
+
+
+;;;
+;;; GNUS Group Mode
+;;;
+
+(if gnus-Group-mode-map
+    nil
+  (setq gnus-Group-mode-map (make-keymap))
+  (suppress-keymap gnus-Group-mode-map)
+  (define-key gnus-Group-mode-map " " 'gnus-Group-read-group)
+  (define-key gnus-Group-mode-map "=" 'gnus-Group-select-group)
+  (define-key gnus-Group-mode-map "j" 'gnus-Group-jump-to-group)
+  (define-key gnus-Group-mode-map "n" 'gnus-Group-next-unread-group)
+  (define-key gnus-Group-mode-map "p" 'gnus-Group-prev-unread-group)
+  (define-key gnus-Group-mode-map "\177" 'gnus-Group-prev-unread-group)
+  (define-key gnus-Group-mode-map "N" 'gnus-Group-next-group)
+  (define-key gnus-Group-mode-map "P" 'gnus-Group-prev-group)
+  (define-key gnus-Group-mode-map "\C-n" 'gnus-Group-next-group)
+  (define-key gnus-Group-mode-map "\C-p" 'gnus-Group-prev-group)
+  (define-key gnus-Group-mode-map "\r" 'next-line)
+  (define-key gnus-Group-mode-map "/" 'isearch-forward)
+  (define-key gnus-Group-mode-map "<" 'beginning-of-buffer)
+  (define-key gnus-Group-mode-map ">" 'end-of-buffer)
+  (define-key gnus-Group-mode-map "u" 'gnus-Group-unsubscribe-current-group)
+  (define-key gnus-Group-mode-map "U" 'gnus-Group-unsubscribe-group)
+  (define-key gnus-Group-mode-map "c" 'gnus-Group-catch-up)
+  (define-key gnus-Group-mode-map "C" 'gnus-Group-catch-up-all)
+  (define-key gnus-Group-mode-map "l" 'gnus-Group-list-groups)
+  (define-key gnus-Group-mode-map "L" 'gnus-Group-list-all-groups)
+  (define-key gnus-Group-mode-map "g" 'gnus-Group-get-new-news)
+  (define-key gnus-Group-mode-map "R" 'gnus-Group-restart)
+  (define-key gnus-Group-mode-map "b" 'gnus-Group-check-bogus-groups)
+  (define-key gnus-Group-mode-map "r" 'gnus-Group-restrict-groups)
+  (define-key gnus-Group-mode-map "a" 'gnus-Group-post-news)
+  (define-key gnus-Group-mode-map "\ek" 'gnus-Group-edit-local-kill)
+  (define-key gnus-Group-mode-map "\eK" 'gnus-Group-edit-global-kill)
+  (define-key gnus-Group-mode-map "\C-k" 'gnus-Group-kill-group)
+  (define-key gnus-Group-mode-map "\C-y" 'gnus-Group-yank-group)
+  (define-key gnus-Group-mode-map "\C-c\C-y" 'gnus-Browse-killed-groups)
+  (define-key gnus-Group-mode-map "V" 'gnus-version)
+  (define-key gnus-Group-mode-map "x" 'gnus-Group-force-update)
+  (define-key gnus-Group-mode-map "s" 'gnus-Group-force-update)
+  (define-key gnus-Group-mode-map "z" 'gnus-Group-suspend)
+  (define-key gnus-Group-mode-map "q" 'gnus-Group-exit)
+  (define-key gnus-Group-mode-map "Q" 'gnus-Group-quit)
+  (define-key gnus-Group-mode-map "?" 'gnus-Group-describe-briefly)
+  (define-key gnus-Group-mode-map "\C-c\C-i" 'gnus-Info-find-node))
+
+(defun gnus-Group-mode ()
+  "Major mode for reading network news.
+All normal editing commands are turned off.
+Instead, these commands are available:
+\\{gnus-Group-mode-map}
+
+  The name of the host running NNTP server is asked for if no default
+host is specified. It is also possible to choose another NNTP server
+even when the default server is defined by giving a prefix argument to
+the command `\\[gnus]'.
+
+  If an NNTP server is preceded by a colon such as `:Mail', the user's
+private directory `~/Mail' is used as a news spool. This makes it
+possible to read mail stored in MH folders or articles saved by GNUS.
+File names of mail or articles must consist of only numeric
+characters. Otherwise, they are ignored.
+
+  If there is a file named `~/.newsrc-SERVER', it is used as the
+startup file instead of standard one when talking to SERVER.  It is
+possible to talk to many hosts by using different startup files for
+each.
+
+  Option `-n' of the options line in the startup file is recognized
+properly the same as the Bnews system. For example, if the options
+line is `options -n !talk talk.rumors', newsgroups under the `talk'
+hierarchy except for `talk.rumors' are ignored while checking new
+newsgroups.
+
+  If there is a file named `~/.signature-DISTRIBUTION', it is used as
+signature file instead of standard one when posting a news in
+DISTRIBUTION.
+
+  If an Info file generated from `gnus.texinfo' is installed, you can
+read an appropriate Info node of the Info file according to the
+current major mode of GNUS by \\[gnus-Info-find-node].
+
+  The variable `gnus-version', `nntp-version', `nnspool-version', and
+`mhspool-version' have the version numbers of this version of gnus.el,
+nntp.el, nnspool.el, and mhspoo.el, respectively.
+
+User customizable variables:
+ gnus-nntp-server
+    Specifies the name of the host running the NNTP server. If its
+    value is a string such as `:DIRECTORY', the user's private
+    DIRECTORY is used as a news spool. The variable is initialized
+    from the NNTPSERVER environment variable.
+
+ gnus-nntp-service
+    Specifies a NNTP service name. It is usually \"nntp\" or 119.  Nil
+    forces GNUS to use a local news spool if the variable
+    `gnus-nntp-server' is set to the local host name.
+
+ gnus-startup-file
+    Specifies a startup file (.newsrc). If there is a file named
+    `.newsrc-SERVER', it's used instead when talking to SERVER. I
+    recommend you to use the server specific file, if you'd like to
+    talk to many servers.  Especially if you'd like to read your
+    private directory, the name of the file must be
+    `.newsrc-:DIRECTORY'.
+
+ gnus-signature-file
+    Specifies a signature file (.signature). If there is a file named
+    `.signature-DISTRIBUTION', it's used instead when posting an
+    article in DISTRIBUTION. Set the variable to nil to prevent
+    appending the file automatically. If you use an NNTP inews which
+    comes with the NNTP package, you may have to set the variable to
+    nil.
+
+ gnus-use-cross-reference
+    Specifies what to do with cross references (Xref: field).  If it
+    is nil, cross references are ignored.  If it is t, articles in
+    subscribed newsgroups are only marked as read.  Otherwise, if it
+    is not nil nor t, articles in all newsgroups are marked as read.
+
+ gnus-use-followup-to
+    Specifies what to do with followup-to: field.  If it is nil, its
+    value is ignored.  If it is non-nil, its value is used as followup
+    newsgroups.  Especially, if it is t and field value is `poster',
+    your confirmation is required.
+
+ gnus-author-copy
+    Specifies a file name to save a copy of article you posted using
+    FCC: field.  If the first character of the value is `|', the
+    contents of the article is piped out to a program specified by the
+    rest of the value.  The variable is initialized from the
+    AUTHORCOPY environment variable.
+
+ gnus-author-copy-saver
+    Specifies a function to save an author copy.  The function is
+    called with a file name.  The default function `rmail-output'
+    saves in Unix mail format.
+
+ gnus-kill-file-name
+    Use specified file name as a KILL file (default to `KILL').
+
+ gnus-novice-user
+    Non-nil means that you are a novice to USENET.  If non-nil,
+    verbose messages may be displayed or your confirmations may be
+    required.
+
+ gnus-interactive-post
+    Non-nil means that newsgroup, subject and distribution are asked
+    for interactively when posting a new article.
+
+ gnus-use-full-window
+    Non-nil means to take up the entire screen of Emacs.
+
+ gnus-window-configuration
+    Specifies the configuration of Group, Subject, and Article
+    windows.  It is a list of (ACTION (G S A)), where G, S, and A are
+    the relative height of Group, Subject, and Article windows,
+    respectively.  ACTION is `SelectNewsgroup', `ExitNewsgroup',
+    `SelectArticle', or `ExpandSubject'.
+
+ gnus-subscribe-newsgroup-method
+    Specifies a function called with a newsgroup name when new
+    newsgroup is found.  The default definition adds new newsgroup at
+    the beginning of other newsgroups.
+
+Various hooks for customization:
+ gnus-Group-mode-hook
+    Entry to this mode calls the value with no arguments, if that
+    value is non-nil. This hook is called before GNUS is connected to
+    the NNTP server. So, you can change or define the NNTP server in
+    this hook.
+
+ gnus-Startup-hook
+    Called with no arguments after the NNTP server is selected. It is
+    possible to change the behavior of GNUS or initialize the
+    variables according to the selected NNTP server.
+
+ gnus-Group-prepare-hook
+    Called with no arguments after a newsgroup list is created in the
+    Newsgroup buffer, if that value is non-nil.
+
+ gnus-Save-newsrc-hook
+    Called with no arguments when saving newsrc file if that value is
+    non-nil.
+
+ gnus-Inews-article-hook
+    Called with no arguments when posting an article if that value is
+    non-nil. This hook is called just before posting an article, while
+    `news-inews-hook' is called before preparing article headers. If
+    you'd like to convert kanji code of the article, this hook is recommended.
+
+ gnus-Suspend-gnus-hook
+    Called with no arguments when suspending (not exiting) GNUS, if
+    that value is non-nil.
+
+ gnus-Exit-gnus-hook
+    Called with no arguments when exiting (not suspending) GNUS, if
+    that value is non-nil."
+  (interactive)
+  (kill-all-local-variables)
+  ;; Gee.  Why don't you upgrade?
+  (cond ((boundp 'mode-line-modified)
+         (setq mode-line-modified "--- "))
+        ((listp (default-value 'mode-line-format))
+         (setq mode-line-format
+               (cons "--- " (cdr (default-value 'mode-line-format)))))
+        (t
+         (setq mode-line-format
+               "--- GNUS: List of Newsgroups  %[(%m)%]----%3p-%-")))
+  (setq major-mode 'gnus-Group-mode)
+  (setq mode-name "Newsgroup")
+  (setq mode-line-buffer-identification "GNUS: List of Newsgroups")
+  (setq mode-line-process nil)
+  (use-local-map gnus-Group-mode-map)
+  (buffer-flush-undo (current-buffer))
+  (setq buffer-read-only t)             ;Disable modification
+  (run-hooks 'gnus-Group-mode-hook))
+
+;;;###autoload
+(defun gnus (&optional confirm)
+  "Read network news.
+If optional argument CONFIRM is non-nil, ask NNTP server."
+  (interactive "P")
+  (unwind-protect
+      (progn
+        (switch-to-buffer (get-buffer-create gnus-Group-buffer))
+        (gnus-Group-mode)
+        (gnus-start-news-server confirm))
+    (if (not (gnus-server-opened))
+        (gnus-Group-quit)
+      ;; NNTP server is successfully open. 
+      (setq mode-line-process (format " {%s}" gnus-nntp-server))
+      (let ((buffer-read-only nil))
+        (erase-buffer)
+        (gnus-Group-startup-message)
+        (sit-for 0))
+      (run-hooks 'gnus-Startup-hook)
+      (gnus-setup-news-info)
+      (if gnus-novice-user
+          (gnus-Group-describe-briefly)) ;Show brief help message.
+      (gnus-Group-list-groups nil)
+      )))
+
+(defun gnus-Group-startup-message ()
+  "Insert startup message in current buffer."
+  ;; Insert the message.
+  (insert "
+                   GNUS Version 3.13
+
+         NNTP-based News Reader for GNU Emacs
+
+
+If you have any trouble with this software, please let me
+know. I will fix your problems in the next release.
+
+Comments, suggestions, and bug fixes are welcome.
+
+Masanobu UMEDA
+umerin@tc.Nagasaki.GO.JP")
+  ;; And then hack it.
+  ;; 57 is the longest line.
+  (indent-rigidly (point-min) (point-max) (/ (max (- (window-width) 57) 0) 2))
+  (goto-char (point-min))
+  ;; +4 is fuzzy factor.
+  (insert-char ?\n (/ (max (- (window-height) 18) 0) 2)))
+
+(defun gnus-Group-list-groups (show-all)
+  "List newsgroups in the Newsgroup buffer.
+If argument SHOW-ALL is non-nil, unsubscribed groups are also listed."
+  (interactive "P")
+  (let ((last-group                     ;Current newsgroup.
+         (gnus-Group-group-name))
+        (next-group                     ;Next possible newsgroup.
+         (progn
+           (gnus-Group-search-forward nil nil)
+           (gnus-Group-group-name)))
+        (prev-group                     ;Previous possible newsgroup.
+         (progn
+           (gnus-Group-search-forward t nil)
+           (gnus-Group-group-name))))
+    (gnus-Group-prepare show-all)
+    (if (zerop (buffer-size))
+        (message "No news is good news")
+      ;; Go to last newsgroup if possible.  If cannot, try next and
+      ;; previous.  If all fail, go to first unread newsgroup.
+      (goto-char (point-min))
+      (or (and last-group
+               (re-search-forward
+                (concat "^.+: " (regexp-quote last-group) "$") nil t))
+          (and next-group
+               (re-search-forward
+                (concat "^.+: " (regexp-quote next-group) "$") nil t))
+          (and prev-group
+               (re-search-forward
+                (concat "^.+: " (regexp-quote prev-group) "$") nil t))
+          (re-search-forward "^[ \t]+[1-9][0-9]*:" nil t))
+      ;; Adjust cursor point.
+      (beginning-of-line)
+      (search-forward ":" nil t)
+      )))
+
+(defun gnus-Group-prepare (&optional all)
+  "Prepare list of newsgroups in current buffer.
+If optional argument ALL is non-nil, unsubscribed groups are also listed."
+  (let ((buffer-read-only nil)
+        (newsrc gnus-newsrc-assoc)
+        (group-info nil)
+        (group-name nil)
+        (unread-count 0)
+        ;; This specifies the format of Group buffer.
+        (cntl "%s%s%5d: %s\n"))
+    (erase-buffer)
+    ;; List newsgroups.
+    (while newsrc
+      (setq group-info (car newsrc))
+      (setq group-name (car group-info))
+      (setq unread-count (nth 1 (gnus-gethash group-name gnus-unread-hashtb)))
+      (if (or all
+              (and (nth 1 group-info)   ;Subscribed.
+                   (> unread-count 0))) ;There are unread articles.
+          ;; Yes, I can use gnus-Group-prepare-line, but this is faster.
+          (insert
+           (format cntl
+                   ;; Subscribed or not.
+                   (if (nth 1 group-info) " " "U")
+                   ;; Has new news?
+                   (if (and (> unread-count 0)
+                            (>= 0
+                                (- unread-count
+                                   (length
+                                    (cdr (assoc group-name
+                                                gnus-marked-assoc))))))
+                       "*" " ")
+                   ;; Number of unread articles.
+                   unread-count
+                   ;; Newsgroup name.
+                   group-name))
+        )
+      (setq newsrc (cdr newsrc))
+      )
+    (setq gnus-have-all-newsgroups all)
+    (goto-char (point-min))
+    (run-hooks 'gnus-Group-prepare-hook)
+    ))
+
+(defun gnus-Group-prepare-line (info)
+  "Return a string for the Newsgroup buffer from INFO.
+INFO is an element of gnus-newsrc-assoc or gnus-killed-assoc."
+  (let* ((group-name (car info))
+         (unread-count
+          (or (nth 1 (gnus-gethash group-name gnus-unread-hashtb))
+              ;; Not in hash table, so compute it now.
+              (gnus-number-of-articles
+               (gnus-difference-of-range
+                (nth 2 (gnus-gethash group-name gnus-active-hashtb))
+                (nthcdr 2 info)))))
+         ;; This specifies the format of Group buffer.
+         (cntl "%s%s%5d: %s\n"))
+    (format cntl
+            ;; Subscribed or not.
+            (if (nth 1 info) " " "U")
+            ;; Has new news?
+            (if (and (> unread-count 0)
+                     (>= 0
+                         (- unread-count
+                            (length
+                             (cdr (assoc group-name gnus-marked-assoc))))))
+                "*" " ")
+            ;; Number of unread articles.
+            unread-count
+            ;; Newsgroup name.
+            group-name
+            )))
+
+(defun gnus-Group-update-group (group &optional visible-only)
+  "Update newsgroup info of GROUP.
+If optional argument VISIBLE-ONLY is non-nil, non displayed group is ignored."
+  (let ((buffer-read-only nil)
+        (visible nil))
+    ;; Buffer may be narrowed.
+    (save-restriction
+      (widen)
+      ;; Search point to modify.
+      (goto-char (point-min))
+      (if (re-search-forward (concat "^.+: " (regexp-quote group) "$") nil t)
+          ;; GROUP is listed in current buffer. So, delete old line.
+          (progn
+            (setq visible t)
+            (beginning-of-line)
+            (delete-region (point) (progn (forward-line 1) (point)))
+            ))
+      (if (or visible (not visible-only))
+          (progn
+            (insert (gnus-Group-prepare-line (assoc group gnus-newsrc-assoc)))
+            (forward-line -1)           ;Move point on that line.
+            ))
+      )))
+
+;; GNUS Group mode command
+
+(defun gnus-Group-group-name ()
+  "Get newsgroup name around point."
+  (save-excursion
+    (beginning-of-line)
+    (if (looking-at ".[* \t]*[0-9]+:[ \t]+\\([^ \t\n]+\\)$")
+        (buffer-substring (match-beginning 1) (match-end 1))
+      )))
+
+(defun gnus-Group-read-group (all &optional no-article)
+  "Read news in this newsgroup.
+If argument ALL is non-nil, already read articles become readable.
+If optional argument NO-ARTICLE is non-nil, no article body is displayed."
+  (interactive "P")
+  (let ((group (gnus-Group-group-name))) ;Newsgroup name to read.
+    (if group
+        (gnus-Subject-read-group
+         group
+         (or all
+             ;;(not (nth 1 (assoc group gnus-newsrc-assoc)))    ;Unsubscribed
+             (zerop
+              (nth 1 (gnus-gethash group gnus-unread-hashtb)))) ;No unread
+         no-article
+         ))
+    ))
+
+(defun gnus-Group-select-group (all)
+  "Select this newsgroup.
+No article is selected automatically.
+If argument ALL is non-nil, already read articles become readable."
+  (interactive "P")
+  (gnus-Group-read-group all t))
+
+(defun gnus-Group-jump-to-group (group)
+  "Jump to newsgroup GROUP."
+  (interactive
+   (list (completing-read "Newsgroup: " gnus-newsrc-assoc nil 'require-match)))
+  (goto-char (point-min))
+  (or (re-search-forward (concat "^.+: " (regexp-quote group) "$") nil t)
+      (if (assoc group gnus-newsrc-assoc)
+          ;; Add GROUP entry, then seach again.
+          (gnus-Group-update-group group)))
+  ;; Adjust cursor point.
+  (beginning-of-line)
+  (search-forward ":" nil t))
+
+(defun gnus-Group-search-forward (backward any-group)
+  "Search for newsgroup forward.
+If first argument BACKWARD is non-nil, search backward instead.
+If second argument ANY-GROUP is non-nil, unsubscribed or empty
+group may be selected."
+  (let ((func (if backward 're-search-backward 're-search-forward))
+        (regexp 
+         (format "^%s[ \t]*\\(%s\\):"
+                 (if any-group ".." " [ \t]")
+                 (if any-group "[0-9]+" "[1-9][0-9]*")))
+        (found nil))
+    (if backward
+        (beginning-of-line)
+      (end-of-line))
+    (setq found (funcall func regexp nil t))
+    ;; Adjust cursor point.
+    (beginning-of-line)
+    (search-forward ":" nil t)
+    ;; Return T if found.
+    found
+    ))
+
+(defun gnus-Group-next-group (n)
+  "Go to next N'th newsgroup."
+  (interactive "p")
+  (while (and (> n 1)
+              (gnus-Group-search-forward nil t))
+    (setq n (1- n)))
+  (or (gnus-Group-search-forward nil t)
+      (message "No more newsgroups")))
+
+(defun gnus-Group-next-unread-group (n)
+  "Go to next N'th unread newsgroup."
+  (interactive "p")
+  (while (and (> n 1)
+              (gnus-Group-search-forward nil nil))
+    (setq n (1- n)))
+  (or (gnus-Group-search-forward nil nil)
+      (message "No more unread newsgroups")))
+
+(defun gnus-Group-prev-group (n)
+  "Go to previous N'th newsgroup."
+  (interactive "p")
+  (while (and (> n 1)
+              (gnus-Group-search-forward t t))
+    (setq n (1- n)))
+  (or (gnus-Group-search-forward t t)
+      (message "No more newsgroups")))
+
+(defun gnus-Group-prev-unread-group (n)
+  "Go to previous N'th unread newsgroup."
+  (interactive "p")
+  (while (and (> n 1)
+              (gnus-Group-search-forward t nil))              
+    (setq n (1- n)))
+  (or (gnus-Group-search-forward t nil)
+      (message "No more unread newsgroups")))
+
+(defun gnus-Group-catch-up (all &optional quietly)
+  "Mark all articles not marked as unread in current newsgroup as read.
+If prefix argument ALL is non-nil, all articles are marked as read.
+Cross references (Xref: field) of articles are ignored."
+  (interactive "P")
+  (let* ((group (gnus-Group-group-name))
+         (marked (if (not all)
+                     (cdr (assoc group gnus-marked-assoc)))))
+    (and group
+         (or quietly
+             (y-or-n-p
+              (if all
+                  "Do you really want to mark everything as read? "
+                "Delete all articles not marked as read? ")))
+         (progn
+           (message "")                 ;Erase "Yes or No" question.
+           ;; Any marked articles will be preserved.
+           (gnus-update-unread-articles group marked marked)
+           (gnus-Group-update-group group)
+           (gnus-Group-next-group 1)))
+    ))
+
+(defun gnus-Group-catch-up-all (&optional quietly)
+  "Mark all articles in current newsgroup as read.
+Cross references (Xref: field) of articles are ignored."
+  (interactive)
+  (gnus-Group-catch-up t quietly))
+
+(defun gnus-Group-unsubscribe-current-group ()
+  "Toggle subscribe from/to unsubscribe current group."
+  (interactive)
+  (gnus-Group-unsubscribe-group (gnus-Group-group-name))
+  (gnus-Group-next-group 1))
+
+(defun gnus-Group-unsubscribe-group (group)
+  "Toggle subscribe from/to unsubscribe GROUP.
+New newsgroup is added to .newsrc automatically."
+  (interactive
+   (list (completing-read "Newsgroup: "
+                          gnus-active-hashtb nil 'require-match)))
+  (let ((newsrc (assoc group gnus-newsrc-assoc)))
+    (cond ((not (null newsrc))
+           ;; Toggle subscription flag.
+           (setcar (nthcdr 1 newsrc) (not (nth 1 newsrc)))
+           (gnus-update-newsrc-buffer group)
+           (gnus-Group-update-group group)
+           ;; Adjust cursor point.
+           (beginning-of-line)
+           (search-forward ":" nil t))
+          ((and (stringp group)
+                (gnus-gethash group gnus-active-hashtb))
+           ;; Add new newsgroup.
+           (gnus-add-newsgroup group)
+           (gnus-Group-update-group group)
+           ;; Adjust cursor point.
+           (beginning-of-line)
+           (search-forward ":" nil t))
+          (t (error "No such newsgroup: %s" group)))
+    ))
+
+(defun gnus-Group-list-all-groups ()
+  "List all of newsgroups in the Newsgroup buffer."
+  (interactive)
+  (gnus-Group-list-groups t))
+
+(defun gnus-Group-get-new-news ()
+  "Get newly arrived articles.  In fact, read the active file again."
+  (interactive)
+  (gnus-setup-news-info)
+  (gnus-Group-list-groups gnus-have-all-newsgroups))
+
+(defun gnus-Group-restart ()
+  "Force GNUS to read the raw startup file."
+  (interactive)
+  (gnus-save-newsrc-file)
+  (gnus-setup-news-info t)              ;Force to read the raw startup file.
+  (gnus-Group-list-groups gnus-have-all-newsgroups))
+
+(defun gnus-Group-check-bogus-groups ()
+  "Check bogus newsgroups."
+  (interactive)
+  (gnus-check-bogus-newsgroups t)       ;Require confirmation.
+  (gnus-Group-list-groups gnus-have-all-newsgroups))
+
+(defun gnus-Group-restrict-groups (start end)
+  "Restrict visible newsgroups to the current region (START and END).
+Type \\[widen] to remove restriction."
+  (interactive "r")
+  (save-excursion
+    (narrow-to-region (progn
+                        (goto-char start)
+                        (beginning-of-line)
+                        (point))
+                      (progn
+                        (goto-char end)
+                        (forward-line 1)
+                        (point))))
+  (message (substitute-command-keys "Type \\[widen] to remove restriction")))
+
+(defun gnus-Group-edit-global-kill ()
+  "Edit a global KILL file."
+  (interactive)
+  (setq gnus-current-kill-article nil)  ;No articles selected.
+  (gnus-Kill-file-edit-file nil)        ;Nil stands for global KILL file.
+  (message
+   (substitute-command-keys
+    "Editing a global KILL file (Type \\[gnus-Kill-file-exit] to exit)")))
+
+(defun gnus-Group-edit-local-kill ()
+  "Edit a local KILL file."
+  (interactive)
+  (setq gnus-current-kill-article nil)  ;No articles selected.
+  (gnus-Kill-file-edit-file (gnus-Group-group-name))
+  (message
+   (substitute-command-keys
+    "Editing a local KILL file (Type \\[gnus-Kill-file-exit] to exit)")))
+
+(defun gnus-Group-force-update ()
+  "Update .newsrc file."
+  (interactive)
+  (gnus-save-newsrc-file))
+
+(defun gnus-Group-suspend ()
+  "Suspend the current GNUS session.
+In fact, cleanup buffers except for Group Mode buffer.
+The hook `gnus-Suspend-gnus-hook' is called before actually suspending."
+  (interactive)
+  (run-hooks 'gnus-Suspend-gnus-hook)
+  ;; Kill GNUS buffers except for Group Mode buffer.
+  (let ((buffers gnus-buffer-list))
+    (while buffers
+      (and (not (eq (car buffers) gnus-Group-buffer))
+           (get-buffer (car buffers))
+           (kill-buffer (car buffers)))
+      (setq buffers (cdr buffers))
+      ))
+  (bury-buffer))
+
+(defun gnus-Group-exit ()
+  "Quit reading news after updating .newsrc.
+The hook `gnus-Exit-gnus-hook' is called before actually quitting."
+  (interactive)
+  (if (or noninteractive                ;For gnus-batch-kill
+          (zerop (buffer-size))         ;No news is good news.
+          (not (gnus-server-opened))    ;NNTP connection closed.
+          (y-or-n-p "Are you sure you want to quit reading news? "))
+      (progn
+        (message "")                    ;Erase "Yes or No" question.
+        (run-hooks 'gnus-Exit-gnus-hook)
+        (gnus-save-newsrc-file)
+        (gnus-clear-system)
+        (gnus-close-server))
+    ))
+
+(defun gnus-Group-quit ()
+  "Quit reading news without updating .newsrc.
+The hook `gnus-Exit-gnus-hook' is called before actually quitting."
+  (interactive)
+  (if (or (zerop (buffer-size))
+          (not (gnus-server-opened))
+          (yes-or-no-p
+           (format "Quit reading news without saving %s? "
+                   (file-name-nondirectory gnus-current-startup-file))))
+      (progn
+        (message "")                    ;Erase "Yes or No" question.
+        (run-hooks 'gnus-Exit-gnus-hook)
+        (gnus-clear-system)
+        (gnus-close-server))
+    ))
+
+(defun gnus-Group-describe-briefly ()
+  "Describe Group mode commands briefly."
+  (interactive)
+  (message
+   (concat
+    (substitute-command-keys "\\[gnus-Group-read-group]:Select  ")
+    (substitute-command-keys "\\[gnus-Group-next-unread-group]:Forward  ")
+    (substitute-command-keys "\\[gnus-Group-prev-unread-group]:Backward  ")
+    (substitute-command-keys "\\[gnus-Group-exit]:Exit  ")
+    (substitute-command-keys "\\[gnus-Info-find-node]:Run Info  ")
+    (substitute-command-keys "\\[gnus-Group-describe-briefly]:This help")
+    )))
+
+
+;;;
+;;; GNUS Subject Mode
+;;;
+
+(if gnus-Subject-mode-map
+    nil
+  (setq gnus-Subject-mode-map (make-keymap))
+  (suppress-keymap gnus-Subject-mode-map)
+  (define-key gnus-Subject-mode-map " " 'gnus-Subject-next-page)
+  (define-key gnus-Subject-mode-map "\177" 'gnus-Subject-prev-page)
+  (define-key gnus-Subject-mode-map "\r" 'gnus-Subject-scroll-up)
+  (define-key gnus-Subject-mode-map "n" 'gnus-Subject-next-unread-article)
+  (define-key gnus-Subject-mode-map "p" 'gnus-Subject-prev-unread-article)
+  (define-key gnus-Subject-mode-map "N" 'gnus-Subject-next-article)
+  (define-key gnus-Subject-mode-map "P" 'gnus-Subject-prev-article)
+  (define-key gnus-Subject-mode-map "\e\C-n" 'gnus-Subject-next-same-subject)
+  (define-key gnus-Subject-mode-map "\e\C-p" 'gnus-Subject-prev-same-subject)
+  ;;(define-key gnus-Subject-mode-map "\e\C-n" 'gnus-Subject-next-unread-same-subject)
+  ;;(define-key gnus-Subject-mode-map "\e\C-p" 'gnus-Subject-prev-unread-same-subject)
+  (define-key gnus-Subject-mode-map "\C-c\C-n" 'gnus-Subject-next-digest)
+  (define-key gnus-Subject-mode-map "\C-c\C-p" 'gnus-Subject-prev-digest)
+  (define-key gnus-Subject-mode-map "\C-n" 'gnus-Subject-next-subject)
+  (define-key gnus-Subject-mode-map "\C-p" 'gnus-Subject-prev-subject)
+  (define-key gnus-Subject-mode-map "\en" 'gnus-Subject-next-unread-subject)
+  (define-key gnus-Subject-mode-map "\ep" 'gnus-Subject-prev-unread-subject)
+  ;;(define-key gnus-Subject-mode-map "\C-cn" 'gnus-Subject-next-group)
+  ;;(define-key gnus-Subject-mode-map "\C-cp" 'gnus-Subject-prev-group)
+  (define-key gnus-Subject-mode-map "." 'gnus-Subject-first-unread-article)
+  (define-key gnus-Subject-mode-map "/" 'isearch-forward)
+  (define-key gnus-Subject-mode-map "s" 'gnus-Subject-isearch-article)
+  (define-key gnus-Subject-mode-map "\es" 'gnus-Subject-search-article-forward)
+  (define-key gnus-Subject-mode-map "\eS" 'gnus-Subject-search-article-backward)
+  (define-key gnus-Subject-mode-map "<" 'gnus-Subject-beginning-of-article)
+  (define-key gnus-Subject-mode-map ">" 'gnus-Subject-end-of-article)
+  (define-key gnus-Subject-mode-map "j" 'gnus-Subject-goto-subject)
+  (define-key gnus-Subject-mode-map "J" 'gnus-Subject-goto-article)
+  (define-key gnus-Subject-mode-map "l" 'gnus-Subject-goto-last-article)
+  (define-key gnus-Subject-mode-map "^" 'gnus-Subject-refer-parent-article)
+  (define-key gnus-Subject-mode-map "\er" 'gnus-Subject-refer-article)
+  (define-key gnus-Subject-mode-map "u" 'gnus-Subject-mark-as-unread-forward)
+  (define-key gnus-Subject-mode-map "U" 'gnus-Subject-mark-as-unread-backward)
+  (define-key gnus-Subject-mode-map "d" 'gnus-Subject-mark-as-read-forward)
+  (define-key gnus-Subject-mode-map "D" 'gnus-Subject-mark-as-read-backward)
+  (define-key gnus-Subject-mode-map "\eu" 'gnus-Subject-clear-mark-forward)
+  (define-key gnus-Subject-mode-map "\eU" 'gnus-Subject-clear-mark-backward)
+  (define-key gnus-Subject-mode-map "k" 'gnus-Subject-kill-same-subject-and-select)
+  (define-key gnus-Subject-mode-map "\C-k" 'gnus-Subject-kill-same-subject)
+  (define-key gnus-Subject-mode-map "\e\C-t" 'gnus-Subject-toggle-threads)
+  (define-key gnus-Subject-mode-map "\e\C-s" 'gnus-Subject-show-thread)
+  (define-key gnus-Subject-mode-map "\e\C-h" 'gnus-Subject-hide-thread)
+  (define-key gnus-Subject-mode-map "\e\C-f" 'gnus-Subject-next-thread)
+  (define-key gnus-Subject-mode-map "\e\C-b" 'gnus-Subject-prev-thread)
+  (define-key gnus-Subject-mode-map "\e\C-u" 'gnus-Subject-up-thread)
+  (define-key gnus-Subject-mode-map "\e\C-d" 'gnus-Subject-down-thread)
+  (define-key gnus-Subject-mode-map "\e\C-k" 'gnus-Subject-kill-thread)
+  (define-key gnus-Subject-mode-map "&" 'gnus-Subject-execute-command)
+  ;;(define-key gnus-Subject-mode-map "c" 'gnus-Subject-catch-up)
+  ;;(define-key gnus-Subject-mode-map "c" 'gnus-Subject-catch-up-all)
+  (define-key gnus-Subject-mode-map "c" 'gnus-Subject-catch-up-and-exit)
+  ;;(define-key gnus-Subject-mode-map "c" 'gnus-Subject-catch-up-all-and-exit)
+  (define-key gnus-Subject-mode-map "\C-t" 'gnus-Subject-toggle-truncation)
+  (define-key gnus-Subject-mode-map "x" 'gnus-Subject-delete-marked-as-read)
+  (define-key gnus-Subject-mode-map "X" 'gnus-Subject-delete-marked-with)
+  (define-key gnus-Subject-mode-map "\C-c\C-sn" 'gnus-Subject-sort-by-number)
+  (define-key gnus-Subject-mode-map "\C-c\C-sa" 'gnus-Subject-sort-by-author)
+  (define-key gnus-Subject-mode-map "\C-c\C-ss" 'gnus-Subject-sort-by-subject)
+  (define-key gnus-Subject-mode-map "\C-c\C-sd" 'gnus-Subject-sort-by-date)
+  (define-key gnus-Subject-mode-map "\C-c\C-s\C-n" 'gnus-Subject-sort-by-number)
+  (define-key gnus-Subject-mode-map "\C-c\C-s\C-a" 'gnus-Subject-sort-by-author)
+  (define-key gnus-Subject-mode-map "\C-c\C-s\C-s" 'gnus-Subject-sort-by-subject)
+  (define-key gnus-Subject-mode-map "\C-c\C-s\C-d" 'gnus-Subject-sort-by-date)
+  (define-key gnus-Subject-mode-map "=" 'gnus-Subject-expand-window)
+  (define-key gnus-Subject-mode-map "G" 'gnus-Subject-reselect-current-group)
+  (define-key gnus-Subject-mode-map "w" 'gnus-Subject-stop-page-breaking)
+  (define-key gnus-Subject-mode-map "\C-c\C-r" 'gnus-Subject-caesar-message)
+  (define-key gnus-Subject-mode-map "g" 'gnus-Subject-show-article)
+  (define-key gnus-Subject-mode-map "t" 'gnus-Subject-toggle-header)
+  (define-key gnus-Subject-mode-map "v" 'gnus-Subject-show-all-headers)
+  (define-key gnus-Subject-mode-map "\C-d" 'gnus-Subject-rmail-digest)
+  (define-key gnus-Subject-mode-map "a" 'gnus-Subject-post-news)
+  (define-key gnus-Subject-mode-map "f" 'gnus-Subject-post-reply)
+  (define-key gnus-Subject-mode-map "F" 'gnus-Subject-post-reply-with-original)
+  (define-key gnus-Subject-mode-map "C" 'gnus-Subject-cancel-article)
+  (define-key gnus-Subject-mode-map "r" 'gnus-Subject-mail-reply)
+  (define-key gnus-Subject-mode-map "R" 'gnus-Subject-mail-reply-with-original)
+  (define-key gnus-Subject-mode-map "m" 'gnus-Subject-mail-other-window)
+  (define-key gnus-Subject-mode-map "o" 'gnus-Subject-save-article)
+  (define-key gnus-Subject-mode-map "\C-o" 'gnus-Subject-save-in-mail)
+  (define-key gnus-Subject-mode-map "|" 'gnus-Subject-pipe-output)
+  (define-key gnus-Subject-mode-map "\ek" 'gnus-Subject-edit-local-kill)
+  (define-key gnus-Subject-mode-map "\eK" 'gnus-Subject-edit-global-kill)
+  (define-key gnus-Subject-mode-map "V" 'gnus-version)
+  (define-key gnus-Subject-mode-map "q" 'gnus-Subject-exit)
+  (define-key gnus-Subject-mode-map "Q" 'gnus-Subject-quit)
+  (define-key gnus-Subject-mode-map "?" 'gnus-Subject-describe-briefly)
+  (define-key gnus-Subject-mode-map "\C-c\C-i" 'gnus-Info-find-node))
+
+(defun gnus-Subject-mode ()
+  "Major mode for reading articles in this newsgroup.
+All normal editing commands are turned off.
+Instead, these commands are available:
+\\{gnus-Subject-mode-map}
+
+User customizable variables:
+ gnus-large-newsgroup
+    The number of articles which indicates a large newsgroup. If the
+    number of articles in a newsgroup is greater than the value, the
+    number of articles to be selected is asked for.  If the given value
+    N is positive, the last N articles is selected.  If N is negative,
+    the first N articles are selected.  An empty string means to select
+    all articles.
+
+ gnus-use-long-file-name
+    Non-nil means that a newsgroup name is used as a default file name
+    to save articles to.  If it's nil, the directory form of a
+    newsgroup is used instead.
+
+ gnus-default-article-saver
+    Specifies your favorite article saver which is interactively
+    funcallable.  Following functions are available:
+
+        gnus-Subject-save-in-rmail (in Rmail format)
+        gnus-Subject-save-in-mail (in Unix mail format)
+        gnus-Subject-save-in-folder (in MH folder)
+        gnus-Subject-save-in-file (in article format).
+
+ gnus-rmail-save-name
+ gnus-mail-save-name
+ gnus-folder-save-name
+ gnus-file-save-name
+    Specifies a function generating a file name to save articles in
+    specified format.  The function is called with NEWSGROUP, HEADERS,
+    and optional LAST-FILE.  Access macros to the headers are defined
+    as nntp-header-FIELD, and functions are defined as `gnus-header-FIELD'.
+
+ gnus-article-save-directory
+    Specifies a directory name to save articles to using the commands
+    `gnus-Subject-save-in-rmail', `gnus-Subject-save-in-mail' and
+    `gnus-Subject-save-in-file'.  The variable is initialized from the
+    SAVEDIR environment variable.
+
+ gnus-show-all-headers
+    Non-nil means that all headers of an article are shown.
+
+ gnus-save-all-headers
+    Non-nil means that all headers of an article are saved in a file.
+
+ gnus-show-threads
+    Non-nil means that conversation threads are shown in tree structure.
+
+ gnus-thread-hide-subject
+    Non-nil means that subjects for thread subtrees are hidden.
+
+ gnus-thread-hide-subtree
+    Non-nil means that thread subtrees are hidden initially.
+
+ gnus-thread-hide-killed
+    Non-nil means that killed thread subtrees are hidden automatically.
+
+ gnus-thread-ignore-subject
+    Non-nil means that subject differences are ignored in constructing
+    thread trees.
+
+ gnus-thread-indent-level
+    Indentation of thread subtrees.
+
+ gnus-optional-headers
+    Specifies a function which generates an optional string displayed
+    in the Subject buffer.  The function is called with an article
+    HEADERS.  The result must be a string excluding `[' and `]'.  The
+    default function returns a string like NNN:AUTHOR, where NNN is
+    the number of lines in an article and AUTHOR is the name of the
+    author.
+
+ gnus-auto-extend-newsgroup
+    Non-nil means visible articles are extended to forward and
+    backward automatically if possible.
+
+ gnus-auto-select-first
+    Non-nil means the first unread article is selected automagically
+    when a newsgroup is selected normally (by gnus-Group-read-group).
+    If you'd like to prevent automatic selection of the first unread
+    article in some newsgroups, set the variable to nil in
+    gnus-Select-group-hook or gnus-Apply-kill-hook.
+
+ gnus-auto-select-next
+    Non-nil means the next newsgroup is selected automagically at the
+    end of the newsgroup. If the value is t and the next newsgroup is
+    empty (no unread articles), GNUS will exit Subject mode and go
+    back to Group mode. If the value is neither nil nor t, GNUS won't
+    exit Subject mode but select the following unread newsgroup.
+    Especially, if the value is the symbol `quietly', the next unread
+    newsgroup will be selected without any confirmations.
+
+ gnus-auto-select-same
+    Non-nil means an article with the same subject as the current
+    article is selected automagically like `rn -S'.
+
+ gnus-auto-center-subject
+    Non-nil means the point of Subject Mode window is always kept
+    centered.
+
+ gnus-break-pages
+    Non-nil means an article is broken into pages at page delimiters.
+    This may not work with some versions of GNU Emacs earlier than
+    version 18.50.
+
+ gnus-page-delimiter
+    Specifies a regexp describing line-beginnings that separate pages
+    of news article.
+
+ [gnus-more-message is obsolete.  overlay-arrow-string interfares
+    with other subsystems, such as dbx mode.]
+
+ gnus-digest-show-summary
+    Non-nil means that a summary of digest messages is shown when
+    reading a digest article using `gnus-Subject-rmail-digest' command.
+
+ gnus-digest-separator
+    Specifies a regexp separating messages in a digest article.
+
+ gnus-mail-reply-method
+ gnus-mail-other-window-method
+    Specifies a function to begin composing mail message using
+    commands gnus-Subject-mail-reply and
+    gnus-Subject-mail-other-window.  Functions
+    gnus-mail-reply-using-mail and gnus-mail-reply-using-mhe are
+    available for the value of gnus-mail-reply-method.  And functions
+    gnus-mail-other-window-using-mail and
+    gnus-mail-other-window-using-mhe are available for the value of
+    gnus-mail-other-window-method.
+
+Various hooks for customization:
+ gnus-Subject-mode-hook
+    Entry to this mode calls the value with no arguments, if that
+    value is non-nil.
+
+ gnus-Select-group-hook
+    Called with no arguments when newsgroup is selected, if that value
+    is non-nil.  It is possible to sort subjects in this hook.  See the
+    documentation of this variable for more information.
+
+ gnus-Subject-prepare-hook
+    Called with no arguments after a subject list is created in the
+    Subject buffer, if that value is non-nil.  If you'd like to modify
+    the buffer, you can use this hook.
+
+ gnus-Select-article-hook
+    Called with no arguments when an article is selected, if that
+    value is non-nil.  See the documentation of this variable for
+    more information.
+
+ gnus-Select-digest-hook
+    Called with no arguments when reading digest messages using Rmail,
+    if that value is non-nil.  This hook can be used to modify an
+    article so that Rmail can work with it.  See the documentation of
+    the variable for more information.
+
+ gnus-Rmail-digest-hook
+    Called with no arguments when reading digest messages using Rmail,
+    if that value is non-nil.  This hook is intended to customize Rmail
+    mode.
+
+ gnus-Apply-kill-hook
+    Called with no arguments when a newsgroup is selected and the
+    Subject buffer is prepared.  This hook is intended to apply a KILL
+    file to the selected newsgroup.  The format of KILL file is
+    completely different from that of version 3.8. You have to rewrite
+    them in the new format.  See the documentation of Kill file mode
+    for more information.
+
+ gnus-Mark-article-hook
+    Called with no arguments when an article is selected at the first
+    time.  The hook is intended to mark an article as read (or unread)
+    automatically when it is selected.  See the documentation of the
+    variable for more information.
+
+ gnus-Exit-group-hook
+    Called with no arguments when exiting the current newsgroup, if
+    that value is non-nil.  If your machine is so slow that exiting
+    from Subject mode takes very long time, inhibit marking articles
+    as read using cross-references by setting the variable
+    `gnus-newsgroup-headers' to nil in this hook."
+  (interactive)
+  (kill-all-local-variables)
+  ;; Gee.  Why don't you upgrade?
+  (cond ((boundp 'mode-line-modified)
+         (setq mode-line-modified "--- "))
+        ((listp (default-value 'mode-line-format))
+         (setq mode-line-format
+               (cons "--- " (cdr (default-value 'mode-line-format))))))
+  (make-local-variable 'global-mode-string)
+  (setq global-mode-string nil)
+  (setq major-mode 'gnus-Subject-mode)
+  (setq mode-name "Subject")
+  ;;(setq mode-line-process '(" " gnus-newsgroup-name))
+  (make-local-variable 'minor-mode-alist)
+  (or (assq 'gnus-show-threads minor-mode-alist)
+      (setq minor-mode-alist
+            (cons (list 'gnus-show-threads " Thread") minor-mode-alist)))
+  (gnus-Subject-set-mode-line)
+  (use-local-map gnus-Subject-mode-map)
+  (buffer-flush-undo (current-buffer))
+  (setq buffer-read-only t)             ;Disable modification
+  (setq truncate-lines t)               ;Stop line folding
+  (setq selective-display t)
+  (setq selective-display-ellipses t)   ;Display `...'
+  ;;(setq case-fold-search t)
+  (run-hooks 'gnus-Subject-mode-hook))
+
+(defun gnus-Subject-setup-buffer ()
+  "Initialize subject display buffer."
+  (if (get-buffer gnus-Subject-buffer)
+      (set-buffer gnus-Subject-buffer)
+    (set-buffer (get-buffer-create gnus-Subject-buffer))
+    (gnus-Subject-mode)
+    ))
+
+(defun gnus-Subject-read-group (group &optional show-all no-article)
+  "Start reading news in newsgroup GROUP.
+If optional first argument SHOW-ALL is non-nil, already read articles are
+also listed.
+If optional second argument NO-ARTICLE is non-nil, no article is selected
+initially."
+  (message "Retrieving newsgroup: %s..." group)
+  (if (gnus-select-newsgroup group show-all)
+      (progn
+        ;; Don't switch-to-buffer to prevent displaying old contents
+        ;;  of the buffer until new subjects list is created.
+        ;; Suggested by Juha Heinanen <jh@tut.fi>
+        (gnus-Subject-setup-buffer)
+        ;; You can change the order of subjects in this hook.
+        (run-hooks 'gnus-Select-group-hook)
+        (gnus-Subject-prepare)
+        ;; Function `gnus-apply-kill-file' must be called in this hook.
+        (run-hooks 'gnus-Apply-kill-hook)
+        (if (zerop (buffer-size))
+            ;; This newsgroup is empty.
+            (progn
+              (gnus-Subject-catch-up-and-exit nil t) ;Without confirmations.
+              (message "No unread news"))
+          ;; Hide conversation thread subtrees.  We cannot do this in
+          ;; gnus-Subject-prepare-hook since kill processing may not
+          ;; work with hidden articles.
+          (and gnus-show-threads
+               gnus-thread-hide-subtree
+               (gnus-Subject-hide-all-threads))
+          ;; Show first unread article if requested.
+          (goto-char (point-min))
+          (if (and (not no-article)
+                   gnus-auto-select-first
+                   (gnus-Subject-first-unread-article))
+              ;; Window is configured automatically.
+              ;; Current buffer may be changed as a result of hook
+              ;; evaluation, especially by gnus-Subject-rmail-digest
+              ;; command, so we should adjust cursor point carefully.
+              (if (eq (current-buffer) (get-buffer gnus-Subject-buffer))
+                  (progn
+                    ;; Adjust cursor point.
+                    (beginning-of-line)
+                    (search-forward ":" nil t)))
+            (gnus-configure-windows 'SelectNewsgroup)
+            (pop-to-buffer gnus-Subject-buffer)
+            (gnus-Subject-set-mode-line)
+            ;; I sometime get confused with the old Article buffer.
+            (if (get-buffer gnus-Article-buffer)
+                (if (get-buffer-window gnus-Article-buffer)
+                    (save-excursion
+                      (set-buffer gnus-Article-buffer)
+                      (let ((buffer-read-only nil))
+                        (erase-buffer)))
+                  (kill-buffer gnus-Article-buffer)))
+            ;; Adjust cursor point.
+            (beginning-of-line)
+            (search-forward ":" nil t))
+          ))
+    ;; Cannot select newsgroup GROUP.
+    (if (gnus-gethash group gnus-active-hashtb)
+        (progn
+          ;; If NNTP is used, nntp_access file may not be installed
+          ;; properly.  Otherwise, may be active file problem.
+          (ding)
+          (message "Cannot select %s.  May be security or active file problem." group)
+          (sit-for 0))
+      ;; Check bogus newsgroups.
+      ;; We must be in Group Mode buffer.
+      (gnus-Group-check-bogus-groups))
+    ))
+
+(defun gnus-Subject-prepare ()
+  "Prepare subject list of current newsgroup in Subject mode buffer."
+  (let ((buffer-read-only nil))
+    ;; Note: The next codes are not actually used because the user who
+    ;; want it can define them in gnus-Select-group-hook.
+    ;; Print verbose messages if too many articles are selected.
+    ;;    (and (numberp gnus-large-newsgroup)
+    ;;       (> (length gnus-newsgroup-headers) gnus-large-newsgroup)
+    ;;       (message "Preparing headers..."))
+    (erase-buffer)
+    (gnus-Subject-prepare-threads
+     (if gnus-show-threads
+         (gnus-make-threads gnus-newsgroup-headers)
+       gnus-newsgroup-headers) 0)
+    ;; Erase header retrieval message.
+    (message "")
+    ;; Call hooks for modifying Subject mode buffer.
+    ;; Suggested by sven@tde.LTH.Se (Sven Mattisson).
+    (goto-char (point-min))
+    (run-hooks 'gnus-Subject-prepare-hook)
+    ))
+
+;; Basic ideas by Paul Dworkin <paul@media-lab.media.mit.edu>
+
+(defun gnus-Subject-prepare-threads (threads level)
+  "Prepare Subject buffer from THREADS and indentation LEVEL.
+THREADS is a list of `(PARENT [(CHILD1 [(GRANDCHILD ...]...) ...]).'"
+  (let ((thread nil)
+        (header nil)
+        (number nil)
+        ;; `M Indent NUM: [OPT] SUBJECT'
+        (cntl (format "%%s %%s%%%dd: [%%s] %%s\n"
+                      (length (prin1-to-string gnus-newsgroup-end)))))
+    (while threads
+      (setq thread (car threads))
+      (setq threads (cdr threads))
+      ;; If thread is a cons, hierarchical threads is given.
+      ;; Otherwise, thread itself is header.
+      (if (consp thread)
+          (setq header (car thread))
+        (setq header thread))
+      ;; Print valid header only.
+      (if (vectorp header)              ;Depends on nntp.el.
+          (progn
+            (setq number (nntp-header-number header))
+            (insert
+             (format cntl
+                     ;; Read or not.
+                     (cond ((memq number gnus-newsgroup-marked)  "-")
+                           ((memq number gnus-newsgroup-unreads) " ")
+                           (t "D"))
+                     ;; Thread level.
+                     (make-string (* level gnus-thread-indent-level) ? )
+                     ;; Article number.
+                     number
+                     ;; Optional headers.
+                     (or (and gnus-optional-headers
+                              (funcall gnus-optional-headers header)) "")
+                     ;; Its subject string.
+                     (concat (if (or (zerop level)
+                                     (not gnus-thread-hide-subject))
+                                 nil
+                               (make-string (window-width) ? ))
+                             (nntp-header-subject header))
+                     ))
+            ))
+      ;; Print subthreads.
+      (and (consp thread)
+           (cdr thread)
+           (gnus-Subject-prepare-threads (cdr thread) (1+ level)))
+      )))
+
+(defun gnus-Subject-set-mode-line ()
+  "Set Subject mode line string."
+  ;; The value must be a string to escape %-constructs.
+  (let ((subject
+         (if gnus-current-headers
+             (nntp-header-subject gnus-current-headers) gnus-newsgroup-name)))
+    (setq mode-line-buffer-identification
+          (concat "GNUS: "
+                  subject
+                  ;; Enough spaces to pad subject to 17 positions.
+                  (make-string (max 0 (- 17 (length subject))) ? ))))
+  (set-buffer-modified-p t))
+
+;; GNUS Subject mode command.
+
+(defun gnus-Subject-search-group (&optional backward)
+  "Search for next unread newsgroup.
+If optional argument BACKWARD is non-nil, search backward instead."
+  (save-excursion
+    (set-buffer gnus-Group-buffer)
+    (save-excursion
+      ;; We don't want to alter current point of Group mode buffer.
+      (if (gnus-Group-search-forward backward nil)
+          (gnus-Group-group-name))
+      )))
+
+(defun gnus-Subject-search-subject (backward unread subject)
+  "Search for article forward.
+If first argument BACKWARD is non-nil, search backward.
+If second argument UNREAD is non-nil, only unread article is selected.
+If third argument SUBJECT is non-nil, the article which has
+the same subject will be searched for."
+  (let ((func (if backward 're-search-backward 're-search-forward))
+        (article nil)
+        ;; We have to take care of hidden lines.
+        (regexp 
+         (format "^%s[ \t]+\\([0-9]+\\):.\\[[^]\r\n]*\\][ \t]+%s"
+                 ;;(if unread " " ".")
+                 (cond ((eq unread t) " ") (unread "[ ---]") (t "."))
+                 (if subject
+                     (concat "\\([Rr][Ee]:[ \t]+\\)*"
+                             (regexp-quote (gnus-simplify-subject subject))
+                             ;; Ignore words in parentheses.
+                             "\\([ \t]*([^\r\n]*)\\)*[ \t]*\\(\r\\|$\\)")
+                   "")
+                 )))
+    (if backward
+        (beginning-of-line)
+      (end-of-line))
+    (if (funcall func regexp nil t)
+        (setq article
+              (string-to-int
+               (buffer-substring (match-beginning 1) (match-end 1)))))
+    ;; Adjust cursor point.
+    (beginning-of-line)
+    (search-forward ":" nil t)
+    ;; This is the result.
+    article
+    ))
+
+(defun gnus-Subject-search-forward (&optional unread subject)
+  "Search for article forward.
+If first optional argument UNREAD is non-nil, only unread article is selected.
+If second optional argument SUBJECT is non-nil, the article which has
+the same subject will be searched for."
+  (gnus-Subject-search-subject nil unread subject))
+
+(defun gnus-Subject-search-backward (&optional unread subject)
+  "Search for article backward.
+If first optional argument UNREAD is non-nil, only unread article is selected.
+If second optional argument SUBJECT is non-nil, the article which has
+the same subject will be searched for."
+  (gnus-Subject-search-subject t unread subject))
+
+(defun gnus-Subject-article-number ()
+  "Article number around point. If nothing, return current number."
+  (save-excursion
+    (beginning-of-line)
+    (if (looking-at ".[ \t]+\\([0-9]+\\):")
+        (string-to-int
+         (buffer-substring (match-beginning 1) (match-end 1)))
+      ;; If search fail, return current article number.
+      gnus-current-article
+      )))
+
+(defun gnus-Subject-subject-string ()
+  "Return current subject string or nil if nothing."
+  (save-excursion
+    ;; It is possible to implement this function using
+    ;;  `gnus-Subject-article-number' and `gnus-newsgroup-headers'.
+    (beginning-of-line)
+    ;; We have to take care of hidden lines.
+    (if (looking-at ".[ \t]+[0-9]+:.\\[[^]\r\n]*\\][ \t]+\\([^\r\n]*\\)[\r\n]")
+        (buffer-substring (match-beginning 1) (match-end 1)))
+    ))
+
+(defun gnus-Subject-goto-subject (article)
+  "Move point to ARTICLE's subject."
+  (interactive
+   (list
+    (string-to-int
+     (completing-read "Article number: "
+                      (mapcar
+                       (function
+                        (lambda (headers)
+                          (list
+                           (int-to-string (nntp-header-number headers)))))
+                       gnus-newsgroup-headers)
+                      nil 'require-match))))
+  (let ((current (point)))
+    (goto-char (point-min))
+    (or (and article (re-search-forward (format "^.[ \t]+%d:" article) nil t))
+        (progn (goto-char current) nil))
+    ))
+
+(defun gnus-Subject-recenter ()
+  "Center point in Subject mode window."
+  ;; Scroll window so as to cursor comes center of Subject mode window
+  ;;  only when article is displayed.
+  ;; Suggested by earle@mahendo.JPL.NASA.GOV (Greg Earle).
+  ;; Recenter only when requested.
+  ;; Suggested by popovich@park.cs.columbia.edu
+  (and gnus-auto-center-subject
+       (get-buffer-window gnus-Article-buffer)
+       (< (/ (- (window-height) 1) 2)
+          (count-lines (point) (point-max)))
+       (recenter (/ (- (window-height) 2) 2))))
+
+;; Walking around Group mode buffer.
+
+(defun gnus-Subject-jump-to-group (newsgroup)
+  "Move point to NEWSGROUP in Group mode buffer."
+  ;; Keep update point of Group mode buffer if visible.
+  (if (eq (current-buffer)
+          (get-buffer gnus-Group-buffer))
+      (save-window-excursion
+        ;; Take care of tree window mode.
+        (if (get-buffer-window gnus-Group-buffer)
+            (pop-to-buffer gnus-Group-buffer))
+        (gnus-Group-jump-to-group newsgroup))
+    (save-excursion
+      ;; Take care of tree window mode.
+      (if (get-buffer-window gnus-Group-buffer)
+          (pop-to-buffer gnus-Group-buffer)
+        (set-buffer gnus-Group-buffer))
+      (gnus-Group-jump-to-group newsgroup))))
+
+(defun gnus-Subject-next-group (no-article)
+  "Exit current newsgroup and then select next unread newsgroup.
+If prefix argument NO-ARTICLE is non-nil, no article is selected initially."
+  (interactive "P")
+  ;; Make sure Group mode buffer point is on current newsgroup.
+  (gnus-Subject-jump-to-group gnus-newsgroup-name)
+  (let ((group (gnus-Subject-search-group)))
+    (if (null group)
+        (progn
+          (message "Exiting %s..." gnus-newsgroup-name)  
+          (gnus-Subject-exit)
+          (message ""))
+      (message "Selecting %s..." group)
+      (gnus-Subject-exit t)             ;Exit Subject mode temporary.
+      ;; We are now in Group mode buffer.
+      ;; Make sure Group mode buffer point is on GROUP.
+      (gnus-Subject-jump-to-group group)
+      (gnus-Subject-read-group group nil no-article)
+      (or (eq (current-buffer)
+              (get-buffer gnus-Subject-buffer))
+          (eq gnus-auto-select-next t)
+          ;; Expected newsgroup has nothing to read since the articles
+          ;; are marked as read by cross-referencing. So, try next
+          ;; newsgroup. (Make sure we are in Group mode buffer now.)
+          (and (eq (current-buffer)
+                   (get-buffer gnus-Group-buffer))
+               (gnus-Group-group-name)
+               (gnus-Subject-read-group
+                (gnus-Group-group-name) nil no-article))
+          )
+      )))
+
+(defun gnus-Subject-prev-group (no-article)
+  "Exit current newsgroup and then select previous unread newsgroup.
+If prefix argument NO-ARTICLE is non-nil, no article is selected initially."
+  (interactive "P")
+  ;; Make sure Group mode buffer point is on current newsgroup.
+  (gnus-Subject-jump-to-group gnus-newsgroup-name)
+  (let ((group (gnus-Subject-search-group t)))
+    (if (null group)
+        (progn
+          (message "Exiting %s..." gnus-newsgroup-name)  
+          (gnus-Subject-exit)
+          (message ""))
+      (message "Selecting %s..." group)
+      (gnus-Subject-exit t)             ;Exit Subject mode temporary.
+      ;; We are now in Group mode buffer.
+      ;; We have to adjust point of Group mode buffer because current
+      ;; point is moved to next unread newsgroup by exiting.
+      (gnus-Subject-jump-to-group group)
+      (gnus-Subject-read-group group nil no-article)
+      (or (eq (current-buffer)
+              (get-buffer gnus-Subject-buffer))
+          (eq gnus-auto-select-next t)
+          ;; Expected newsgroup has nothing to read since the articles
+          ;; are marked as read by cross-referencing. So, try next
+          ;; newsgroup. (Make sure we are in Group mode buffer now.)
+          (and (eq (current-buffer)
+                   (get-buffer gnus-Group-buffer))
+               (gnus-Subject-search-group t)
+               (gnus-Subject-read-group
+                (gnus-Subject-search-group t) nil no-article))
+          )
+      )))
+
+;; Walking around subject lines.
+
+(defun gnus-Subject-next-subject (n &optional unread)
+  "Go to next N'th subject line.
+If optional argument UNREAD is non-nil, only unread article is selected."
+  (interactive "p")
+  (while (and (> n 1)
+              (gnus-Subject-search-forward unread))
+    (setq n (1- n)))
+  (cond ((gnus-Subject-search-forward unread)
+         (gnus-Subject-recenter))
+        (unread
+         (message "No more unread articles"))
+        (t
+         (message "No more articles"))
+        ))
+
+(defun gnus-Subject-next-unread-subject (n)
+  "Go to next N'th unread subject line."
+  (interactive "p")
+  (gnus-Subject-next-subject n t))
+
+(defun gnus-Subject-prev-subject (n &optional unread)
+  "Go to previous N'th subject line.
+If optional argument UNREAD is non-nil, only unread article is selected."
+  (interactive "p")
+  (while (and (> n 1)
+              (gnus-Subject-search-backward unread))
+    (setq n (1- n)))
+  (cond ((gnus-Subject-search-backward unread)
+         (gnus-Subject-recenter))
+        (unread
+         (message "No more unread articles"))
+        (t
+         (message "No more articles"))
+        ))
+
+(defun gnus-Subject-prev-unread-subject (n)
+  "Go to previous N'th unread subject line."
+  (interactive "p")
+  (gnus-Subject-prev-subject n t))
+
+;; Walking around subject lines with displaying articles.
+
+(defun gnus-Subject-expand-window ()
+  "Expand Subject window to show headers full window."
+  (interactive)
+  (gnus-configure-windows 'ExpandSubject)
+  (pop-to-buffer gnus-Subject-buffer))
+
+(defun gnus-Subject-display-article (article &optional all-header)
+  "Display ARTICLE in Article buffer."
+  (if (null article)
+      nil
+    (gnus-configure-windows 'SelectArticle)
+    (pop-to-buffer gnus-Subject-buffer)
+    (gnus-Article-prepare article all-header)
+    (gnus-Subject-recenter)
+    (gnus-Subject-set-mode-line)
+    (run-hooks 'gnus-Select-article-hook)
+    ;; Successfully display article.
+    t
+    ))
+
+(defun gnus-Subject-select-article (&optional all-headers force)
+  "Select the current article.
+Optional argument ALL-HEADERS is non-nil, show all headers."
+  (let ((article (gnus-Subject-article-number)))
+    (if (or (null gnus-current-article)
+            (/= article gnus-current-article)
+            (and force (not (eq all-headers gnus-have-all-headers))))
+        ;; The selected subject is different from that of the current article.
+        (gnus-Subject-display-article article all-headers)
+      (gnus-configure-windows 'SelectArticle)
+      (pop-to-buffer gnus-Subject-buffer))
+    ))
+
+(defun gnus-Subject-set-current-mark (&optional current-mark)
+  "Put `+' at the current article.
+Optional argument specifies CURRENT-MARK instead of `+'."
+  (save-excursion
+    (set-buffer gnus-Subject-buffer)
+    (let ((buffer-read-only nil))
+      (goto-char (point-min))
+      ;; First of all clear mark at last article.
+      (if (re-search-forward "^.[ \t]+[0-9]+:[^ \t]" nil t)
+          (progn
+            (delete-char -1)
+            (insert " ")
+            (goto-char (point-min))))
+      (if (re-search-forward (format "^.[ \t]+%d:" gnus-current-article) nil t)
+          (progn
+            (delete-char 1)
+            (insert (or current-mark "+"))))
+      )))
+
+(defun gnus-Subject-next-article (unread &optional subject)
+  "Select article after current one.
+If argument UNREAD is non-nil, only unread article is selected."
+  (interactive "P")
+  (let ((header nil))
+    (cond ((gnus-Subject-display-article
+            (gnus-Subject-search-forward unread subject)))
+          ((and subject
+                gnus-auto-select-same
+                (gnus-set-difference gnus-newsgroup-unreads
+                                     gnus-newsgroup-marked)
+                (memq this-command
+                      '(gnus-Subject-next-unread-article
+                        gnus-Subject-next-page
+                        gnus-Subject-kill-same-subject-and-select
+                        ;;gnus-Subject-next-article
+                        ;;gnus-Subject-next-same-subject
+                        ;;gnus-Subject-next-unread-same-subject
+                        )))
+           ;; Wrap article pointer if there are unread articles.
+           ;; Hook function, such as gnus-Subject-rmail-digest, may
+           ;; change current buffer, so need check.
+           (let ((buffer (current-buffer))
+                 (last-point (point)))
+             ;; No more articles with same subject, so jump to the first
+             ;; unread article.
+             (gnus-Subject-first-unread-article)
+             ;;(and (eq buffer (current-buffer))
+             ;; (= (point) last-point)
+             ;; ;; Ignore given SUBJECT, and try again.
+             ;; (gnus-Subject-next-article unread nil))
+             (and (eq buffer (current-buffer))
+                  (< (point) last-point)
+                  (message "Wrapped"))
+             ))
+          ((and (not unread)
+                gnus-auto-extend-newsgroup
+                (setq header (gnus-more-header-forward)))
+           ;; Extend to next article if possible.
+           ;; Basic ideas by himacdonald@watdragon.waterloo.edu
+           (gnus-extend-newsgroup header nil)
+           ;; Threads feature must be turned off.
+           (let ((buffer-read-only nil))
+             (goto-char (point-max))
+             (gnus-Subject-prepare-threads (list header) 0))
+           (gnus-Subject-goto-article gnus-newsgroup-end))
+          (t
+           ;; Select next newsgroup automatically if requested.
+           (let ((cmd (string-to-char (this-command-keys)))
+                 (group (gnus-Subject-search-group))
+                 (auto-select
+                  (and gnus-auto-select-next
+                       ;;(null (gnus-set-difference gnus-newsgroup-unreads
+                       ;;                               gnus-newsgroup-marked))
+                       (memq this-command
+                             '(gnus-Subject-next-unread-article
+                               gnus-Subject-next-article
+                               gnus-Subject-next-page
+                               gnus-Subject-next-same-subject
+                               gnus-Subject-next-unread-same-subject
+                               gnus-Subject-kill-same-subject
+                               gnus-Subject-kill-same-subject-and-select
+                               ))
+                       ;; Ignore characters typed ahead.
+                       (not (input-pending-p))
+                       )))
+             (message "No more%s articles%s"
+                      (if unread " unread" "")
+                      (if (and auto-select
+                               (not (eq gnus-auto-select-next 'quietly)))
+                          (if group
+                              (format " (Type %s to %s [%d])"
+                                      (key-description (char-to-string cmd))
+                                      group
+                                      (nth 1 (gnus-gethash group
+                                                           gnus-unread-hashtb)))
+                            (format " (Type %s to exit %s)"
+                                    (key-description (char-to-string cmd))
+                                    gnus-newsgroup-name
+                                    ))
+                        ""))
+             ;; Select next unread newsgroup automagically.
+             (cond ((and auto-select
+                         (eq gnus-auto-select-next 'quietly))
+                    ;; Select quietly.
+                    (gnus-Subject-next-group nil))
+                   (auto-select
+                    ;; Confirm auto selection.
+                    (let ((char (read-char)))
+                      (if (= char cmd)
+                          (gnus-Subject-next-group nil)
+                        (setq unread-command-char char))))
+                   )
+             ))
+          )))
+
+(defun gnus-Subject-next-unread-article ()
+  "Select unread article after current one."
+  (interactive)
+  (gnus-Subject-next-article t (and gnus-auto-select-same
+                                    (gnus-Subject-subject-string))))
+
+(defun gnus-Subject-prev-article (unread &optional subject)
+  "Select article before current one.
+If argument UNREAD is non-nil, only unread article is selected."
+  (interactive "P")
+  (let ((header nil))
+    (cond ((gnus-Subject-display-article
+            (gnus-Subject-search-backward unread subject)))
+          ((and subject
+                gnus-auto-select-same
+                (gnus-set-difference gnus-newsgroup-unreads
+                                     gnus-newsgroup-marked)
+                (memq this-command
+                      '(gnus-Subject-prev-unread-article
+                        ;;gnus-Subject-prev-page
+                        ;;gnus-Subject-prev-article
+                        ;;gnus-Subject-prev-same-subject
+                        ;;gnus-Subject-prev-unread-same-subject
+                        )))
+           ;; Ignore given SUBJECT, and try again.
+           (gnus-Subject-prev-article unread nil))
+          (unread
+           (message "No more unread articles"))
+          ((and gnus-auto-extend-newsgroup
+                (setq header (gnus-more-header-backward)))
+           ;; Extend to previous article if possible.
+           ;; Basic ideas by himacdonald@watdragon.waterloo.edu
+           (gnus-extend-newsgroup header t)
+           (let ((buffer-read-only nil))
+             (goto-char (point-min))
+             (gnus-Subject-prepare-threads (list header) 0))
+           (gnus-Subject-goto-article gnus-newsgroup-begin))
+          (t
+           (message "No more articles"))
+          )))
+
+(defun gnus-Subject-prev-unread-article ()
+  "Select unred article before current one."
+  (interactive)
+  (gnus-Subject-prev-article t (and gnus-auto-select-same
+                                    (gnus-Subject-subject-string))))
+
+(defun gnus-Subject-next-page (lines)
+  "Show next page of selected article.
+If end of artile, select next article.
+Argument LINES specifies lines to be scrolled up."
+  (interactive "P")
+  (let ((article (gnus-Subject-article-number))
+        (endp nil))
+    (if (or (null gnus-current-article)
+            (/= article gnus-current-article))
+        ;; Selected subject is different from current article's.
+        (gnus-Subject-display-article article)
+      (gnus-configure-windows 'SelectArticle)
+      (pop-to-buffer gnus-Subject-buffer)
+      (gnus-eval-in-buffer-window gnus-Article-buffer
+        (setq endp (gnus-Article-next-page lines)))
+      (cond ((and endp lines)
+             (message "End of message"))
+            ((and endp (null lines))
+             (gnus-Subject-next-unread-article)))
+      )))
+
+(defun gnus-Subject-prev-page (lines)
+  "Show previous page of selected article.
+Argument LINES specifies lines to be scrolled down."
+  (interactive "P")
+  (let ((article (gnus-Subject-article-number)))
+    (if (or (null gnus-current-article)
+            (/= article gnus-current-article))
+        ;; Selected subject is different from current article's.
+        (gnus-Subject-display-article article)
+      (gnus-configure-windows 'SelectArticle)
+      (pop-to-buffer gnus-Subject-buffer)
+      (gnus-eval-in-buffer-window gnus-Article-buffer
+        (gnus-Article-prev-page lines))
+      )))
+
+(defun gnus-Subject-scroll-up (lines)
+  "Scroll up (or down) one line current article.
+Argument LINES specifies lines to be scrolled up (or down if negative)."
+  (interactive "p")
+  (gnus-Subject-select-article)
+  (gnus-eval-in-buffer-window gnus-Article-buffer
+    (cond ((> lines 0)
+           (if (gnus-Article-next-page lines)
+               (message "End of message")))
+          ((< lines 0)
+           (gnus-Article-prev-page (- 0 lines))))
+    ))
+
+(defun gnus-Subject-next-same-subject ()
+  "Select next article which has the same subject as current one."
+  (interactive)
+  (gnus-Subject-next-article nil (gnus-Subject-subject-string)))
+
+(defun gnus-Subject-prev-same-subject ()
+  "Select previous article which has the same subject as current one."
+  (interactive)
+  (gnus-Subject-prev-article nil (gnus-Subject-subject-string)))
+
+(defun gnus-Subject-next-unread-same-subject ()
+  "Select next unread article which has the same subject as current one."
+  (interactive)
+  (gnus-Subject-next-article t (gnus-Subject-subject-string)))
+
+(defun gnus-Subject-prev-unread-same-subject ()
+  "Select previous unread article which has the same subject as current one."
+  (interactive)
+  (gnus-Subject-prev-article t (gnus-Subject-subject-string)))
+
+(defun gnus-Subject-refer-parent-article (child)
+  "Refer parent article of current article.
+If a prefix argument CHILD is non-nil, go back to the child article
+using internally maintained articles history.
+NOTE: This command may not work with nnspool.el."
+  (interactive "P")
+  (gnus-Subject-select-article t t)     ;Request all headers.
+  (let ((referenced-id nil))            ;Message-id of parent or child article.
+    (if child
+        ;; Go back to child article using history.
+        (gnus-Subject-refer-article nil)
+      (gnus-eval-in-buffer-window gnus-Article-buffer
+        ;; Look for parent Message-ID.
+        ;; We cannot use gnus-current-headers to get references
+        ;; because we may be looking at parent or refered article.
+        (let ((references (gnus-fetch-field "References")))
+          ;; Get the last message-id in the references.
+          (and references
+               (string-match "\\(<[^<>]+>\\)[^>]*\\'" references)
+               (setq referenced-id
+                     (substring references
+                                (match-beginning 1) (match-end 1))))
+          ))
+      (if (stringp referenced-id)
+          (gnus-Subject-refer-article referenced-id)
+        (error "No more parents"))
+      )))
+
+(defun gnus-Subject-refer-article (message-id)
+  "Refer article specified by MESSAGE-ID.
+If MESSAGE-ID is nil or an empty string, it is popped from an
+internally maintained articles history.
+NOTE: This command may not work with nnspool.el."
+  (interactive "sMessage-ID: ")
+  ;; Make sure that this command depends on the fact that article
+  ;; related information is not updated when an article is retrieved
+  ;; by Message-ID.
+  (gnus-Subject-select-article t t)     ;Request all headers.
+  (if (and (stringp message-id)
+           (> (length message-id) 0))
+      (gnus-eval-in-buffer-window gnus-Article-buffer
+        ;; Construct the correct Message-ID if necessary.
+        ;; Suggested by tale@pawl.rpi.edu.
+        (or (string-match "^<" message-id)
+            (setq message-id (concat "<" message-id)))
+        (or (string-match ">$" message-id)
+            (setq message-id (concat message-id ">")))
+        ;; Push current message-id on history.
+        ;; We cannot use gnus-current-headers to get current
+        ;; message-id because we may be looking at parent or refered
+        ;; article.
+        (let ((current (gnus-fetch-field "Message-ID")))
+          (or (equal current message-id) ;Nothing to do.
+              (equal current (car gnus-current-history))
+              (setq gnus-current-history
+                    (cons current gnus-current-history)))
+          ))
+    ;; Pop message-id from history.
+    (setq message-id (car gnus-current-history))
+    (setq gnus-current-history (cdr gnus-current-history)))
+  (if (stringp message-id)
+      ;; Retrieve article by message-id.  This may not work with nnspool.
+      (gnus-Article-prepare message-id t)
+    (error "No such references"))
+  )
+
+(defun gnus-Subject-next-digest (nth)
+  "Move to head of NTH next digested message."
+  (interactive "p")
+  (gnus-Subject-select-article)
+  (gnus-eval-in-buffer-window gnus-Article-buffer
+    (gnus-Article-next-digest (or nth 1))
+    ))
+
+(defun gnus-Subject-prev-digest (nth)
+  "Move to head of NTH previous digested message."
+  (interactive "p")
+  (gnus-Subject-select-article)
+  (gnus-eval-in-buffer-window gnus-Article-buffer
+    (gnus-Article-prev-digest (or nth 1))
+    ))
+
+(defun gnus-Subject-first-unread-article ()
+  "Select first unread article.  Return non-nil if successfully selected."
+  (interactive)
+  (let ((begin (point)))
+    (goto-char (point-min))
+    (if (re-search-forward "^ [ \t]+[0-9]+:" nil t)
+        (gnus-Subject-display-article (gnus-Subject-article-number))
+      ;; If there is no unread articles, stay there.
+      (goto-char begin)
+      ;;(gnus-Subject-display-article (gnus-Subject-article-number))
+      (message "No more unread articles")
+      nil
+      )
+    ))
+
+(defun gnus-Subject-isearch-article ()
+  "Do incremental search forward on current article."
+  (interactive)
+  (gnus-Subject-select-article)
+  (gnus-eval-in-buffer-window gnus-Article-buffer
+    (call-interactively 'isearch-forward)
+    ))
+
+(defun gnus-Subject-search-article-forward (regexp)
+  "Search for an article containing REGEXP forward.
+`gnus-Select-article-hook' is not called during the search."
+  (interactive
+   (list (read-string
+          (concat "Search forward (regexp): "
+                  (if gnus-last-search-regexp
+                      (concat "(default " gnus-last-search-regexp ") "))))))
+  (if (string-equal regexp "")
+      (setq regexp (or gnus-last-search-regexp ""))
+    (setq gnus-last-search-regexp regexp))
+  (if (gnus-Subject-search-article regexp nil)
+      (gnus-eval-in-buffer-window gnus-Article-buffer
+        (recenter 0)
+        ;;(sit-for 1)
+        )
+    (error "Search failed: \"%s\"" regexp)
+    ))
+
+(defun gnus-Subject-search-article-backward (regexp)
+  "Search for an article containing REGEXP backward.
+`gnus-Select-article-hook' is not called during the search."
+  (interactive
+   (list (read-string
+          (concat "Search backward (regexp): "
+                  (if gnus-last-search-regexp
+                      (concat "(default " gnus-last-search-regexp ") "))))))
+  (if (string-equal regexp "")
+      (setq regexp (or gnus-last-search-regexp ""))
+    (setq gnus-last-search-regexp regexp))
+  (if (gnus-Subject-search-article regexp t)
+      (gnus-eval-in-buffer-window gnus-Article-buffer
+        (recenter 0)
+        ;;(sit-for 1)
+        )
+    (error "Search failed: \"%s\"" regexp)
+    ))
+
+(defun gnus-Subject-search-article (regexp &optional backward)
+  "Search for an article containing REGEXP.
+Optional argument BACKWARD means do search for backward.
+`gnus-Select-article-hook' is not called during the search."
+  (let ((gnus-Select-article-hook nil)  ;Disable hook.
+        (gnus-Mark-article-hook nil)    ;Inhibit marking as read.
+        (re-search
+         (if backward
+             (function re-search-backward) (function re-search-forward)))
+        (found nil)
+        (last nil))
+    ;; Hidden thread subtrees must be searched for ,too.
+    (gnus-Subject-show-all-threads)
+    ;; First of all, search current article.
+    ;; We don't want to read article again from NNTP server nor reset
+    ;; current point.
+    (gnus-Subject-select-article)
+    (message "Searching article: %d..." gnus-current-article)
+    (setq last gnus-current-article)
+    (gnus-eval-in-buffer-window gnus-Article-buffer
+      (save-restriction
+        (widen)
+        ;; Begin search from current point.
+        (setq found (funcall re-search regexp nil t))))
+    ;; Then search next articles.
+    (while (and (not found)
+                (gnus-Subject-display-article 
+                 (gnus-Subject-search-subject backward nil nil)))
+      (message "Searching article: %d..." gnus-current-article)
+      (gnus-eval-in-buffer-window gnus-Article-buffer
+        (save-restriction
+          (widen)
+          (goto-char (if backward (point-max) (point-min)))
+          (setq found (funcall re-search regexp nil t)))
+        ))
+    (message "")
+    ;; Adjust article pointer.
+    (or (eq last gnus-current-article)
+        (setq gnus-last-article last))
+    ;; Return T if found such article.
+    found
+    ))
+
+(defun gnus-Subject-execute-command (field regexp command &optional backward)
+  "If FIELD of article header matches REGEXP, execute COMMAND string.
+If FIELD is an empty string (or nil), entire article body is searched for.
+If optional (prefix) argument BACKWARD is non-nil, do backward instead."
+  (interactive
+   (list (let ((completion-ignore-case t))
+           (completing-read "Field name: "
+                            '(("Number")("Subject")("From")
+                              ("Lines")("Date")("Id")
+                              ("Xref")("References"))
+                            nil 'require-match))
+         (read-string "Regexp: ")
+         (read-key-sequence "Command: ")
+         current-prefix-arg))
+  ;; Hidden thread subtrees must be searched for ,too.
+  (gnus-Subject-show-all-threads)
+  ;; We don't want to change current point nor window configuration.
+  (save-excursion
+    (save-window-excursion
+      (message "Executing %s..." (key-description command))
+      ;; We'd like to execute COMMAND interactively so as to give arguments.
+      (gnus-execute field regexp
+                    (` (lambda ()
+                         (call-interactively '(, (key-binding command)))))
+                    backward)
+      (message "Executing %s... done" (key-description command)))))
+
+(defun gnus-Subject-beginning-of-article ()
+  "Go to beginning of article body"
+  (interactive)
+  (gnus-Subject-select-article)
+  (gnus-eval-in-buffer-window gnus-Article-buffer
+    (widen)
+    (beginning-of-buffer)
+    (if gnus-break-pages
+        (gnus-narrow-to-page))
+    ))
+
+(defun gnus-Subject-end-of-article ()
+  "Go to end of article body"
+  (interactive)
+  (gnus-Subject-select-article)
+  (gnus-eval-in-buffer-window gnus-Article-buffer
+    (widen)
+    (end-of-buffer)
+    (if gnus-break-pages
+        (gnus-narrow-to-page))
+    ))
+
+(defun gnus-Subject-goto-article (article &optional all-headers)
+  "Read ARTICLE if exists.
+Optional argument ALL-HEADERS means all headers are shown."
+  (interactive
+   (list
+    (string-to-int
+     (completing-read "Article number: "
+                      (mapcar
+                       (function
+                        (lambda (headers)
+                          (list
+                           (int-to-string (nntp-header-number headers)))))
+                       gnus-newsgroup-headers)
+                      nil 'require-match))))
+  (if (gnus-Subject-goto-subject article)
+      (gnus-Subject-display-article article all-headers)))
+
+(defun gnus-Subject-goto-last-article ()
+  "Go to last subject line."
+  (interactive)
+  (if gnus-last-article
+      (gnus-Subject-goto-article gnus-last-article)))
+
+(defun gnus-Subject-show-article ()
+  "Force to show current article."
+  (interactive)
+  ;; The following is a trick to force to read the current article again.
+  (setq gnus-have-all-headers (not gnus-have-all-headers))
+  (gnus-Subject-select-article (not gnus-have-all-headers) t))
+
+(defun gnus-Subject-toggle-header (arg)
+  "Show original header if pruned header currently shown, or vice versa.
+With arg, show original header iff arg is positive."
+  (interactive "P")
+  ;; Variable gnus-show-all-headers must be NIL to toggle really.
+  (let ((gnus-show-all-headers nil)
+        (all-headers
+         (if (null arg) (not gnus-have-all-headers)
+           (> (prefix-numeric-value arg) 0))))
+    (gnus-Subject-select-article all-headers t)))
+
+(defun gnus-Subject-show-all-headers ()
+  "Show original article header."
+  (interactive)
+  (gnus-Subject-select-article t t))
+
+(defun gnus-Subject-stop-page-breaking ()
+  "Stop page breaking by linefeed temporary (Widen article buffer)."
+  (interactive)
+  (gnus-Subject-select-article)
+  (gnus-eval-in-buffer-window gnus-Article-buffer
+    (widen)))
+
+(defun gnus-Subject-kill-same-subject-and-select (unmark)
+  "Mark articles which has the same subject as read, and then select next.
+If argument UNMARK is positive, remove any kinds of marks.
+If argument UNMARK is negative, mark articles as unread instead."
+  (interactive "P")
+  (if unmark
+      (setq unmark (prefix-numeric-value unmark)))
+  (let ((count
+         (gnus-Subject-mark-same-subject
+          (gnus-Subject-subject-string) unmark)))
+    ;; Select next unread article. If auto-select-same mode, should
+    ;; select the first unread article.
+    (gnus-Subject-next-article t (and gnus-auto-select-same
+                                      (gnus-Subject-subject-string)))
+    (message "%d articles are marked as %s"
+             count (if unmark "unread" "read"))
+    ))
+
+(defun gnus-Subject-kill-same-subject (unmark)
+  "Mark articles which has the same subject as read. 
+If argument UNMARK is positive, remove any kinds of marks.
+If argument UNMARK is negative, mark articles as unread instead."
+  (interactive "P")
+  (if unmark
+      (setq unmark (prefix-numeric-value unmark)))
+  (let ((count
+         (gnus-Subject-mark-same-subject
+          (gnus-Subject-subject-string) unmark)))
+    ;; If marked as read, go to next unread subject.
+    (if (null unmark)
+        ;; Go to next unread subject.
+        (gnus-Subject-next-subject 1 t))
+    (message "%d articles are marked as %s"
+             count (if unmark "unread" "read"))
+    ))
+
+(defun gnus-Subject-mark-same-subject (subject &optional unmark)
+  "Mark articles with same SUBJECT as read, and return marked number.
+If optional argument UNMARK is positive, remove any kinds of marks.
+If optional argument UNMARK is negative, mark articles as unread instead."
+  (let ((count 1))
+    (save-excursion
+      (cond ((null unmark)
+             (gnus-Subject-mark-as-read nil "K"))
+            ((> unmark 0)
+             (gnus-Subject-mark-as-unread nil t))
+            (t
+             (gnus-Subject-mark-as-unread)))
+      (while (and subject
+                  (gnus-Subject-search-forward nil subject))
+        (cond ((null unmark)
+               (gnus-Subject-mark-as-read nil "K"))
+              ((> unmark 0)
+               (gnus-Subject-mark-as-unread nil t))
+              (t
+               (gnus-Subject-mark-as-unread)))
+        (setq count (1+ count))
+        ))
+    ;; Hide killed thread subtrees.  Does not work properly always.
+    ;;(and (null unmark)
+    ;;     gnus-thread-hide-killed
+    ;;     (gnus-Subject-hide-thread))
+    ;; Return number of articles marked as read.
+    count
+    ))
+
+(defun gnus-Subject-mark-as-unread-forward (count)
+  "Mark current article as unread, and then go forward.
+Argument COUNT specifies number of articles marked as unread."
+  (interactive "p")
+  (while (> count 0)
+    (gnus-Subject-mark-as-unread nil nil)
+    (gnus-Subject-next-subject 1 nil)
+    (setq count (1- count))))
+
+(defun gnus-Subject-mark-as-unread-backward (count)
+  "Mark current article as unread, and then go backward.
+Argument COUNT specifies number of articles marked as unread."
+  (interactive "p")
+  (while (> count 0)
+    (gnus-Subject-mark-as-unread nil nil)
+    (gnus-Subject-prev-subject 1 nil)
+    (setq count (1- count))))
+
+(defun gnus-Subject-mark-as-unread (&optional article clear-mark)
+  "Mark current article as unread.
+Optional first argument ARTICLE specifies article number to be
+marked as unread.  Optional second argument CLEAR-MARK removes
+any kind of mark."
+  (save-excursion
+    (set-buffer gnus-Subject-buffer)
+    ;; First of all, show hidden thread subtrees.
+    (gnus-Subject-show-thread)
+    (let* ((buffer-read-only nil)
+           (current (gnus-Subject-article-number))
+           (article (or article current)))
+      (gnus-mark-article-as-unread article clear-mark)
+      (if (or (eq article current)
+              (gnus-Subject-goto-subject article))
+          (progn
+            (beginning-of-line)
+            (delete-char 1)
+            (insert (if clear-mark " " "-"))))
+      )))
+
+(defun gnus-Subject-mark-as-read-forward (count)
+  "Mark current article as read, and then go forward.
+Argument COUNT specifies number of articles marked as read"
+  (interactive "p")
+  (while (> count 0)
+    (gnus-Subject-mark-as-read)
+    (gnus-Subject-next-subject 1 'unread-only)
+    (setq count (1- count))))
+
+(defun gnus-Subject-mark-as-read-backward (count)
+  "Mark current article as read, and then go backward.
+Argument COUNT specifies number of articles marked as read"
+  (interactive "p")
+  (while (> count 0)
+    (gnus-Subject-mark-as-read)
+    (gnus-Subject-prev-subject 1 'unread-only)
+    (setq count (1- count))))
+
+(defun gnus-Subject-mark-as-read (&optional article mark)
+  "Mark current article as read.
+Optional first argument ARTICLE specifies article number to be marked as read.
+Optional second argument MARK specifies a string inserted at beginning of line.
+Any kind of string (length 1) except for a space and `-' is ok."
+  (save-excursion
+    (set-buffer gnus-Subject-buffer)
+    ;; First of all, show hidden thread subtrees.
+    (gnus-Subject-show-thread)
+    (let* ((buffer-read-only nil)
+           (mark (or mark "D"))         ;Default mark is `D'.
+           (current (gnus-Subject-article-number))
+           (article (or article current)))
+      (gnus-mark-article-as-read article)
+      (if (or (eq article current)
+              (gnus-Subject-goto-subject article))
+          (progn
+            (beginning-of-line)
+            (delete-char 1)
+            (insert mark)))
+      )))
+
+(defun gnus-Subject-clear-mark-forward (count)
+  "Remove current article's mark, and go forward.
+Argument COUNT specifies number of articles unmarked"
+  (interactive "p")
+  (while (> count 0)
+    (gnus-Subject-mark-as-unread nil t)
+    (gnus-Subject-next-subject 1 nil)
+    (setq count (1- count))))
+
+(defun gnus-Subject-clear-mark-backward (count)
+  "Remove current article's mark, and go backward.
+Argument COUNT specifies number of articles unmarked"
+  (interactive "p")
+  (while (> count 0)
+    (gnus-Subject-mark-as-unread nil t)
+    (gnus-Subject-prev-subject 1 nil)
+    (setq count (1- count))))
+
+(defun gnus-Subject-delete-marked-as-read ()
+  "Delete lines which are marked as read."
+  (interactive)
+  (if gnus-newsgroup-unreads
+      (let ((buffer-read-only nil))
+        (save-excursion
+          (goto-char (point-min))
+          (delete-non-matching-lines "^[ ---]"))
+        ;; Adjust point.
+        (if (eobp)
+            (gnus-Subject-prev-subject 1)
+          (beginning-of-line)
+          (search-forward ":" nil t)))
+    ;; It is not so good idea to make the buffer empty.
+    (message "All articles are marked as read")
+    ))
+
+(defun gnus-Subject-delete-marked-with (marks)
+  "Delete lines which are marked with MARKS (e.g. \"DK\")."
+  (interactive "sMarks: ")
+  (let ((buffer-read-only nil))
+    (save-excursion
+      (goto-char (point-min))
+      (delete-matching-lines (concat "^[" marks "]")))
+    ;; Adjust point.
+    (or (zerop (buffer-size))
+        (if (eobp)
+            (gnus-Subject-prev-subject 1)
+          (beginning-of-line)
+          (search-forward ":" nil t)))
+    ))
+
+;; Thread-based commands.
+
+(defun gnus-Subject-toggle-threads (arg)
+  "Toggle showing conversation threads.
+With arg, turn showing conversation threads on iff arg is positive."
+  (interactive "P")
+  (let ((current (gnus-Subject-article-number)))
+    (setq gnus-show-threads
+          (if (null arg) (not gnus-show-threads)
+            (> (prefix-numeric-value arg) 0)))
+    (gnus-Subject-prepare)
+    (gnus-Subject-goto-subject current)
+    ))
+
+(defun gnus-Subject-show-all-threads ()
+  "Show all thread subtrees."
+  (interactive)
+  (if gnus-show-threads
+      (save-excursion
+        (let ((buffer-read-only nil))
+          (subst-char-in-region (point-min) (point-max) ?\^M ?\n t)
+          ))))
+
+(defun gnus-Subject-show-thread ()
+  "Show thread subtrees."
+  (interactive)
+  (if gnus-show-threads
+      (save-excursion
+        (let ((buffer-read-only nil))
+          (subst-char-in-region (progn
+                                  (beginning-of-line) (point))
+                                (progn
+                                  (end-of-line) (point))
+                                ?\^M ?\n t)
+          ))))
+
+(defun gnus-Subject-hide-all-threads ()
+  "Hide all thread subtrees."
+  (interactive)
+  (if gnus-show-threads
+      (save-excursion
+        ;; Adjust cursor point.
+        (goto-char (point-min))
+        (search-forward ":" nil t)
+        (let ((level (current-column)))
+          (gnus-Subject-hide-thread)
+          (while (gnus-Subject-search-forward)
+            (and (>= level (current-column))
+                 (gnus-Subject-hide-thread)))
+          ))))
+
+(defun gnus-Subject-hide-thread ()
+  "Hide thread subtrees."
+  (interactive)
+  (if gnus-show-threads
+      (save-excursion
+        ;; Adjust cursor point.
+        (beginning-of-line)
+        (search-forward ":" nil t)
+        (let ((buffer-read-only nil)
+              (init (point))
+              (last (point))
+              (level (current-column)))
+          (while (and (gnus-Subject-search-forward)
+                      (< level (current-column)))
+            ;; Interested in lower levels.
+            (if (< level (current-column))
+                (progn
+                  (setq last (point))
+                  ))
+            )
+          (subst-char-in-region init last ?\n ?\^M t)
+          ))))
+
+(defun gnus-Subject-next-thread (n)
+  "Go to the same level next thread.
+Argument N specifies the number of threads."
+  (interactive "p")
+  ;; Adjust cursor point.
+  (beginning-of-line)
+  (search-forward ":" nil t)
+  (let ((init (point))
+        (last (point))
+        (level (current-column)))
+    (while (and (> n 0)
+                (gnus-Subject-search-forward)
+                (<= level (current-column)))
+      ;; We have to skip lower levels.
+      (if (= level (current-column))
+          (progn
+            (setq last (point))
+            (setq n (1- n))
+            ))
+      )
+    ;; Return non-nil if successfully move to the next.
+    (prog1 (not (= init last))
+      (goto-char last))
+    ))
+
+(defun gnus-Subject-prev-thread (n)
+  "Go to the same level previous thread.
+Argument N specifies the number of threads."
+  (interactive "p")
+  ;; Adjust cursor point.
+  (beginning-of-line)
+  (search-forward ":" nil t)
+  (let ((init (point))
+        (last (point))
+        (level (current-column)))
+    (while (and (> n 0)
+                (gnus-Subject-search-backward)
+                (<= level (current-column)))
+      ;; We have to skip lower levels.
+      (if (= level (current-column))
+          (progn
+            (setq last (point))
+            (setq n (1- n))
+            ))
+      )
+    ;; Return non-nil if successfully move to the previous.
+    (prog1 (not (= init last))
+      (goto-char last))
+    ))
+
+(defun gnus-Subject-down-thread (d)
+  "Go downward current thread.
+Argument D specifies the depth goes down."
+  (interactive "p")
+  ;; Adjust cursor point.
+  (beginning-of-line)
+  (search-forward ":" nil t)
+  (let ((last (point))
+        (level (current-column)))
+    (while (and (> d 0)
+                (gnus-Subject-search-forward)
+                (<= level (current-column))) ;<= can be <.  Which do you like?
+      ;; We have to skip the same levels.
+      (if (< level (current-column))
+          (progn
+            (setq last (point))
+            (setq level (current-column))
+            (setq d (1- d))
+            ))
+      )
+    (goto-char last)
+    ))
+
+(defun gnus-Subject-up-thread (d)
+  "Go upward current thread.
+Argument D specifies the depth goes up."
+  (interactive "p")
+  ;; Adjust cursor point.
+  (beginning-of-line)
+  (search-forward ":" nil t)
+  (let ((last (point))
+        (level (current-column)))
+    (while (and (> d 0)
+                (gnus-Subject-search-backward))
+      ;; We have to skip the same levels.
+      (if (> level (current-column))
+          (progn
+            (setq last (point))
+            (setq level (current-column))
+            (setq d (1- d))
+            ))
+      )
+    (goto-char last)
+    ))
+
+(defun gnus-Subject-kill-thread (unmark)
+  "Mark articles under current thread as read.
+If argument UNMARK is positive, remove any kinds of marks.
+If argument UNMARK is negative, mark articles as unread instead."
+  (interactive "P")
+  (if unmark
+      (setq unmark (prefix-numeric-value unmark)))
+  ;; Adjust cursor point.
+  (beginning-of-line)
+  (search-forward ":" nil t)
+  (save-excursion
+    (let ((level (current-column)))
+      ;; Mark current article.
+      (cond ((null unmark)
+             (gnus-Subject-mark-as-read nil "K"))
+            ((> unmark 0)
+             (gnus-Subject-mark-as-unread nil t))
+            (t
+             (gnus-Subject-mark-as-unread))
+            )
+      ;; Mark following articles.
+      (while (and (gnus-Subject-search-forward)
+                  (< level (current-column)))
+        (cond ((null unmark)
+               (gnus-Subject-mark-as-read nil "K"))
+              ((> unmark 0)
+               (gnus-Subject-mark-as-unread nil t))
+              (t
+               (gnus-Subject-mark-as-unread))
+              ))
+      ))
+  ;; Hide killed subtrees.
+  (and (null unmark)
+       gnus-thread-hide-killed
+       (gnus-Subject-hide-thread))
+  ;; If marked as read, go to next unread subject.
+  (if (null unmark)
+      ;; Go to next unread subject.
+      (gnus-Subject-next-subject 1 t))
+  )
+
+(defun gnus-Subject-toggle-truncation (arg)
+  "Toggle truncation of subject lines.
+With ARG, turn line truncation on iff ARG is positive."
+  (interactive "P")
+  (setq truncate-lines
+        (if (null arg) (not truncate-lines)
+          (> (prefix-numeric-value arg) 0)))
+  (redraw-display))
+
+(defun gnus-Subject-sort-by-number (reverse)
+  "Sort subject display buffer by article number.
+Argument REVERSE means reverse order."
+  (interactive "P")
+  (gnus-Subject-sort-subjects
+   (function
+    (lambda (a b)
+      (< (nntp-header-number a) (nntp-header-number b))))
+   reverse
+   ))
+
+(defun gnus-Subject-sort-by-author (reverse)
+  "Sort subject display buffer by author name alphabetically.
+If case-fold-search is non-nil, case of letters is ignored.
+Argument REVERSE means reverse order."
+  (interactive "P")
+  (gnus-Subject-sort-subjects
+   (function
+    (lambda (a b)
+      (gnus-string-lessp (nntp-header-from a) (nntp-header-from b))))
+   reverse
+   ))
+
+(defun gnus-Subject-sort-by-subject (reverse)
+  "Sort subject display buffer by subject alphabetically. `Re:'s are ignored.
+If case-fold-search is non-nil, case of letters is ignored.
+Argument REVERSE means reverse order."
+  (interactive "P")
+  (gnus-Subject-sort-subjects
+   (function
+    (lambda (a b)
+      (gnus-string-lessp
+       (gnus-simplify-subject (nntp-header-subject a) 're-only)
+       (gnus-simplify-subject (nntp-header-subject b) 're-only))))
+   reverse
+   ))
+
+(defun gnus-Subject-sort-by-date (reverse)
+  "Sort subject display buffer by posted date.
+Argument REVERSE means reverse order."
+  (interactive "P")
+  (gnus-Subject-sort-subjects
+   (function
+    (lambda (a b)
+      (gnus-date-lessp (nntp-header-date a) (nntp-header-date b))))
+   reverse
+   ))
+
+(defun gnus-Subject-sort-subjects (predicate &optional reverse)
+  "Sort subject display buffer by PREDICATE.
+Optional argument REVERSE means reverse order."
+  (let ((current (gnus-Subject-article-number)))
+    (gnus-sort-headers predicate reverse)
+    (gnus-Subject-prepare)
+    (gnus-Subject-goto-subject current)
+    ))
+
+(defun gnus-Subject-reselect-current-group (show-all)
+  "Once exit and then reselect the current newsgroup.
+Prefix argument SHOW-ALL means to select all articles."
+  (interactive "P")
+  (let ((current-subject (gnus-Subject-article-number)))
+    (gnus-Subject-exit t)
+    ;; We have to adjust the point of Group mode buffer because the
+    ;; current point was moved to the next unread newsgroup by
+    ;; exiting.
+    (gnus-Subject-jump-to-group gnus-newsgroup-name)
+    (gnus-Group-read-group show-all t)
+    (gnus-Subject-goto-subject current-subject)
+    ))
+
+(defun gnus-Subject-caesar-message (rotnum)
+  "Caesar rotates all letters of current message by 13/47 places.
+With prefix arg, specifies the number of places to rotate each letter forward.
+Caesar rotates Japanese letters by 47 places in any case."
+  (interactive "P")
+  (gnus-Subject-select-article)
+  (gnus-overload-functions)
+  (gnus-eval-in-buffer-window gnus-Article-buffer
+    (save-restriction
+      (widen)
+      ;; We don't want to jump to the beginning of the message.
+      ;; `save-excursion' does not do its job.
+      (move-to-window-line 0)
+      (let ((last (point)))
+        (news-caesar-buffer-body rotnum)
+        (goto-char last)
+        (recenter 0)
+        ))
+    ))
+
+(defun gnus-Subject-rmail-digest ()
+  "Run RMAIL on current digest article.
+`gnus-Select-digest-hook' will be called with no arguments, if that
+value is non-nil.  It is possible to modify the article so that Rmail
+can work with it.
+
+`gnus-Rmail-digest-hook' will be called with no arguments, if that value
+is non-nil.  The hook is intended to customize Rmail mode."
+  (interactive)
+  (gnus-Subject-select-article)
+  (require 'rmail)
+  (let ((artbuf gnus-Article-buffer)
+        (digbuf (get-buffer-create gnus-Digest-buffer))
+        (mail-header-separator ""))
+    (set-buffer digbuf)
+    (buffer-flush-undo (current-buffer))
+    (setq buffer-read-only nil)
+    (erase-buffer)
+    (insert-buffer-substring artbuf)
+    (run-hooks 'gnus-Select-digest-hook)
+    (gnus-convert-article-to-rmail)
+    (goto-char (point-min))
+    ;; Rmail initializations.
+    (rmail-insert-rmail-file-header)
+    (rmail-mode)
+    (rmail-set-message-counters)
+    (rmail-show-message)
+    (condition-case ()
+        (progn
+          (undigestify-rmail-message)
+          (rmail-expunge)               ;Delete original message.
+          ;; File name is meaningless but `save-buffer' requires it.
+          (setq buffer-file-name "GNUS Digest")
+          (setq mode-line-buffer-identification
+                (concat "Digest: "
+                        (nntp-header-subject gnus-current-headers)))
+          ;; There is no need to write this buffer to a file.
+          (make-local-variable 'write-file-hooks)
+          (setq write-file-hooks
+                (list (function
+                       (lambda ()
+                         (set-buffer-modified-p nil)
+                         (message "(No changes need to be saved)")
+                         'no-need-to-write-this-buffer))))
+          ;; Default file name saving digest messages.
+          (setq rmail-last-rmail-file
+                (funcall gnus-rmail-save-name
+                         gnus-newsgroup-name
+                         gnus-current-headers
+                         gnus-newsgroup-last-rmail
+                         ))
+          (setq rmail-last-file
+                (funcall gnus-mail-save-name
+                         gnus-newsgroup-name
+                         gnus-current-headers
+                         gnus-newsgroup-last-mail
+                         ))
+          ;; Prevent generating new buffer named ***<N> each time.
+          (setq rmail-summary-buffer
+                (get-buffer-create gnus-Digest-summary-buffer))
+          (run-hooks 'gnus-Rmail-digest-hook)
+          ;; Take all windows safely.
+          (gnus-configure-windows '(1 0 0))
+          (pop-to-buffer gnus-Group-buffer)
+          ;; Use Subject and Article windows for Digest summary and
+          ;; Digest buffers.
+          (if gnus-digest-show-summary
+              (let ((gnus-Subject-buffer gnus-Digest-summary-buffer)
+                    (gnus-Article-buffer gnus-Digest-buffer))
+                (gnus-configure-windows 'SelectArticle)
+                (pop-to-buffer gnus-Digest-buffer)
+                (rmail-summary)
+                (pop-to-buffer gnus-Digest-summary-buffer)
+                (message (substitute-command-keys
+                          "Type \\[rmail-summary-quit] to return to GNUS")))
+            (let ((gnus-Subject-buffer gnus-Digest-buffer))
+              (gnus-configure-windows 'ExpandSubject)
+              (pop-to-buffer gnus-Digest-buffer)
+              (message (substitute-command-keys
+                        "Type \\[rmail-quit] to return to GNUS")))
+            )
+          ;; Move the buffers to the end of buffer list.
+          (bury-buffer gnus-Article-buffer)
+          (bury-buffer gnus-Group-buffer)
+          (bury-buffer gnus-Digest-summary-buffer)
+          (bury-buffer gnus-Digest-buffer))
+      (error (set-buffer-modified-p nil)
+             (kill-buffer digbuf)
+             ;; This command should not signal an error because the
+             ;; command is called from hooks.
+             (ding) (message "Article is not a digest")))
+    ))
+
+(defun gnus-Subject-save-article ()
+  "Save this article using default saver function.
+Variable `gnus-default-article-saver' specifies the saver function."
+  (interactive)
+  (gnus-Subject-select-article
+   (not (null gnus-save-all-headers)) gnus-save-all-headers)
+  (if gnus-default-article-saver
+      (call-interactively gnus-default-article-saver)
+    (error "No default saver is defined.")))
+
+(defun gnus-Subject-save-in-rmail (&optional filename)
+  "Append this article to Rmail file.
+Optional argument FILENAME specifies file name.
+Directory to save to is default to `gnus-article-save-directory' which
+is initialized from the SAVEDIR environment variable."
+  (interactive)
+  (gnus-Subject-select-article
+   (not (null gnus-save-all-headers)) gnus-save-all-headers)
+  (gnus-eval-in-buffer-window gnus-Article-buffer
+    (save-excursion
+      (save-restriction
+        (widen)
+        (let ((default-name
+                (funcall gnus-rmail-save-name
+                         gnus-newsgroup-name
+                         gnus-current-headers
+                         gnus-newsgroup-last-rmail
+                         )))
+          (or filename
+              (setq filename
+                    (read-file-name
+                     (concat "Save article in Rmail file: (default "
+                             (file-name-nondirectory default-name)
+                             ") ")
+                     (file-name-directory default-name)
+                     default-name)))
+          (gnus-make-directory (file-name-directory filename))
+          (gnus-output-to-rmail filename)
+          ;; Remember the directory name to save articles.
+          (setq gnus-newsgroup-last-rmail filename)
+          )))
+    ))
+
+(defun gnus-Subject-save-in-mail (&optional filename)
+  "Append this article to Unix mail file.
+Optional argument FILENAME specifies file name.
+Directory to save to is default to `gnus-article-save-directory' which
+is initialized from the SAVEDIR environment variable."
+  (interactive)
+  (gnus-Subject-select-article
+   (not (null gnus-save-all-headers)) gnus-save-all-headers)
+  (gnus-eval-in-buffer-window gnus-Article-buffer
+    (save-excursion
+      (save-restriction
+        (widen)
+        (let ((default-name
+                (funcall gnus-mail-save-name
+                         gnus-newsgroup-name
+                         gnus-current-headers
+                         gnus-newsgroup-last-mail
+                         )))
+          (or filename
+              (setq filename
+                    (read-file-name
+                     (concat "Save article in Unix mail file: (default "
+                             (file-name-nondirectory default-name)
+                             ") ")
+                     (file-name-directory default-name)
+                     default-name)))
+          (gnus-make-directory (file-name-directory filename))
+          (rmail-output filename)
+          ;; Remember the directory name to save articles.
+          (setq gnus-newsgroup-last-mail filename)
+          )))
+    ))
+
+(defun gnus-Subject-save-in-file (&optional filename)
+  "Append this article to file.
+Optional argument FILENAME specifies file name.
+Directory to save to is default to `gnus-article-save-directory' which
+is initialized from the SAVEDIR environment variable."
+  (interactive)
+  (gnus-Subject-select-article
+   (not (null gnus-save-all-headers)) gnus-save-all-headers)
+  (gnus-eval-in-buffer-window gnus-Article-buffer
+    (save-excursion
+      (save-restriction
+        (widen)
+        (let ((default-name
+                (funcall gnus-file-save-name
+                         gnus-newsgroup-name
+                         gnus-current-headers
+                         gnus-newsgroup-last-file
+                         )))
+          (or filename
+              (setq filename
+                    (read-file-name
+                     (concat "Save article in file: (default "
+                             (file-name-nondirectory default-name)
+                             ") ")
+                     (file-name-directory default-name)
+                     default-name)))
+          (gnus-make-directory (file-name-directory filename))
+          (gnus-output-to-file filename)
+          ;; Remember the directory name to save articles.
+          (setq gnus-newsgroup-last-file filename)
+          )))
+    ))
+
+(defun gnus-Subject-save-in-folder (&optional folder)
+  "Save this article to MH folder (using `rcvstore' in MH library).
+Optional argument FOLDER specifies folder name."
+  (interactive)
+  (gnus-Subject-select-article
+   (not (null gnus-save-all-headers)) gnus-save-all-headers)
+  (gnus-eval-in-buffer-window gnus-Article-buffer
+    (save-restriction
+      (widen)
+      ;; Thanks to yuki@flab.Fujitsu.JUNET and ohm@kaba.junet.
+      (mh-find-path)
+      (let ((folder
+             (or folder
+                 (mh-prompt-for-folder "Save article in"
+                                       (funcall gnus-folder-save-name
+                                                gnus-newsgroup-name
+                                                gnus-current-headers
+                                                gnus-newsgroup-last-folder
+                                                )
+                                       t
+                                       )))
+            (errbuf (get-buffer-create " *GNUS rcvstore*")))
+        (unwind-protect
+            (call-process-region (point-min) (point-max)
+                                 (expand-file-name "rcvstore" mh-lib)
+                                 nil errbuf nil folder)
+          (set-buffer errbuf)
+          (if (zerop (buffer-size))
+              (message "Article saved in folder: %s" folder)
+            (message "%s" (buffer-string)))
+          (kill-buffer errbuf)
+          (setq gnus-newsgroup-last-folder folder))
+        ))
+    ))
+
+(defun gnus-Subject-pipe-output ()
+  "Pipe this article to subprocess."
+  (interactive)
+  ;; Ignore `gnus-save-all-headers' since this is not save command.
+  (gnus-Subject-select-article)
+  (gnus-eval-in-buffer-window gnus-Article-buffer
+    (save-restriction
+      (widen)
+      (let ((command (read-string "Shell command on article: "
+                                  gnus-last-shell-command)))
+        (if (string-equal command "")
+            (setq command gnus-last-shell-command))
+        (shell-command-on-region (point-min) (point-max) command nil)
+        (setq gnus-last-shell-command command)
+        ))
+    ))
+
+(defun gnus-Subject-catch-up (all &optional quietly)
+  "Mark all articles not marked as unread in this newsgroup as read.
+If prefix argument ALL is non-nil, all articles are marked as read."
+  (interactive "P")
+  (if (or quietly
+          (y-or-n-p
+           (if all
+               "Do you really want to mark everything as read? "
+             "Delete all articles not marked as unread? ")))
+      (let ((unmarked
+             (gnus-set-difference gnus-newsgroup-unreads
+                                  (if (not all) gnus-newsgroup-marked))))
+        (message "")                    ;Erase "Yes or No" question.
+        (while unmarked
+          (gnus-Subject-mark-as-read (car unmarked) "C")
+          (setq unmarked (cdr unmarked))
+          ))
+    ))
+
+(defun gnus-Subject-catch-up-all (&optional quietly)
+  "Mark all articles in this newsgroup as read."
+  (interactive)
+  (gnus-Subject-catch-up t quietly))
+
+(defun gnus-Subject-catch-up-and-exit (all &optional quietly)
+  "Mark all articles not marked as unread in this newsgroup as read, then exit.
+If prefix argument ALL is non-nil, all articles are marked as read."
+  (interactive "P")
+  (if (or quietly
+          (y-or-n-p
+           (if all
+               "Do you really want to mark everything as read? "
+             "Delete all articles not marked as unread? ")))
+      (let ((unmarked
+             (gnus-set-difference gnus-newsgroup-unreads
+                                  (if (not all) gnus-newsgroup-marked))))
+        (message "")                    ;Erase "Yes or No" question.
+        (while unmarked
+          (gnus-mark-article-as-read (car unmarked))
+          (setq unmarked (cdr unmarked)))
+        ;; Select next newsgroup or exit.
+        (cond ((eq gnus-auto-select-next 'quietly)
+               ;; Select next newsgroup quietly.
+               (gnus-Subject-next-group nil))
+              (t
+               (gnus-Subject-exit)))
+        )))
+
+(defun gnus-Subject-catch-up-all-and-exit (&optional quietly)
+  "Mark all articles in this newsgroup as read, and then exit."
+  (interactive)
+  (gnus-Subject-catch-up-and-exit t quietly))
+
+(defun gnus-Subject-edit-global-kill ()
+  "Edit a global KILL file."
+  (interactive)
+  (setq gnus-current-kill-article (gnus-Subject-article-number))
+  (gnus-Kill-file-edit-file nil)        ;Nil stands for global KILL file.
+  (message
+   (substitute-command-keys
+    "Editing a global KILL file (Type \\[gnus-Kill-file-exit] to exit)")))
+
+(defun gnus-Subject-edit-local-kill ()
+  "Edit a local KILL file applied to the current newsgroup."
+  (interactive)
+  (setq gnus-current-kill-article (gnus-Subject-article-number))
+  (gnus-Kill-file-edit-file gnus-newsgroup-name)
+  (message
+   (substitute-command-keys
+    "Editing a local KILL file (Type \\[gnus-Kill-file-exit] to exit)")))
+
+(defun gnus-Subject-exit (&optional temporary)
+  "Exit reading current newsgroup, and then return to group selection mode.
+gnus-Exit-group-hook is called with no arguments if that value is non-nil."
+  (interactive)
+  (let ((updated nil)
+        (gnus-newsgroup-headers gnus-newsgroup-headers)
+        (gnus-newsgroup-unreads gnus-newsgroup-unreads)
+        (gnus-newsgroup-unselected gnus-newsgroup-unselected)
+        (gnus-newsgroup-marked gnus-newsgroup-marked))
+    ;; Important internal variables are save, so we can reenter
+    ;; Subject Mode buffer even if hook changes them.
+    (run-hooks 'gnus-Exit-group-hook)
+    (gnus-update-unread-articles gnus-newsgroup-name
+                                 (append gnus-newsgroup-unselected
+                                         gnus-newsgroup-unreads)
+                                 gnus-newsgroup-marked)
+    ;; T means ignore unsubscribed newsgroups.
+    (if gnus-use-cross-reference
+        (setq updated
+              (gnus-mark-as-read-by-xref gnus-newsgroup-name
+                                         gnus-newsgroup-headers
+                                         gnus-newsgroup-unreads
+                                         (eq gnus-use-cross-reference t)
+                                         )))
+    ;; Do not switch windows but change the buffer to work.
+    (set-buffer gnus-Group-buffer)
+    ;; Update cross referenced group info.
+    (while updated
+      (gnus-Group-update-group (car updated) t) ;Ignore invisible group.
+      (setq updated (cdr updated)))
+    (gnus-Group-update-group gnus-newsgroup-name))
+  ;; Make sure where I was, and go to next newsgroup.
+  (gnus-Group-jump-to-group gnus-newsgroup-name)
+  (gnus-Group-next-unread-group 1)
+  (if temporary
+      ;; If exiting temporary, caller should adjust Group mode
+      ;; buffer point by itself.
+      nil                               ;Nothing to do.
+    ;; Return to Group mode buffer.
+    (if (get-buffer gnus-Subject-buffer)
+        (bury-buffer gnus-Subject-buffer))
+    (if (get-buffer gnus-Article-buffer)
+        (bury-buffer gnus-Article-buffer))
+    (gnus-configure-windows 'ExitNewsgroup)
+    (pop-to-buffer gnus-Group-buffer)))
+
+(defun gnus-Subject-quit ()
+  "Quit reading current newsgroup without updating read article info."
+  (interactive)
+  (if (y-or-n-p "Do you really wanna quit reading this group? ")
+      (progn
+        (message "")                    ;Erase "Yes or No" question.
+        ;; Return to Group selection mode.
+        (if (get-buffer gnus-Subject-buffer)
+            (bury-buffer gnus-Subject-buffer))
+        (if (get-buffer gnus-Article-buffer)
+            (bury-buffer gnus-Article-buffer))
+        (gnus-configure-windows 'ExitNewsgroup)
+        (pop-to-buffer gnus-Group-buffer)
+        (gnus-Group-jump-to-group gnus-newsgroup-name) ;Make sure where I was.
+        (gnus-Group-next-group 1)       ;(gnus-Group-next-unread-group 1)
+        )))
+
+(defun gnus-Subject-describe-briefly ()
+  "Describe Subject mode commands briefly."
+  (interactive)
+  (message
+   (concat
+    (substitute-command-keys "\\[gnus-Subject-next-page]:Select  ")
+    (substitute-command-keys "\\[gnus-Subject-next-unread-article]:Forward  ")
+    (substitute-command-keys "\\[gnus-Subject-prev-unread-article]:Backward  ")
+    (substitute-command-keys "\\[gnus-Subject-exit]:Exit  ")
+    (substitute-command-keys "\\[gnus-Info-find-node]:Run Info  ")
+    (substitute-command-keys "\\[gnus-Subject-describe-briefly]:This help")
+    )))
+
+
+;;;
+;;; GNUS Article Mode
+;;;
+
+(if gnus-Article-mode-map
+    nil
+  (setq gnus-Article-mode-map (make-keymap))
+  (suppress-keymap gnus-Article-mode-map)
+  (define-key gnus-Article-mode-map " " 'gnus-Article-next-page)
+  (define-key gnus-Article-mode-map "\177" 'gnus-Article-prev-page)
+  (define-key gnus-Article-mode-map "r" 'gnus-Article-refer-article)
+  (define-key gnus-Article-mode-map "o" 'gnus-Article-pop-article)
+  (define-key gnus-Article-mode-map "h" 'gnus-Article-show-subjects)
+  (define-key gnus-Article-mode-map "s" 'gnus-Article-show-subjects)
+  (define-key gnus-Article-mode-map "?" 'gnus-Article-describe-briefly)
+  (define-key gnus-Article-mode-map "\C-c\C-i" 'gnus-Info-find-node))
+
+(defun gnus-Article-mode ()
+  "Major mode for browsing through an article.
+All normal editing commands are turned off.
+Instead, these commands are available:
+\\{gnus-Article-mode-map}
+
+Various hooks for customization:
+ gnus-Article-mode-hook
+    Entry to this mode calls the value with no arguments, if that
+    value is non-nil.
+
+ gnus-Article-prepare-hook
+    Called with no arguments after an article is prepared for reading,
+    if that value is non-nil."
+  (interactive)
+  (kill-all-local-variables)
+  ;; Gee.  Why don't you upgrade?
+  (cond ((boundp 'mode-line-modified)
+         (setq mode-line-modified "--- "))
+        ((listp (default-value 'mode-line-format))
+         (setq mode-line-format
+               (cons "--- " (cdr (default-value 'mode-line-format))))))
+  (make-local-variable 'global-mode-string)
+  (setq global-mode-string nil)
+  (setq major-mode 'gnus-Article-mode)
+  (setq mode-name "Article")
+  (gnus-Article-set-mode-line)
+  (use-local-map gnus-Article-mode-map)
+  (make-local-variable 'page-delimiter)
+  (setq page-delimiter gnus-page-delimiter)
+  (make-local-variable 'mail-header-separator)
+  (setq mail-header-separator "")       ;For caesar function.
+  (buffer-flush-undo (current-buffer))
+  (setq buffer-read-only t)             ;Disable modification
+  (run-hooks 'gnus-Article-mode-hook))
+
+(defun gnus-Article-setup-buffer ()
+  "Initialize Article mode buffer."
+  (or (get-buffer gnus-Article-buffer)
+      (save-excursion
+        (set-buffer (get-buffer-create gnus-Article-buffer))
+        (gnus-Article-mode))
+      ))
+
+(defun gnus-Article-prepare (article &optional all-headers)
+  "Prepare ARTICLE in Article mode buffer.
+If optional argument ALL-HEADERS is non-nil, all headers are inserted."
+  (save-excursion
+    (set-buffer gnus-Article-buffer)
+    (let ((buffer-read-only nil))
+      (erase-buffer)
+      (if (gnus-request-article article)
+          (progn
+            ;; Prepare article buffer
+            (insert-buffer-substring nntp-server-buffer)
+            (setq gnus-have-all-headers (or all-headers gnus-show-all-headers))
+            (if (and (numberp article)
+                     (not (eq article gnus-current-article)))
+                ;; Seems me that a new article is selected.
+                (progn
+                  ;; gnus-current-article must be an article number.
+                  (setq gnus-last-article gnus-current-article)
+                  (setq gnus-current-article article)
+                  (setq gnus-current-headers
+                        (gnus-find-header-by-number gnus-newsgroup-headers
+                                                    gnus-current-article))
+                  ;; Clear articles history only when articles are
+                  ;; retrieved by article numbers.
+                  (setq gnus-current-history nil)
+                  (run-hooks 'gnus-Mark-article-hook)
+                  ))
+            ;; Hooks for modifying contents of the article. This hook
+            ;; must be called before being narrowed.
+            (run-hooks 'gnus-Article-prepare-hook)
+            ;; Delete unnecessary headers.
+            (or gnus-have-all-headers
+                (gnus-Article-delete-headers))
+            ;; Do page break.
+            (goto-char (point-min))
+            (if gnus-break-pages
+                (gnus-narrow-to-page))
+            ;; Next function must be called after setting
+            ;;  `gnus-current-article' variable and narrowed to page.
+            (gnus-Article-set-mode-line)
+            )
+        (if (numberp article)
+            (gnus-Subject-mark-as-read article))
+        (ding) (message "No such article (may be canceled)"))
+      )))
+
+(defun gnus-Article-show-all-headers ()
+  "Show all article headers in Article mode buffer."
+  (or gnus-have-all-headers
+      (gnus-Article-prepare gnus-current-article t)))
+
+;;(defun gnus-Article-set-mode-line ()
+;;  "Set Article mode line string."
+;;  (setq mode-line-buffer-identification
+;;      (list 17
+;;            (format "GNUS: %s {%d-%d} %d"
+;;                    gnus-newsgroup-name
+;;                    gnus-newsgroup-begin
+;;                    gnus-newsgroup-end
+;;                    gnus-current-article
+;;                    )))
+;;  (set-buffer-modified-p t))
+
+(defun gnus-Article-set-mode-line ()
+  "Set Article mode line string."
+  (let ((unmarked
+         (- (length gnus-newsgroup-unreads)
+            (length (gnus-intersection
+                     gnus-newsgroup-unreads gnus-newsgroup-marked))))
+        (unselected
+         (- (length gnus-newsgroup-unselected)
+            (length (gnus-intersection
+                     gnus-newsgroup-unselected gnus-newsgroup-marked)))))
+    (setq mode-line-buffer-identification
+          (list 17
+                (format "GNUS: %s{%d} %s"
+                        gnus-newsgroup-name
+                        gnus-current-article
+                        ;; This is proposed by tale@pawl.rpi.edu.
+                        (cond ((and (zerop unmarked)
+                                    (zerop unselected))
+                               "      ")
+                              ((zerop unselected)
+                               (format "%d more" unmarked))
+                              (t
+                               (format "%d(+%d) more" unmarked unselected)))
+                        ))))
+  (set-buffer-modified-p t))
+
+(defun gnus-Article-delete-headers ()
+  "Delete unnecessary headers."
+  (save-excursion
+    (save-restriction
+      (goto-char (point-min))
+      (narrow-to-region (point-min)
+                        (progn (search-forward "\n\n" nil 'move) (point)))
+      (goto-char (point-min))
+      (and (stringp gnus-ignored-headers)
+           (while (re-search-forward gnus-ignored-headers nil t)
+             (beginning-of-line)
+             (delete-region (point)
+                            (progn (re-search-forward "\n[^ \t]")
+                                   (forward-char -1)
+                                   (point)))))
+      )))
+
+;; Working on article's buffer
+
+(defun gnus-Article-next-page (lines)
+  "Show next page of current article.
+If end of article, return non-nil. Otherwise return nil.
+Argument LINES specifies lines to be scrolled up."
+  (interactive "P")
+  (move-to-window-line -1)
+  ;; Fixed by enami@ptgd.sony.co.jp (enami tsugutomo)
+  (if (save-excursion
+        (end-of-line)
+        (and (pos-visible-in-window-p)  ;Not continuation line.
+             (eobp)))
+      ;; Nothing in this page.
+      (if (or (not gnus-break-pages)
+              (save-excursion
+                (save-restriction
+                  (widen) (forward-line 1) (eobp)))) ;Real end-of-buffer?
+          t                             ;Nothing more.
+        (gnus-narrow-to-page 1)         ;Go to next page.
+        nil
+        )
+    ;; More in this page.
+    (condition-case ()
+        (scroll-up lines)
+      (end-of-buffer
+       ;; Long lines may cause an end-of-buffer error.
+       (goto-char (point-max))))
+    nil
+    ))
+
+(defun gnus-Article-prev-page (lines)
+  "Show previous page of current article.
+Argument LINES specifies lines to be scrolled down."
+  (interactive "P")
+  (move-to-window-line 0)
+  (if (and gnus-break-pages
+           (bobp)
+           (not (save-restriction (widen) (bobp)))) ;Real beginning-of-buffer?
+      (progn
+        (gnus-narrow-to-page -1) ;Go to previous page.
+        (goto-char (point-max))
+        (recenter -1))
+    (scroll-down lines)))
+
+(defun gnus-Article-next-digest (nth)
+  "Move to head of NTH next digested message.
+Set mark at end of digested message."
+  ;; Stop page breaking in digest mode.
+  (widen)
+  (end-of-line)
+  ;; Skip NTH - 1 digest.
+  ;; Suggested by Khalid Sattar <admin@cs.exeter.ac.uk>.
+  ;; Digest separator is customizable.
+  ;; Suggested by Skip Montanaro <montanaro@sprite.crd.ge.com>.
+  (while (and (> nth 1)
+              (re-search-forward gnus-digest-separator nil 'move))
+    (setq nth (1- nth)))
+  (if (re-search-forward gnus-digest-separator nil t)
+      (let ((begin (point)))
+        ;; Search for end of this message.
+        (end-of-line)
+        (if (re-search-forward gnus-digest-separator nil t)
+            (progn
+              (search-backward "\n\n")  ;This may be incorrect.
+              (forward-line 1))
+          (goto-char (point-max)))
+        (push-mark)                     ;Set mark at end of digested message.
+        (goto-char begin)
+        (beginning-of-line)
+        ;; Show From: and Subject: fields.
+        (recenter 1))
+    (message "End of message")
+    ))
+
+(defun gnus-Article-prev-digest (nth)
+  "Move to head of NTH previous digested message."
+  ;; Stop page breaking in digest mode.
+  (widen)
+  (beginning-of-line)
+  ;; Skip NTH - 1 digest.
+  ;; Suggested by Khalid Sattar <admin@cs.exeter.ac.uk>.
+  ;; Digest separator is customizable.
+  ;; Suggested by Skip Montanaro <montanaro@sprite.crd.ge.com>.
+  (while (and (> nth 1)
+              (re-search-backward gnus-digest-separator nil 'move))
+    (setq nth (1- nth)))
+  (if (re-search-backward gnus-digest-separator nil t)
+      (let ((begin (point)))
+        ;; Search for end of this message.
+        (end-of-line)
+        (if (re-search-forward gnus-digest-separator nil t)
+            (progn
+              (search-backward "\n\n")  ;This may be incorrect.
+              (forward-line 1))
+          (goto-char (point-max)))
+        (push-mark)                     ;Set mark at end of digested message.
+        (goto-char begin)
+        ;; Show From: and Subject: fields.
+        (recenter 1))
+    (goto-char (point-min))
+    (message "Top of message")
+    ))
+
+(defun gnus-Article-refer-article ()
+  "Read article specified by message-id around point."
+  (interactive)
+  (save-window-excursion
+    (save-excursion
+      (re-search-forward ">" nil t)     ;Move point to end of "<....>".
+      (if (re-search-backward "\\(<[^<> \t\n]+>\\)" nil t)
+          (let ((message-id
+                 (buffer-substring (match-beginning 1) (match-end 1))))
+            (set-buffer gnus-Subject-buffer)
+            (gnus-Subject-refer-article message-id))
+        (error "No references around point"))
+      )))
+
+(defun gnus-Article-pop-article ()
+  "Pop up article history."
+  (interactive)
+  (save-window-excursion
+    (set-buffer gnus-Subject-buffer)
+    (gnus-Subject-refer-article nil)))
+
+(defun gnus-Article-show-subjects ()
+  "Reconfigure windows to show headers."
+  (interactive)
+  (gnus-configure-windows 'SelectArticle)
+  (pop-to-buffer gnus-Subject-buffer)
+  (gnus-Subject-goto-subject gnus-current-article))
+
+(defun gnus-Article-describe-briefly ()
+  "Describe Article mode commands briefly."
+  (interactive)
+  (message
+   (concat
+    (substitute-command-keys "\\[gnus-Article-next-page]:Next page  ")
+    (substitute-command-keys "\\[gnus-Article-prev-page]:Prev page  ")
+    (substitute-command-keys "\\[gnus-Article-show-subjects]:Show headers  ")
+    (substitute-command-keys "\\[gnus-Info-find-node]:Run Info  ")
+    (substitute-command-keys "\\[gnus-Article-describe-briefly]:This help")
+    )))
+
+
+;;;
+;;; GNUS KILL-File Mode
+;;;
+
+(if gnus-Kill-file-mode-map
+    nil
+  (setq gnus-Kill-file-mode-map (copy-keymap emacs-lisp-mode-map))
+  (define-key gnus-Kill-file-mode-map "\C-c\C-k\C-s" 'gnus-Kill-file-kill-by-subject)
+  (define-key gnus-Kill-file-mode-map "\C-c\C-k\C-a" 'gnus-Kill-file-kill-by-author)
+  (define-key gnus-Kill-file-mode-map "\C-c\C-a" 'gnus-Kill-file-apply-buffer)
+  (define-key gnus-Kill-file-mode-map "\C-c\C-e" 'gnus-Kill-file-apply-last-sexp)
+  (define-key gnus-Kill-file-mode-map "\C-c\C-c" 'gnus-Kill-file-exit)
+  (define-key gnus-Kill-file-mode-map "\C-c\C-i" 'gnus-Info-find-node))
+
+(defun gnus-Kill-file-mode ()
+  "Major mode for editing KILL file.
+
+In addition to Emacs-Lisp Mode, the following commands are available:
+
+\\[gnus-Kill-file-kill-by-subject]      Insert KILL command for current subject.
+\\[gnus-Kill-file-kill-by-author]       Insert KILL command for current author.
+\\[gnus-Kill-file-apply-buffer] Apply current buffer to selected newsgroup.
+\\[gnus-Kill-file-apply-last-sexp]      Apply sexp before point to selected newsgroup.
+\\[gnus-Kill-file-exit] Save file and exit editing KILL file.
+\\[gnus-Info-find-node] Read Info about KILL file.
+
+  A KILL file contains lisp expressions to be applied to a selected
+newsgroup. The purpose is to mark articles as read on the basis of
+some set of regexps. A global KILL file is applied to every newsgroup,
+and a local KILL file is applied to a specified newsgroup. Since a
+global KILL file is applied to every newsgroup, for better performance
+use a local one.
+
+  A KILL file can contain any kind of Emacs lisp expressions expected
+to be evaluated in the Subject buffer. Writing lisp programs for this
+purpose is not so easy because the internal working of GNUS must be
+well-known. For this reason, GNUS provides a general function which
+does this easily for non-Lisp programmers.
+
+  The `gnus-kill' function executes commands available in Subject Mode
+by their key sequences. `gnus-kill' should be called with FIELD,
+REGEXP and optional COMMAND and ALL. FIELD is a string representing
+the header field or an empty string. If FIELD is an empty string, the
+entire article body is searched for. REGEXP is a string which is
+compared with FIELD value. COMMAND is a string representing a valid
+key sequence in Subject Mode or Lisp expression. COMMAND is default to
+'(gnus-Subject-mark-as-read nil \"X\"). Make sure that COMMAND is
+executed in the Subject buffer.  If the second optional argument ALL
+is non-nil, the COMMAND is applied to articles which are already
+marked as read or unread.  Articles which are marked are skipped over
+by default.
+
+  For example, if you want to mark articles of which subjects contain
+the string `AI' as read, a possible KILL file may look like:
+
+        (gnus-kill \"Subject\" \"AI\")
+
+  If you want to mark articles with `D' instead of `X', you can use
+the following expression:
+
+        (gnus-kill \"Subject\" \"AI\" \"d\")
+
+In this example it is assumed that the command
+`gnus-Subject-mark-as-read-forward' is assigned to `d' in Subject Mode.
+
+  It is possible to delete unnecessary headers which are marked with
+`X' in a KILL file as follows:
+
+        (gnus-expunge \"X\")
+
+  If the Subject buffer is empty after applying KILL files, GNUS will
+exit the selected newsgroup normally.  If headers which are marked
+with `D' are deleted in a KILL file, it is impossible to read articles
+which are marked as read in the previous GNUS sessions.  Marks other
+than `D' should be used for articles which should really be deleted.
+
+Entry to this mode calls emacs-lisp-mode-hook and
+gnus-Kill-file-mode-hook with no arguments, if that value is non-nil."
+  (interactive)
+  (kill-all-local-variables)
+  (use-local-map gnus-Kill-file-mode-map)
+  (set-syntax-table emacs-lisp-mode-syntax-table)
+  (setq major-mode 'gnus-Kill-file-mode)
+  (setq mode-name "KILL-File")
+  (lisp-mode-variables nil)
+  (run-hooks 'emacs-lisp-mode-hook 'gnus-Kill-file-mode-hook))
+
+(defun gnus-Kill-file-edit-file (newsgroup)
+  "Begin editing a KILL file of NEWSGROUP.
+If NEWSGROUP is nil, the global KILL file is selected."
+  (interactive "sNewsgroup: ")
+  (let ((file (gnus-newsgroup-kill-file newsgroup)))
+    (gnus-make-directory (file-name-directory file))
+    ;; Save current window configuration if this is first invocation.
+    (or (and (get-file-buffer file)
+             (get-buffer-window (get-file-buffer file)))
+        (setq gnus-winconf-kill-file (current-window-configuration)))
+    ;; Hack windows.
+    (let ((buffer (find-file-noselect file)))
+      (cond ((get-buffer-window buffer)
+             (pop-to-buffer buffer))
+            ((eq major-mode 'gnus-Group-mode)
+             (gnus-configure-windows '(1 0 0)) ;Take all windows.
+             (pop-to-buffer gnus-Group-buffer)
+             (let ((gnus-Subject-buffer buffer))
+               (gnus-configure-windows '(1 1 0)) ;Split into two.
+               (pop-to-buffer buffer)))
+            ((eq major-mode 'gnus-Subject-mode)
+             (gnus-configure-windows 'SelectArticle)
+             (pop-to-buffer gnus-Article-buffer)
+             (bury-buffer gnus-Article-buffer)
+             (switch-to-buffer buffer))
+            (t                          ;No good rules.
+             (find-file-other-window file))
+            ))
+    (gnus-Kill-file-mode)
+    ))
+
+(defun gnus-Kill-file-kill-by-subject ()
+  "Insert KILL command for current subject."
+  (interactive)
+  (insert
+   (format "(gnus-kill \"Subject\" %s)\n"
+           (prin1-to-string
+            (if gnus-current-kill-article
+                (regexp-quote
+                 (nntp-header-subject
+                  (gnus-find-header-by-number gnus-newsgroup-headers
+                                              gnus-current-kill-article)))
+              "")))))
+
+(defun gnus-Kill-file-kill-by-author ()
+  "Insert KILL command for current author."
+  (interactive)
+  (insert
+   (format "(gnus-kill \"From\" %s)\n"
+           (prin1-to-string
+            (if gnus-current-kill-article
+                (regexp-quote
+                 (nntp-header-from
+                  (gnus-find-header-by-number gnus-newsgroup-headers
+                                              gnus-current-kill-article)))
+              "")))))
+
+(defun gnus-Kill-file-apply-buffer ()
+  "Apply current buffer to current newsgroup."
+  (interactive)
+  (if (and gnus-current-kill-article
+           (get-buffer gnus-Subject-buffer))
+      ;; Assume newsgroup is selected.
+      (let ((string (concat "(progn \n" (buffer-string) "\n)" )))
+        (save-excursion
+          (save-window-excursion
+            (pop-to-buffer gnus-Subject-buffer)
+            (eval (car (read-from-string string))))))
+    (ding) (message "No newsgroup is selected.")))
+
+(defun gnus-Kill-file-apply-last-sexp ()
+  "Apply sexp before point in current buffer to current newsgroup."
+  (interactive)
+  (if (and gnus-current-kill-article
+           (get-buffer gnus-Subject-buffer))
+      ;; Assume newsgroup is selected.
+      (let ((string
+             (buffer-substring
+              (save-excursion (forward-sexp -1) (point)) (point))))
+        (save-excursion
+          (save-window-excursion
+            (pop-to-buffer gnus-Subject-buffer)
+            (eval (car (read-from-string string))))))
+    (ding) (message "No newsgroup is selected.")))
+
+(defun gnus-Kill-file-exit ()
+  "Save a KILL file, then return to the previous buffer."
+  (interactive)
+  (save-buffer)
+  (let ((killbuf (current-buffer)))
+    ;; We don't want to return to Article buffer.
+    (and (get-buffer gnus-Article-buffer)
+         (bury-buffer (get-buffer gnus-Article-buffer)))
+    ;; Delete the KILL file windows.
+    (delete-windows-on killbuf)
+    ;; Restore last window configuration if available.
+    (and gnus-winconf-kill-file
+         (set-window-configuration gnus-winconf-kill-file))
+    (setq gnus-winconf-kill-file nil)
+    ;; Kill the KILL file buffer.  Suggested by tale@pawl.rpi.edu.
+    (kill-buffer killbuf)))
+
+
+;;;
+;;; Utility functions
+;;;
+
+;; Basic ideas by emv@math.lsa.umich.edu (Edward Vielmetti)
+
+(defun gnus-batch-kill ()
+  "Run batched KILL.
+Usage: emacs -batch -l gnus -f gnus-batch-kill NEWSGROUP ..."
+  (if (not noninteractive)
+      (error "gnus-batch-kill is to be used only with -batch"))
+  (let* ((group nil)
+         (subscribed nil)
+         (newsrc nil)
+         (yes-and-no
+          (gnus-parse-n-options
+           (apply (function concat)
+                  (mapcar (function (lambda (g) (concat g " ")))
+                          command-line-args-left))))
+         (yes (car yes-and-no))
+         (no  (cdr yes-and-no))
+         ;; Disable verbose message.
+         (gnus-novice-user nil)
+         (gnus-large-newsgroup nil)
+         (nntp-large-newsgroup nil))
+    ;; Eat all arguments.
+    (setq command-line-args-left nil)
+    ;; Startup GNUS.
+    (gnus)
+    ;; Apply kills to specified newsgroups in command line arguments.
+    (setq newsrc (copy-sequence gnus-newsrc-assoc))
+    (while newsrc
+      (setq group (car (car newsrc)))
+      (setq subscribed (nth 1 (car newsrc)))
+      (setq newsrc (cdr newsrc))
+      (if (and subscribed
+               (not (zerop (nth 1 (gnus-gethash group gnus-unread-hashtb))))
+               (if yes
+                   (string-match yes group) t)
+               (or (null no)
+                   (not (string-match no group))))
+          (progn
+            (gnus-Subject-read-group group nil t)
+            (if (eq (current-buffer) (get-buffer gnus-Subject-buffer))
+                (gnus-Subject-exit t))
+            ))
+      )
+    ;; Finally, exit Emacs.
+    (set-buffer gnus-Group-buffer)
+    (gnus-Group-exit)
+    ))
+
+(defun gnus-Numeric-save-name (newsgroup headers &optional last-file)
+  "Generate file name from NEWSGROUP, HEADERS, and optional LAST-FILE.
+If variable `gnus-use-long-file-name' is nil, it is ~/News/News.group/num.
+Otherwise, it is like ~/News/news/group/num."
+  (let ((default
+          (expand-file-name
+           (concat (if gnus-use-long-file-name
+                       (capitalize newsgroup)
+                     (gnus-newsgroup-directory-form newsgroup))
+                   "/" (int-to-string (nntp-header-number headers)))
+           (or gnus-article-save-directory "~/News"))))
+    (if (and last-file
+             (string-equal (file-name-directory default)
+                           (file-name-directory last-file))
+             (string-match "^[0-9]+$" (file-name-nondirectory last-file)))
+        default
+      (or last-file default))))
+
+(defun gnus-numeric-save-name (newsgroup headers &optional last-file)
+  "Generate file name from NEWSGROUP, HEADERS, and optional LAST-FILE.
+If variable `gnus-use-long-file-name' is nil, it is ~/News/news.group/num.
+Otherwise, it is like ~/News/news/group/num."
+  (let ((default
+          (expand-file-name
+           (concat (if gnus-use-long-file-name
+                       newsgroup
+                     (gnus-newsgroup-directory-form newsgroup))
+                   "/" (int-to-string (nntp-header-number headers)))
+           (or gnus-article-save-directory "~/News"))))
+    (if (and last-file
+             (string-equal (file-name-directory default)
+                           (file-name-directory last-file))
+             (string-match "^[0-9]+$" (file-name-nondirectory last-file)))
+        default
+      (or last-file default))))
+
+(defun gnus-Plain-save-name (newsgroup headers &optional last-file)
+  "Generate file name from NEWSGROUP, HEADERS, and optional LAST-FILE.
+If variable `gnus-use-long-file-name' is nil, it is ~/News/News.group.
+Otherwise, it is like ~/News/news/group/news."
+  (or last-file
+      (expand-file-name
+       (if gnus-use-long-file-name
+           (capitalize newsgroup)
+         (concat (gnus-newsgroup-directory-form newsgroup) "/news"))
+       (or gnus-article-save-directory "~/News"))))
+
+(defun gnus-plain-save-name (newsgroup headers &optional last-file)
+  "Generate file name from NEWSGROUP, HEADERS, and optional LAST-FILE.
+If variable `gnus-use-long-file-name' is nil, it is ~/News/news.group.
+Otherwise, it is like ~/News/news/group/news."
+  (or last-file
+      (expand-file-name
+       (if gnus-use-long-file-name
+           newsgroup
+         (concat (gnus-newsgroup-directory-form newsgroup) "/news"))
+       (or gnus-article-save-directory "~/News"))))
+
+(defun gnus-Folder-save-name (newsgroup headers &optional last-folder)
+  "Generate folder name from NEWSGROUP, HEADERS, and optional LAST-FOLDER.
+If variable `gnus-use-long-file-name' is nil, it is +News.group.
+Otherwise, it is like +news/group."
+  (or last-folder
+      (concat "+"
+              (if gnus-use-long-file-name
+                  (capitalize newsgroup)
+                (gnus-newsgroup-directory-form newsgroup)))))
+
+(defun gnus-folder-save-name (newsgroup headers &optional last-folder)
+  "Generate folder name from NEWSGROUP, HEADERS, and optional LAST-FOLDER.
+If variable `gnus-use-long-file-name' is nil, it is +news.group.
+Otherwise, it is like +news/group."
+  (or last-folder
+      (concat "+"
+              (if gnus-use-long-file-name
+                  newsgroup
+                (gnus-newsgroup-directory-form newsgroup)))))
+
+(defun gnus-apply-kill-file ()
+  "Apply KILL file to the current newsgroup."
+  ;; Apply the global KILL file.
+  (load (gnus-newsgroup-kill-file nil) t nil t)
+  ;; And then apply the local KILL file.
+  (load (gnus-newsgroup-kill-file gnus-newsgroup-name) t nil t))
+
+(defun gnus-Newsgroup-kill-file (newsgroup)
+  "Return the name of a KILL file of NEWSGROUP.
+If NEWSGROUP is nil, return the global KILL file instead."
+  (cond ((or (null newsgroup)
+             (string-equal newsgroup ""))
+         ;; The global KILL file is placed at top of the directory.
+         (expand-file-name gnus-kill-file-name
+                           (or gnus-article-save-directory "~/News")))
+        (gnus-use-long-file-name
+         ;; Append ".KILL" to capitalized newsgroup name.
+         (expand-file-name (concat (capitalize newsgroup)
+                                   "." gnus-kill-file-name)
+                           (or gnus-article-save-directory "~/News")))
+        (t
+         ;; Place "KILL" under the hierarchical directory.
+         (expand-file-name (concat (gnus-newsgroup-directory-form newsgroup)
+                                   "/" gnus-kill-file-name)
+                           (or gnus-article-save-directory "~/News")))
+        ))
+
+(defun gnus-newsgroup-kill-file (newsgroup)
+  "Return the name of a KILL file of NEWSGROUP.
+If NEWSGROUP is nil, return the global KILL file instead."
+  (cond ((or (null newsgroup)
+             (string-equal newsgroup ""))
+         ;; The global KILL file is placed at top of the directory.
+         (expand-file-name gnus-kill-file-name
+                           (or gnus-article-save-directory "~/News")))
+        (gnus-use-long-file-name
+         ;; Append ".KILL" to newsgroup name.
+         (expand-file-name (concat newsgroup "." gnus-kill-file-name)
+                           (or gnus-article-save-directory "~/News")))
+        (t
+         ;; Place "KILL" under the hierarchical directory.
+         (expand-file-name (concat (gnus-newsgroup-directory-form newsgroup)
+                                   "/" gnus-kill-file-name)
+                           (or gnus-article-save-directory "~/News")))
+        ))
+
+(defun gnus-newsgroup-directory-form (newsgroup)
+  "Make hierarchical directory name from NEWSGROUP name."
+  (let ((newsgroup (substring newsgroup 0)) ;Copy string.
+        (len (length newsgroup))
+        (idx 0))
+    ;; Replace all occurence of `.' with `/'.
+    (while (< idx len)
+      (if (= (aref newsgroup idx) ?.)
+          (aset newsgroup idx ?/))
+      (setq idx (1+ idx)))
+    newsgroup
+    ))
+
+(defun gnus-make-directory (directory)
+  "Make DIRECTORY recursively."
+  (let ((directory (expand-file-name directory default-directory)))
+    (or (file-exists-p directory)
+        (gnus-make-directory-1 "" directory))
+    ))
+
+(defun gnus-make-directory-1 (head tail)
+  (cond ((string-match "^/\\([^/]+\\)" tail)
+         (setq head
+               (concat (file-name-as-directory head)
+                       (substring tail (match-beginning 1) (match-end 1))))
+         (or (file-exists-p head)
+             (call-process "mkdir" nil nil nil head))
+         (gnus-make-directory-1 head (substring tail (match-end 1))))
+        ((string-equal tail "") t)
+        ))
+
+(defun gnus-simplify-subject (subject &optional re-only)
+  "Remove `Re:' and words in parentheses.
+If optional argument RE-ONLY is non-nil, strip `Re:' only."
+  (let ((case-fold-search t))           ;Ignore case.
+    ;; Remove `Re:' and `Re^N:'.
+    (if (string-match "\\`\\(re\\(\\^[0-9]+\\)?:[ \t]+\\)+" subject)
+        (setq subject (substring subject (match-end 0))))
+    ;; Remove words in parentheses from end.
+    (or re-only
+        (while (string-match "[ \t\n]*([^()]*)[ \t\n]*\\'" subject)
+          (setq subject (substring subject 0 (match-beginning 0)))))
+    ;; Return subject string.
+    subject
+    ))
+
+(defun gnus-optional-lines-and-from (header)
+  "Return a string like `NNN:AUTHOR' from HEADER."
+  (let ((name-length (length "umerin@photon")))
+    (substring (format "%3d:%s"
+                       ;; Lines of the article.
+                       ;; Suggested by dana@bellcore.com.
+                       (nntp-header-lines header)
+                       ;; Its author.
+                       (concat (mail-strip-quoted-names
+                                (nntp-header-from header))
+                               (make-string name-length ? )))
+               ;; 4 stands for length of `NNN:'.
+               0 (+ 4 name-length))))
+
+(defun gnus-optional-lines (header)
+  "Return a string like `NNN' from HEADER."
+  (format "%4d" (nntp-header-lines header)))
+
+(defun gnus-sort-headers (predicate &optional reverse)
+  "Sort current group headers by PREDICATE safely.
+*Safely* means C-g quitting is disabled during sorting.
+Optional argument REVERSE means reverse order."
+  (let ((inhibit-quit t))
+    (setq gnus-newsgroup-headers
+          (if reverse
+              (nreverse (sort (nreverse gnus-newsgroup-headers) predicate))
+            (sort gnus-newsgroup-headers predicate)))
+    ))
+
+(defun gnus-string-lessp (a b)
+  "Return T if first arg string is less than second in lexicographic order.
+If case-fold-search is non-nil, case of letters is ignored."
+  (if case-fold-search
+      (string-lessp (downcase a) (downcase b)) (string-lessp a b)))
+
+(defun gnus-date-lessp (date1 date2)
+  "Return T if DATE1 is earlyer than DATE2."
+  (string-lessp (gnus-comparable-date date1)
+                (gnus-comparable-date date2)))
+
+(defun gnus-comparable-date (date)
+  "Make comparable string by string-lessp from DATE."
+  (let ((month '(("JAN" . " 1")("FEB" . " 2")("MAR" . " 3")
+                 ("APR" . " 4")("MAY" . " 5")("JUN" . " 6")
+                 ("JUL" . " 7")("AUG" . " 8")("SEP" . " 9")
+                 ("OCT" . "10")("NOV" . "11")("DEC" . "12")))
+        (date (or date "")))
+    ;; Can understand the following styles:
+    ;; (1) 14 Apr 89 03:20:12 GMT
+    ;; (2) Fri, 17 Mar 89 4:01:33 GMT
+    (if (string-match
+         "\\([0-9]+\\) \\([^ ,]+\\) \\([0-9]+\\) \\([0-9:]+\\)" date)
+        (concat
+         ;; Year
+         (substring date (match-beginning 3) (match-end 3))
+         ;; Month
+         (cdr
+          (assoc
+           (upcase (substring date (match-beginning 2) (match-end 2))) month))
+         ;; Day
+         (format "%2d" (string-to-int
+                        (substring date
+                                   (match-beginning 1) (match-end 1))))
+         ;; Time
+         (substring date (match-beginning 4) (match-end 4)))
+      ;; Cannot understand DATE string.
+      date
+      )
+    ))
+
+(defun gnus-fetch-field (field)
+  "Return the value of the header FIELD of current article."
+  (save-excursion
+    (save-restriction
+      (widen)
+      (goto-char (point-min))
+      (narrow-to-region (point-min)
+                        (progn (search-forward "\n\n" nil 'move) (point)))
+      (mail-fetch-field field))))
+
+(fset 'gnus-expunge 'gnus-Subject-delete-marked-with)
+
+(defun gnus-kill (field regexp &optional command all)
+  "If FIELD of an article matches REGEXP, execute COMMAND.
+Optional third argument COMMAND is default to
+        (gnus-Subject-mark-as-read nil \"X\").
+If optional fourth argument ALL is non-nil, articles marked are also applied
+to.  If FIELD is an empty string (or nil), entire article body is searched for.
+COMMAND must be a lisp expression or a string representing a key sequence."
+  ;; We don't want to change current point nor window configuration.
+  (save-excursion
+    (save-window-excursion
+      ;; Selected window must be Subject mode buffer to execute
+      ;; keyboard macros correctly. See command_loop_1.
+      (switch-to-buffer gnus-Subject-buffer 'norecord)
+      (goto-char (point-min))           ;From the beginning.
+      (if (null command)
+          (setq command '(gnus-Subject-mark-as-read nil "X")))
+      (gnus-execute field regexp command nil (not all))
+      )))
+
+(defun gnus-execute (field regexp form &optional backward ignore-marked)
+  "If FIELD of article header matches REGEXP, execute lisp FORM (or a string).
+If FIELD is an empty string (or nil), entire article body is searched for.
+If optional fifth argument BACKWARD is non-nil, do backward instead.
+If optional sixth argument IGNORE-MARKED is non-nil, articles which are
+marked as read or unread are ignored."
+  (let ((function nil)
+        (header nil)
+        (article nil))
+    (if (string-equal field "")
+        (setq field nil))
+    (if (null field)
+        nil
+      (or (stringp field)
+          (setq field (symbol-name field)))
+      ;; Get access function of header filed.
+      (setq function (intern-soft (concat "gnus-header-" (downcase field))))
+      (if (and function (fboundp function))
+          (setq function (symbol-function function))
+        (error "Unknown header field: \"%s\"" field)))
+    ;; Make FORM funcallable.
+    (if (and (listp form) (not (eq (car form) 'lambda)))
+        (setq form (list 'lambda nil form)))
+    ;; Starting from the current article.
+    (or (and ignore-marked
+             ;; Articles marked as read and unread should be ignored.
+             (setq article (gnus-Subject-article-number))
+             (or (not (memq article gnus-newsgroup-unreads)) ;Marked as read.
+                 (memq article gnus-newsgroup-marked) ;Marked as unread.
+                 ))
+        (gnus-execute-1 function regexp form))
+    (while (gnus-Subject-search-subject backward ignore-marked nil)
+      (gnus-execute-1 function regexp form))
+    ))
+
+(defun gnus-execute-1 (function regexp form)
+  (save-excursion
+    ;; The point of Subject mode buffer must be saved during execution.
+    (let ((article (gnus-Subject-article-number)))
+      (if (null article)
+          nil                           ;Nothing to do.
+        (if function
+            ;; Compare with header field.
+            (let ((header (gnus-find-header-by-number
+                           gnus-newsgroup-headers article))
+                  (value nil))
+              (and header
+                   (progn
+                     (setq value (funcall function header))
+                     ;; Number (Lines:) or symbol must be converted to string.
+                     (or (stringp value)
+                         (setq value (prin1-to-string value)))
+                     (string-match regexp value))
+                   (if (stringp form)   ;Keyboard macro.
+                       (execute-kbd-macro form)
+                     (funcall form))))
+          ;; Search article body.
+          (let ((gnus-current-article nil) ;Save article pointer.
+                (gnus-last-article nil)
+                (gnus-break-pages nil)  ;No need to break pages.
+                (gnus-Mark-article-hook nil)) ;Inhibit marking as read.
+            (message "Searching for article: %d..." article)
+            (gnus-Article-setup-buffer)
+            (gnus-Article-prepare article t)
+            (if (save-excursion
+                  (set-buffer gnus-Article-buffer)
+                  (goto-char (point-min))
+                  (re-search-forward regexp nil t))
+                (if (stringp form)      ;Keyboard macro.
+                    (execute-kbd-macro form)
+                  (funcall form))))
+          ))
+      )))
+
+;;; caesar-region written by phr@prep.ai.mit.edu  Nov 86
+;;; modified by tower@prep Nov 86
+;;; Modified by umerin@flab.flab.Fujitsu.JUNET for ROT47.
+
+(defun gnus-caesar-region (&optional n)
+  "Caesar rotation of region by N, default 13, for decrypting netnews.
+ROT47 will be performed for Japanese text in any case."
+  (interactive (if current-prefix-arg   ; Was there a prefix arg?
+                   (list (prefix-numeric-value current-prefix-arg))
+                 (list nil)))
+  (cond ((not (numberp n)) (setq n 13))
+        ((< n 0) (setq n (- 26 (% (- n) 26))))
+        (t (setq n (% n 26))))          ;canonicalize N
+  (if (not (zerop n))           ; no action needed for a rot of 0
+      (progn
+        (if (or (not (boundp 'caesar-translate-table))
+                (/= (aref caesar-translate-table ?a) (+ ?a n)))
+            (let ((i 0) (lower "abcdefghijklmnopqrstuvwxyz") upper)
+              (message "Building caesar-translate-table...")
+              (setq caesar-translate-table (make-vector 256 0))
+              (while (< i 256)
+                (aset caesar-translate-table i i)
+                (setq i (1+ i)))
+              (setq lower (concat lower lower) upper (upcase lower) i 0)
+              (while (< i 26)
+                (aset caesar-translate-table (+ ?a i) (aref lower (+ i n)))
+                (aset caesar-translate-table (+ ?A i) (aref upper (+ i n)))
+                (setq i (1+ i)))
+              ;; ROT47 for Japanese text.
+              ;; Thanks to ichikawa@flab.fujitsu.junet.
+              (setq i 161)
+              (let ((t1 (logior ?O 128))
+                    (t2 (logior ?! 128))
+                    (t3 (logior ?~ 128)))
+                (while (< i 256)
+                  (aset caesar-translate-table i
+                        (let ((v (aref caesar-translate-table i)))
+                          (if (<= v t1) (if (< v t2) v (+ v 47))
+                            (if (<= v t3) (- v 47) v))))
+                  (setq i (1+ i))))
+              (message "Building caesar-translate-table... done")))
+        (let ((from (region-beginning))
+              (to (region-end))
+              (i 0) str len)
+          (setq str (buffer-substring from to))
+          (setq len (length str))
+          (while (< i len)
+            (aset str i (aref caesar-translate-table (aref str i)))
+            (setq i (1+ i)))
+          (goto-char from)
+          (delete-region from to)
+          (insert str)))))
+
+;; Functions accessing headers.
+;; Functions are more convenient than macros in some case.
+
+(defun gnus-header-number (header)
+  "Return article number in HEADER."
+  (nntp-header-number header))
+
+(defun gnus-header-subject (header)
+  "Return subject string in HEADER."
+  (nntp-header-subject header))
+
+(defun gnus-header-from (header)
+  "Return author string in HEADER."
+  (nntp-header-from header))
+
+(defun gnus-header-xref (header)
+  "Return xref string in HEADER."
+  (nntp-header-xref header))
+
+(defun gnus-header-lines (header)
+  "Return lines in HEADER."
+  (nntp-header-lines header))
+
+(defun gnus-header-date (header)
+  "Return date in HEADER."
+  (nntp-header-date header))
+
+(defun gnus-header-id (header)
+  "Return Id in HEADER."
+  (nntp-header-id header))
+
+(defun gnus-header-references (header)
+  "Return references in HEADER."
+  (nntp-header-references header))
+
+
+;;;
+;;; Article savers.
+;;;
+
+(defun gnus-output-to-rmail (file-name)
+  "Append the current article to an Rmail file named FILE-NAME."
+  (require 'rmail)
+  ;; Most of these codes are borrowed from rmailout.el.
+  (setq file-name (expand-file-name file-name))
+  (setq rmail-last-rmail-file file-name)
+  (let ((artbuf (current-buffer))
+        (tmpbuf (get-buffer-create " *GNUS-output*")))
+    (save-excursion
+      (or (get-file-buffer file-name)
+          (file-exists-p file-name)
+          (if (yes-or-no-p
+               (concat "\"" file-name "\" does not exist, create it? "))
+              (let ((file-buffer (create-file-buffer file-name)))
+                (save-excursion
+                  (set-buffer file-buffer)
+                  (rmail-insert-rmail-file-header)
+                  (let ((require-final-newline nil))
+                    (write-region (point-min) (point-max) file-name t 1)))
+                (kill-buffer file-buffer))
+            (error "Output file does not exist")))
+      (set-buffer tmpbuf)
+      (buffer-flush-undo (current-buffer))
+      (erase-buffer)
+      (insert-buffer-substring artbuf)
+      (gnus-convert-article-to-rmail)
+      ;; Decide whether to append to a file or to an Emacs buffer.
+      (let ((outbuf (get-file-buffer file-name)))
+        (if (not outbuf)
+            (append-to-file (point-min) (point-max) file-name)
+          ;; File has been visited, in buffer OUTBUF.
+          (set-buffer outbuf)
+          (let ((buffer-read-only nil)
+                (msg (and (boundp 'rmail-current-message)
+                          rmail-current-message)))
+            ;; If MSG is non-nil, buffer is in RMAIL mode.
+            (if msg
+                (progn (widen)
+                       (narrow-to-region (point-max) (point-max))))
+            (insert-buffer-substring tmpbuf)
+            (if msg
+                (progn
+                  (goto-char (point-min))
+                  (widen)
+                  (search-backward "\^_")
+                  (narrow-to-region (point) (point-max))
+                  (goto-char (1+ (point-min)))
+                  (rmail-count-new-messages t)
+                  (rmail-show-message msg))))))
+      )
+    (kill-buffer tmpbuf)
+    ))
+
+(defun gnus-output-to-file (file-name)
+  "Append the current article to a file named FILE-NAME."
+  (setq file-name (expand-file-name file-name))
+  (let ((artbuf (current-buffer))
+        (tmpbuf (get-buffer-create " *GNUS-output*")))
+    (save-excursion
+      (set-buffer tmpbuf)
+      (buffer-flush-undo (current-buffer))
+      (erase-buffer)
+      (insert-buffer-substring artbuf)
+      ;; Append newline at end of the buffer as separator, and then
+      ;; save it to file.
+      (goto-char (point-max))
+      (insert "\n")
+      (append-to-file (point-min) (point-max) file-name))
+    (kill-buffer tmpbuf)
+    ))
+
+(defun gnus-convert-article-to-rmail ()
+  "Convert article in current buffer to Rmail message format."
+  (let ((buffer-read-only nil))
+    ;; Convert article directly into Babyl format.
+    ;; Suggested by Rob Austein <sra@lcs.mit.edu>
+    (goto-char (point-min))
+    (insert "\^L\n0, unseen,,\n*** EOOH ***\n")
+    (while (search-forward "\n\^_" nil t) ;single char
+      (replace-match "\n^_"))           ;2 chars: "^" and "_"
+    (goto-char (point-max))
+    (insert "\^_")))
+
+;;(defun gnus-convert-article-to-rmail ()
+;;  "Convert article in current buffer to Rmail message format."
+;;  (let ((buffer-read-only nil))
+;;    ;; Insert special header of Unix mail.
+;;    (goto-char (point-min))
+;;    (insert "From "
+;;          (or (mail-strip-quoted-names (mail-fetch-field "from"))
+;;              "unknown")
+;;          " " (current-time-string) "\n")
+;;    ;; Stop quoting `From' since this seems unnecessary in most cases.
+;;    ;; ``Quote'' "\nFrom " as "\n>From "
+;;    ;;(while (search-forward "\nFrom " nil t)
+;;    ;;  (forward-char -5)
+;;    ;;  (insert ?>))
+;;    ;; Convert article to babyl format.
+;;    (rmail-convert-to-babyl-format)
+;;    ))
+
+
+;;;
+;;; Internal functions.
+;;;
+
+(defun gnus-start-news-server (&optional confirm)
+  "Open network stream to remote NNTP server.
+If optional argument CONFIRM is non-nil, ask you host that NNTP server
+is running even if it is defined.
+Run gnus-Open-server-hook just before opening news server."
+  (if (gnus-server-opened)
+      ;; Stream is already opened.
+      nil
+    ;; Open NNTP server.
+    (if (or confirm
+            (null gnus-nntp-server))
+        (if (and (boundp 'gnus-secondary-servers) gnus-secondary-servers)
+            ;; Read server name with completion.
+            (setq gnus-nntp-server
+                  (completing-read "NNTP server: "
+                                   (cons (list gnus-nntp-server)
+                                         gnus-secondary-servers)
+                                   nil nil gnus-nntp-server))
+          (setq gnus-nntp-server
+                (read-string "NNTP server: " gnus-nntp-server))))
+    ;; If no server name is given, local host is assumed.
+    (if (string-equal gnus-nntp-server "")
+        (setq gnus-nntp-server (system-name)))
+    (cond ((string-match ":" gnus-nntp-server)
+           ;; :DIRECTORY
+           (require 'mhspool)
+           (gnus-define-access-method 'mhspool)
+           (message "Looking up private directory..."))
+          ((and (null gnus-nntp-service)
+                (string-equal gnus-nntp-server (system-name)))
+           (require 'nnspool)
+           (gnus-define-access-method 'nnspool)
+           (message "Looking up local news spool..."))
+          (t
+           (gnus-define-access-method 'nntp)
+           (message "Connecting to NNTP server on %s..." gnus-nntp-server)))
+    (run-hooks 'gnus-Open-server-hook)
+    (cond ((gnus-open-server gnus-nntp-server gnus-nntp-service))
+          ((and (stringp (gnus-status-message))
+                (> (length (gnus-status-message)) 0))
+           ;; Show valuable message if available.
+           (error (gnus-status-message)))
+          (t (error "Cannot open NNTP server on %s" gnus-nntp-server)))
+    ))
+
+;; Dummy functions used only once. Should return nil.
+(defun gnus-server-opened () nil)
+(defun gnus-close-server () nil)
+
+(defun gnus-define-access-method (method &optional access-methods)
+  "Define access functions for the access METHOD.
+Methods defintion is taken from optional argument ACCESS-METHODS or
+the variable gnus-access-methods."
+  (let ((bindings
+         (cdr (assoc method (or access-methods gnus-access-methods)))))
+    (if (null bindings)
+        (error "Unknown access method: %s" method)
+      ;; Should not use symbol-function here since overload does not work.
+      (while bindings
+        (fset (car (car bindings)) (cdr (car bindings)))
+        (setq bindings (cdr bindings)))
+      )))
+
+(defun gnus-select-newsgroup (group &optional show-all)
+  "Select newsgroup GROUP.
+If optional argument SHOW-ALL is non-nil, all of articles in the group
+are selected."
+  (if (gnus-request-group group)
+      (let ((articles nil))
+        (setq gnus-newsgroup-name group)
+        (setq gnus-newsgroup-unreads
+              (gnus-uncompress-sequence
+               (nthcdr 2 (gnus-gethash group gnus-unread-hashtb))))
+        (cond (show-all
+               ;; Select all active articles.
+               (setq articles
+                     (gnus-uncompress-sequence
+                      (nthcdr 2 (gnus-gethash group gnus-active-hashtb)))))
+              (t
+               ;; Select unread articles only.
+               (setq articles gnus-newsgroup-unreads)))
+        ;; Require confirmation if selecting large newsgroup.
+        (setq gnus-newsgroup-unselected nil)
+        (if (not (numberp gnus-large-newsgroup))
+            nil
+          (let ((selected nil)
+                (number (length articles)))
+            (if (> number gnus-large-newsgroup)
+                (progn
+                  (condition-case ()
+                      (let ((input
+                             (read-string
+                              (format
+                               "How many articles from %s (default %d): "
+                               gnus-newsgroup-name number))))
+                        (setq selected
+                              (if (string-equal input "")
+                                  number (string-to-int input))))
+                    (quit
+                     (setq selected 0)))
+                  (cond ((and (> selected 0)
+                              (< selected number))
+                         ;; Select last N articles.
+                         (setq articles (nthcdr (- number selected) articles)))
+                        ((and (< selected 0)
+                              (< (- 0 selected) number))
+                         ;; Select first N articles.
+                         (setq selected (- 0 selected))
+                         (setq articles (copy-sequence articles))
+                         (setcdr (nthcdr (1- selected) articles) nil))
+                        ((zerop selected)
+                         (setq articles nil))
+                        ;; Otherwise select all.
+                        )
+                  ;; Get unselected unread articles.
+                  (setq gnus-newsgroup-unselected
+                        (gnus-set-difference gnus-newsgroup-unreads articles))
+                  ))
+            ))
+        ;; Get headers list.
+        (setq gnus-newsgroup-headers (gnus-retrieve-headers articles))
+        ;; UNREADS may contain expired articles, so we have to remove
+        ;;  them from the list.
+        (setq gnus-newsgroup-unreads
+              (gnus-intersection gnus-newsgroup-unreads
+                                 (mapcar
+                                  (function
+                                   (lambda (header)
+                                     (nntp-header-number header)))
+                                  gnus-newsgroup-headers)))
+        ;; Marked article must be a subset of unread articles.
+        (setq gnus-newsgroup-marked
+              (gnus-intersection (append gnus-newsgroup-unselected
+                                         gnus-newsgroup-unreads)
+                                 (cdr (assoc group gnus-marked-assoc))))
+        ;; First and last article in this newsgroup.
+        (setq gnus-newsgroup-begin
+              (if gnus-newsgroup-headers
+                  (nntp-header-number (car gnus-newsgroup-headers))
+                0
+                ))
+        (setq gnus-newsgroup-end
+              (if gnus-newsgroup-headers
+                  (nntp-header-number
+                   (gnus-last-element gnus-newsgroup-headers))
+                0
+                ))
+        ;; File name that an article was saved last.
+        (setq gnus-newsgroup-last-rmail nil)
+        (setq gnus-newsgroup-last-mail nil)
+        (setq gnus-newsgroup-last-folder nil)
+        (setq gnus-newsgroup-last-file nil)
+        ;; Reset article pointer etc.
+        (setq gnus-current-article nil)
+        (setq gnus-current-headers nil)
+        (setq gnus-current-history nil)
+        (setq gnus-have-all-headers nil)
+        (setq gnus-last-article nil)
+        ;; GROUP is successfully selected.
+        t
+        )
+    ))
+
+(defun gnus-more-header-backward ()
+  "Find new header backward."
+  (let ((first
+         (car (nth 2 (gnus-gethash gnus-newsgroup-name gnus-active-hashtb))))
+        (artnum gnus-newsgroup-begin)
+        (header nil))
+    (while (and (not header)
+                (> artnum first))
+      (setq artnum (1- artnum))
+      (setq header (car (gnus-retrieve-headers (list artnum)))))
+    header
+    ))
+
+(defun gnus-more-header-forward ()
+  "Find new header forward."
+  (let ((last
+         (cdr (nth 2 (gnus-gethash gnus-newsgroup-name gnus-active-hashtb))))
+        (artnum gnus-newsgroup-end)
+        (header nil))
+    (while (and (not header)
+                (< artnum last))
+      (setq artnum (1+ artnum))
+      (setq header (car (gnus-retrieve-headers (list artnum)))))
+    header
+    ))
+
+(defun gnus-extend-newsgroup (header &optional backward)
+  "Extend newsgroup selection with HEADER.
+Optional argument BACKWARD means extend toward backward."
+  (if header
+      (let ((artnum (nntp-header-number header)))
+        (setq gnus-newsgroup-headers
+              (if backward
+                  (cons header gnus-newsgroup-headers)
+                (append gnus-newsgroup-headers (list header))))
+        ;; We have to update unreads and unselected, but don't have to
+        ;; care about gnus-newsgroup-marked.
+        (if (memq artnum gnus-newsgroup-unselected)
+            (setq gnus-newsgroup-unreads
+                  (cons artnum gnus-newsgroup-unreads)))
+        (setq gnus-newsgroup-unselected
+              (delq artnum gnus-newsgroup-unselected))
+        (setq gnus-newsgroup-begin (min gnus-newsgroup-begin artnum))
+        (setq gnus-newsgroup-end (max gnus-newsgroup-end artnum))
+        )))
+
+(defun gnus-mark-article-as-read (article)
+  "Remember that ARTICLE is marked as read."
+  ;; Remove from unread and marked list.
+  (setq gnus-newsgroup-unreads
+        (delq article gnus-newsgroup-unreads))
+  (setq gnus-newsgroup-marked
+        (delq article gnus-newsgroup-marked)))
+
+(defun gnus-mark-article-as-unread (article &optional clear-mark)
+  "Remember that ARTICLE is marked as unread.
+Optional argument CLEAR-MARK means ARTICLE should not be remembered
+that it was marked as read once."
+  ;; Add to unread list.
+  (or (memq article gnus-newsgroup-unreads)
+      (setq gnus-newsgroup-unreads
+            (cons article gnus-newsgroup-unreads)))
+  ;; If CLEAR-MARK is non-nil, the article must be removed from marked
+  ;; list.  Otherwise, it must be added to the list.
+  (if clear-mark
+      (setq gnus-newsgroup-marked
+            (delq article gnus-newsgroup-marked))
+    (or (memq article gnus-newsgroup-marked)
+        (setq gnus-newsgroup-marked
+              (cons article gnus-newsgroup-marked)))))
+
+(defun gnus-clear-system ()
+  "Clear all variables and buffer."
+  ;; Clear GNUS variables.
+  (let ((variables gnus-variable-list))
+    (while variables
+      (set (car variables) nil)
+      (setq variables (cdr variables))))
+  ;; Clear other internal variables.
+  (setq gnus-active-hashtb nil)
+  (setq gnus-unread-hashtb nil)
+  ;; Kill the startup file.
+  (and gnus-current-startup-file
+       (get-file-buffer gnus-current-startup-file)
+       (kill-buffer (get-file-buffer gnus-current-startup-file)))
+  (setq gnus-current-startup-file nil)
+  ;; Kill GNUS buffers.
+  (let ((buffers gnus-buffer-list))
+    (while buffers
+      (if (get-buffer (car buffers))
+          (kill-buffer (car buffers)))
+      (setq buffers (cdr buffers))
+      )))
+
+(defun gnus-configure-windows (action)
+  "Configure GNUS windows according to the next ACTION.
+The ACTION is either a symbol, such as `SelectNewsgroup', or a
+configuration list such as `(1 1 2)'.  If ACTION is not a list,
+configuration list is got from the variable gnus-window-configuration."
+  (let* ((windows
+          (if (listp action)
+              action (car (cdr (assq action gnus-window-configuration)))))
+         (grpwin (get-buffer-window gnus-Group-buffer))
+         (subwin (get-buffer-window gnus-Subject-buffer))
+         (artwin (get-buffer-window gnus-Article-buffer))
+         (winsum nil)
+         (height nil)
+         (grpheight 0)
+         (subheight 0)
+         (artheight 0))
+    (if (or (null windows)              ;No configuration is specified.
+            (and (eq (null grpwin)
+                     (zerop (nth 0 windows)))
+                 (eq (null subwin)
+                     (zerop (nth 1 windows)))
+                 (eq (null artwin)
+                     (zerop (nth 2 windows)))))
+        ;; No need to change window configuration.
+        nil
+      (select-window (or grpwin subwin artwin (selected-window)))
+      ;; First of all, compute the height of each window.
+      (cond (gnus-use-full-window
+             ;; Take up the entire screen.
+             (delete-other-windows)
+             (setq height (window-height (selected-window))))
+            (t
+             (setq height (+ (if grpwin (window-height grpwin) 0)
+                             (if subwin (window-height subwin) 0)
+                             (if artwin (window-height artwin) 0)))))
+      ;; The Newsgroup buffer exits always. So, use it to extend the
+      ;; Group window so as to get enough window space.
+      (switch-to-buffer gnus-Group-buffer 'norecord)
+      (and (get-buffer gnus-Subject-buffer)
+           (delete-windows-on gnus-Subject-buffer))
+      (and (get-buffer gnus-Article-buffer)
+           (delete-windows-on gnus-Article-buffer))
+      ;; Compute expected window height.
+      (setq winsum (apply (function +) windows))
+      (if (not (zerop (nth 0 windows)))
+          (setq grpheight (max window-min-height
+                               (/ (* height (nth 0 windows)) winsum))))
+      (if (not (zerop (nth 1 windows)))
+          (setq subheight (max window-min-height
+                               (/ (* height (nth 1 windows)) winsum))))
+      (if (not (zerop (nth 2 windows)))
+          (setq artheight (max window-min-height
+                               (/ (* height (nth 2 windows)) winsum))))
+      (setq height (+ grpheight subheight artheight))
+      (enlarge-window (max 0 (- height (window-height (selected-window)))))
+      ;; Then split the window.
+      (and (not (zerop artheight))
+           (or (not (zerop grpheight))
+               (not (zerop subheight)))
+           (split-window-vertically (+ grpheight subheight)))
+      (and (not (zerop grpheight))
+           (not (zerop subheight))
+           (split-window-vertically grpheight))
+      ;; Then select buffers in each window.
+      (and (not (zerop grpheight))
+           (progn
+             (switch-to-buffer gnus-Group-buffer 'norecord)
+             (other-window 1)))
+      (and (not (zerop subheight))
+           (progn
+             (switch-to-buffer gnus-Subject-buffer 'norecord)
+             (other-window 1)))
+      (and (not (zerop artheight))
+           (progn
+             ;; If Article buffer does not exist, it will be created
+             ;; and initialized.
+             (gnus-Article-setup-buffer)
+             (switch-to-buffer gnus-Article-buffer 'norecord)))
+      )
+    ))
+
+(defun gnus-find-header-by-number (headers number)
+  "Return a header which is a element of HEADERS and has NUMBER."
+  (let ((found nil))
+    (while (and headers (not found))
+      ;; We cannot use `=' to accept non-numeric NUMBER.
+      (if (eq number (nntp-header-number (car headers)))
+          (setq found (car headers)))
+      (setq headers (cdr headers)))
+    found
+    ))
+
+(defun gnus-find-header-by-id (headers id)
+  "Return a header which is a element of HEADERS and has Message-ID."
+  (let ((found nil))
+    (while (and headers (not found))
+      (if (string-equal id (nntp-header-id (car headers)))
+          (setq found (car headers)))
+      (setq headers (cdr headers)))
+    found
+    ))
+
+(defun gnus-version ()
+  "Version numbers of this version of GNUS."
+  (interactive)
+  (cond ((and (boundp 'mhspool-version) (boundp 'nnspool-version))
+         (message "%s; %s; %s; %s"
+                  gnus-version nntp-version nnspool-version mhspool-version))
+        ((boundp 'mhspool-version)
+         (message "%s; %s; %s"
+                  gnus-version nntp-version mhspool-version))
+        ((boundp 'nnspool-version)
+         (message "%s; %s; %s"
+                  gnus-version nntp-version nnspool-version))
+        (t
+         (message "%s; %s" gnus-version nntp-version))))
+
+(defun gnus-Info-find-node ()
+  "Find Info documentation of GNUS."
+  (interactive)
+  (require 'info)
+  ;; Enlarge info window if needed.
+  (cond ((eq major-mode 'gnus-Group-mode)
+         (gnus-configure-windows '(1 0 0)) ;Take all windows.
+         (pop-to-buffer gnus-Group-buffer))
+        ((eq major-mode 'gnus-Subject-mode)
+         (gnus-configure-windows '(0 1 0)) ;Take all windows.
+         (pop-to-buffer gnus-Subject-buffer)))
+  (Info-goto-node (cdr (assq major-mode gnus-Info-nodes))))
+
+(defun gnus-overload-functions (&optional overloads)
+  "Overload functions specified by optional argument OVERLOADS.
+If nothing is specified, use the variable gnus-overload-functions."
+  (let ((defs nil)
+        (overloads (or overloads gnus-overload-functions)))
+    (while overloads
+      (setq defs (car overloads))
+      (setq overloads (cdr overloads))
+      ;; Load file before overloading function if necessary.  Make
+      ;; sure we cannot use `requre' always.
+      (and (not (fboundp (car defs)))
+           (car (cdr (cdr defs)))
+           (load (car (cdr (cdr defs))) nil 'nomessage))
+      (fset (car defs) (car (cdr defs)))
+      )))
+
+(defun gnus-make-threads (newsgroup-headers)
+  "Make conversation threads tree from NEWSGROUP-HEADERS."
+  (let ((headers newsgroup-headers)
+        (h nil)
+        (d nil)
+        (roots nil)
+        (dependencies nil))
+    ;; Make message dependency alist.
+    (while headers
+      (setq h (car headers))
+      (setq headers (cdr headers))
+      ;; Ignore invalid headers.
+      (if (vectorp h)                   ;Depends on nntp.el.
+          (progn
+            ;; Ignore broken references, e.g "<123@a.b.c".
+            (setq d (and (nntp-header-references h)
+                         (string-match "\\(<[^<>]+>\\)[^>]*$"
+                                       (nntp-header-references h))
+                         (gnus-find-header-by-id
+                          newsgroup-headers
+                          (substring (nntp-header-references h)
+                                     (match-beginning 1) (match-end 1)))))
+            ;; Check subject equality.
+            (or gnus-thread-ignore-subject
+                (null d)
+                (string-equal (gnus-simplify-subject
+                               (nntp-header-subject h) 're)
+                              (gnus-simplify-subject
+                               (nntp-header-subject d) 're))
+                ;; H should be a thread root.
+                (setq d nil))
+            ;; H depends on D.
+            (setq dependencies
+                  (cons (cons h d) dependencies))
+            ;; H is a thread root.
+            (if (null d)
+                (setq roots (cons h roots)))
+            ))
+      )
+    ;; Make complete threads from the roots.
+    ;; Note: dependencies are in reverse order, but
+    ;; gnus-make-threads-1 processes it in reverse order again.  So,
+    ;; we don't have to worry about it.
+    (mapcar
+     (function
+      (lambda (root)
+        (gnus-make-threads-1 root dependencies))) (nreverse roots))
+    ))
+
+(defun gnus-make-threads-1 (parent dependencies)
+  (let ((children nil)
+        (d nil)
+        (depends dependencies))
+    ;; Find children.
+    (while depends
+      (setq d (car depends))
+      (setq depends (cdr depends))
+      (and (cdr d)
+           (eq (nntp-header-id parent) (nntp-header-id (cdr d)))
+           (setq children (cons (car d) children))))
+    ;; Go down.
+    (cons parent
+          (mapcar
+           (function
+            (lambda (child)
+              (gnus-make-threads-1 child dependencies))) children))
+    ))
+
+(defun gnus-narrow-to-page (&optional arg)
+  "Make text outside current page invisible except for page delimiter.
+A numeric arg specifies to move forward or backward by that many pages,
+thus showing a page other than the one point was originally in."
+  (interactive "P")
+  (setq arg (if arg (prefix-numeric-value arg) 0))
+  (save-excursion
+    (forward-page -1)                   ;Beginning of current page.
+    (widen)
+    (if (> arg 0)
+        (forward-page arg)
+      (if (< arg 0)
+          (forward-page (1- arg))))
+    ;; Find the end of the page.
+    (forward-page)
+    ;; If we stopped due to end of buffer, stay there.
+    ;; If we stopped after a page delimiter, put end of restriction
+    ;; at the beginning of that line.
+    ;; These are commented out.
+    ;;    (if (save-excursion (beginning-of-line)
+    ;;                  (looking-at page-delimiter))
+    ;;  (beginning-of-line))
+    (narrow-to-region (point)
+                      (progn
+                        ;; Find the top of the page.
+                        (forward-page -1)
+                        ;; If we found beginning of buffer, stay there.
+                        ;; If extra text follows page delimiter on same line,
+                        ;; include it.
+                        ;; Otherwise, show text starting with following line.
+                        (if (and (eolp) (not (bobp)))
+                            (forward-line 1))
+                        (point)))
+    ))
+
+(defun gnus-last-element (list)
+  "Return last element of LIST."
+  (let ((last nil))
+    (while list
+      (if (null (cdr list))
+          (setq last (car list)))
+      (setq list (cdr list)))
+    last
+    ))
+
+(defun gnus-set-difference (list1 list2)
+  "Return a list of elements of LIST1 that do not appear in LIST2."
+  (let ((list1 (copy-sequence list1)))
+    (while list2
+      (setq list1 (delq (car list2) list1))
+      (setq list2 (cdr list2)))
+    list1
+    ))
+
+(defun gnus-intersection (list1 list2)
+  "Return a list of elements that appear in both LIST1 and LIST2."
+  (let ((result nil))
+    (while list2
+      (if (memq (car list2) list1)
+          (setq result (cons (car list2) result)))
+      (setq list2 (cdr list2)))
+    result
+    ))
+
+
+;;;
+;;; Get information about active articles, already read articles, and
+;;;  still unread articles.
+;;;
+
+;; GNUS internal format of gnus-newsrc-assoc and gnus-killed-assoc:
+;; (("general" t (1 . 1))
+;;  ("misc"    t (1 . 10) (12 . 15))
+;;  ("test"  nil (1 . 99)) ...)
+;; GNUS internal format of gnus-marked-assoc:
+;; (("general" 1 2 3)
+;;  ("misc" 2) ...)
+;; GNUS internal format of gnus-active-hashtb:
+;; (("general" t (1 . 1))
+;;  ("misc"    t (1 . 10))
+;;  ("test"  nil (1 . 99)) ...)
+;; GNUS internal format of gnus-unread-hashtb:
+;; (("general" 1 (1 . 1))
+;;  ("misc"   14 (1 . 10) (12 . 15))
+;;  ("test"   99 (1 . 99)) ...)
+
+(defun gnus-setup-news-info (&optional rawfile)
+  "Setup news information.
+If optional argument RAWFILE is non-nil, force to read raw startup file."
+  (let ((init (not (and gnus-newsrc-assoc
+                        gnus-active-hashtb
+                        gnus-unread-hashtb
+                        (not rawfile)
+                        ))))
+    ;; We have to clear some variables to re-initialize news info.
+    (if init
+        (setq gnus-newsrc-assoc nil
+              gnus-active-hashtb nil
+              gnus-unread-hashtb nil))
+    (if init
+        (gnus-read-newsrc-file rawfile))
+    (gnus-read-active-file)
+    (gnus-expire-marked-articles)
+    (gnus-get-unread-articles)
+    ;; Check new newsgroups and subscribe them.
+    (if init
+        (let ((new-newsgroups (gnus-find-new-newsgroups)))
+          (while new-newsgroups
+            (funcall gnus-subscribe-newsgroup-method (car new-newsgroups))
+            (setq new-newsgroups (cdr new-newsgroups))
+            )))
+    ))
+
+(defun gnus-subscribe-newsgroup (newsgroup &optional next)
+  "Subscribe new NEWSGROUP.
+If optional argument NEXT is non-nil, it is inserted before NEXT."
+  (gnus-insert-newsgroup (list newsgroup t) next)
+  (message "Newsgroup %s is subscribed" newsgroup))
+
+(defun gnus-add-newsgroup (newsgroup)
+  "Subscribe new NEWSGROUP safely and put it at top."
+  (and (null (assoc newsgroup gnus-newsrc-assoc)) ;Really new?
+       (gnus-gethash newsgroup gnus-active-hashtb) ;Really exist?
+       (gnus-insert-newsgroup (or (assoc newsgroup gnus-killed-assoc)
+                                  (list newsgroup t))
+                              (car (car gnus-newsrc-assoc)))))
+
+(defun gnus-find-new-newsgroups ()
+  "Looking for new newsgroups and return names.
+`-n' option of options line in .newsrc file is recognized."
+  (let ((group nil)
+        (new-newsgroups nil))
+    (mapatoms
+     (function
+      (lambda (sym)
+        (setq group (symbol-name sym))
+        ;; Taking account of `-n' option.
+        (and (or (null gnus-newsrc-options-n-no)
+                 (not (string-match gnus-newsrc-options-n-no group))
+                 (and gnus-newsrc-options-n-yes
+                      (string-match gnus-newsrc-options-n-yes group)))
+             (null (assoc group gnus-killed-assoc)) ;Ignore killed.
+             (null (assoc group gnus-newsrc-assoc)) ;Really new.
+             ;; Find new newsgroup.
+             (setq new-newsgroups
+                   (cons group new-newsgroups)))
+        ))
+     gnus-active-hashtb)
+    ;; Return new newsgroups.
+    new-newsgroups
+    ))
+
+(defun gnus-kill-newsgroup (group)
+  "Kill GROUP from gnus-newsrc-assoc, .newsrc and gnus-unread-hashtb."
+  (let ((info (assoc group gnus-newsrc-assoc)))
+    (if (null info)
+        nil
+      ;; Delete from gnus-newsrc-assoc
+      (setq gnus-newsrc-assoc (delq info gnus-newsrc-assoc))
+      ;; Add to gnus-killed-assoc.
+      (setq gnus-killed-assoc
+            (cons info
+                  (delq (assoc group gnus-killed-assoc) gnus-killed-assoc)))
+      ;; Clear unread hashtable.
+      ;; Thanks cwitty@csli.Stanford.EDU (Carl Witty).
+      (gnus-sethash group nil gnus-unread-hashtb)
+      ;; Then delete from .newsrc
+      (gnus-update-newsrc-buffer group 'delete)
+      ;; Return the deleted newsrc entry.
+      info
+      )))
+
+(defun gnus-insert-newsgroup (info &optional next)
+  "Insert newsrc INFO entry before NEXT.
+If optional argument NEXT is nil, appended to the last."
+  (if (null info)
+      (error "Invalid argument: %s" info))
+  (let* ((group (car info))             ;Newsgroup name.
+         (range
+          (gnus-difference-of-range
+           (nth 2 (gnus-gethash group gnus-active-hashtb)) (nthcdr 2 info))))
+    ;; Check duplication.
+    (if (assoc group gnus-newsrc-assoc)
+        (error "Duplicated: %s" group))
+    ;; Insert to gnus-newsrc-assoc.
+    (if (string-equal next (car (car gnus-newsrc-assoc)))
+        (setq gnus-newsrc-assoc
+              (cons info gnus-newsrc-assoc))
+      (let ((found nil)
+            (rest gnus-newsrc-assoc)
+            (tail (cons nil gnus-newsrc-assoc)))
+        ;; Seach insertion point.
+        (while (and (not found) rest)
+          (if (string-equal next (car (car rest)))
+              (setq found t)
+            (setq rest (cdr rest))
+            (setq tail (cdr tail))
+            ))
+        ;; Find it.
+        (setcdr tail nil)
+        (setq gnus-newsrc-assoc
+              (append gnus-newsrc-assoc (cons info rest)))
+        ))
+    ;; Delete from gnus-killed-assoc.
+    (setq gnus-killed-assoc
+          (delq (assoc group gnus-killed-assoc) gnus-killed-assoc))
+    ;; Then insert to .newsrc.
+    (gnus-update-newsrc-buffer group nil next)
+    ;; Add to gnus-unread-hashtb.
+    (gnus-sethash group
+                  (cons group           ;Newsgroup name.
+                        (cons (gnus-number-of-articles range) range))
+                  gnus-unread-hashtb)
+    ))
+
+(defun gnus-check-killed-newsgroups ()
+  "Check consistency between gnus-newsrc-assoc and gnus-killed-assoc."
+  (let ((group nil)
+        (new-killed nil)
+        (old-killed gnus-killed-assoc))
+    (while old-killed
+      (setq group (car (car old-killed)))
+      (and (or (null gnus-newsrc-options-n-no)
+               (not (string-match gnus-newsrc-options-n-no group))
+               (and gnus-newsrc-options-n-yes
+                    (string-match gnus-newsrc-options-n-yes group)))
+           (null (assoc group gnus-newsrc-assoc)) ;No duplication.
+           ;; Subscribed in options line and not in gnus-newsrc-assoc.
+           (setq new-killed
+                 (cons (car old-killed) new-killed)))
+      (setq old-killed (cdr old-killed))
+      )
+    (setq gnus-killed-assoc (nreverse new-killed))
+    ))
+
+(defun gnus-check-bogus-newsgroups (&optional confirm)
+  "Delete bogus newsgroups.
+If optional argument CONFIRM is non-nil, confirm deletion of newsgroups."
+  (let ((group nil)                     ;Newsgroup name temporary used.
+        (old-newsrc gnus-newsrc-assoc)
+        (new-newsrc nil)
+        (bogus nil)                     ;List of bogus newsgroups.
+        (old-killed gnus-killed-assoc)
+        (new-killed nil)
+        (old-marked gnus-marked-assoc)
+        (new-marked nil))
+    (message "Checking bogus newsgroups...")
+    ;; Update gnus-newsrc-assoc.
+    (while old-newsrc
+      (setq group (car (car old-newsrc)))
+      (if (or (gnus-gethash group gnus-active-hashtb)
+              (and confirm
+                   (not (y-or-n-p
+                         (format "Delete bogus newsgroup: %s " group)))))
+          ;; Active newsgroup.
+          (setq new-newsrc (cons (car old-newsrc) new-newsrc))
+        ;; Found a bogus newsgroup.
+        (setq bogus (cons group bogus)))
+      (setq old-newsrc (cdr old-newsrc))
+      )
+    (setq gnus-newsrc-assoc (nreverse new-newsrc))
+    ;; Update gnus-killed-assoc.
+    ;; The killed newsgroups are deleted without any confirmations.
+    (while old-killed
+      (setq group (car (car old-killed)))
+      (and (gnus-gethash group gnus-active-hashtb)
+           (null (assoc group gnus-newsrc-assoc))
+           ;; Active and really killed newsgroup.
+           (setq new-killed (cons (car old-killed) new-killed)))
+      (setq old-killed (cdr old-killed))
+      )
+    (setq gnus-killed-assoc (nreverse new-killed))
+    ;; Remove BOGUS from .newsrc file.
+    (while bogus
+      (gnus-update-newsrc-buffer (car bogus) 'delete)
+      (setq bogus (cdr bogus)))
+    ;; Update gnus-marked-assoc.
+    (while old-marked
+      (setq group (car (car old-marked)))
+      (if (and (cdr (car old-marked))   ;Non-empty?
+               (assoc group gnus-newsrc-assoc)) ;Not bogus?
+          (setq new-marked (cons (car old-marked) new-marked)))
+      (setq old-marked (cdr old-marked)))
+    (setq gnus-marked-assoc new-marked)
+    (message "Checking bogus newsgroups... done")
+    ))
+
+(defun gnus-get-unread-articles ()
+  "Compute diffs between active and read articles."
+  (let ((read gnus-newsrc-assoc)
+        (group-info nil)
+        (group-name nil)
+        (active nil)
+        (range nil))
+    (message "Checking new news...")
+    (or gnus-unread-hashtb
+        (setq gnus-unread-hashtb (gnus-make-hashtable)))
+    (while read
+      (setq group-info (car read))      ;About one newsgroup
+      (setq group-name (car group-info))
+      (setq active (nth 2 (gnus-gethash group-name gnus-active-hashtb)))
+      (if (and gnus-octive-hashtb
+               ;; Is nothing changed?
+               (equal active
+                      (nth 2 (gnus-gethash group-name gnus-octive-hashtb)))
+               ;; Is this newsgroup in the unread hash table?
+               (gnus-gethash group-name gnus-unread-hashtb)
+               )
+          nil                           ;Nothing to do.
+        (setq range (gnus-difference-of-range active (nthcdr 2 group-info)))
+        (gnus-sethash group-name
+                      (cons group-name  ;Group name
+                            (cons (gnus-number-of-articles range)
+                                  range)) ;Range of unread articles
+                      gnus-unread-hashtb)
+        )
+      (setq read (cdr read))
+      )
+    (message "Checking new news... done")
+    ))
+
+(defun gnus-expire-marked-articles ()
+  "Check expired article which is marked as unread."
+  (let ((marked-assoc gnus-marked-assoc)
+        (updated-assoc nil)
+        (marked nil)                    ;Current marked info.
+        (articles nil)                  ;List of marked articles.
+        (updated nil)                   ;List of real marked.
+        (begin nil))
+    (while marked-assoc
+      (setq marked (car marked-assoc))
+      (setq articles (cdr marked))
+      (setq updated nil)
+      (setq begin
+            (car (nth 2 (gnus-gethash (car marked) gnus-active-hashtb))))
+      (while (and begin articles)
+        (if (>= (car articles) begin)
+            ;; This article is still active.
+            (setq updated (cons (car articles) updated)))
+        (setq articles (cdr articles)))
+      (if updated
+          (setq updated-assoc
+                (cons (cons (car marked) updated) updated-assoc)))
+      (setq marked-assoc (cdr marked-assoc)))
+    (setq gnus-marked-assoc updated-assoc)
+    ))
+
+(defun gnus-mark-as-read-by-xref
+  (group headers unreads &optional subscribed-only)
+  "Mark articles as read using cross references and return updated newsgroups.
+Arguments are GROUP, HEADERS, UNREADS, and optional SUBSCRIBED-ONLY."
+  (let ((xref-list nil)
+        (header nil)
+        (xrefs nil)                     ;One Xref: field info.
+        (xref nil)                      ;(NEWSGROUP . ARTICLE)
+        (gname nil)                     ;Newsgroup name
+        (article nil))                  ;Article number
+    (while headers
+      (setq header (car headers))
+      (if (memq (nntp-header-number header) unreads)
+          ;; This article is not yet marked as read.
+          nil
+        (setq xrefs (gnus-parse-xref-field (nntp-header-xref header)))
+        ;; For each cross reference info. in one Xref: field.
+        (while xrefs
+          (setq xref (car xrefs))
+          (setq gname (car xref))       ;Newsgroup name
+          (setq article (cdr xref))     ;Article number
+          (or (string-equal group gname) ;Ignore current newsgroup.
+              ;; Ignore unsubscribed newsgroup if requested.
+              (and subscribed-only
+                   (not (nth 1 (assoc gname gnus-newsrc-assoc))))
+              ;; Ignore article marked as unread.
+              (memq article (cdr (assoc gname gnus-marked-assoc)))
+              (let ((group-xref (assoc gname xref-list)))
+                (if group-xref
+                    (if (memq article (cdr group-xref))
+                        nil             ;Alread marked.
+                      (setcdr group-xref (cons article (cdr group-xref))))
+                  ;; Create new assoc entry for GROUP.
+                  (setq xref-list (cons (list gname article) xref-list)))
+                ))
+          (setq xrefs (cdr xrefs))
+          ))
+      (setq headers (cdr headers)))
+    ;; Mark cross referenced articles as read.
+    (gnus-mark-xrefed-as-read xref-list)
+    ;;(message "%s %s" (prin1-to-string unreads) (prin1-to-string xref-list))
+    ;; Return list of updated group name.
+    (mapcar (function car) xref-list)
+    ))
+
+(defun gnus-parse-xref-field (xref-value)
+  "Parse Xref: field value, and return list of `(group . article-id)'."
+  (let ((xref-list nil)
+        (xref-value (or xref-value "")))
+    ;; Remove server host name.
+    (if (string-match "^[ \t]*[^ \t,]+[ \t,]+\\(.*\\)$" xref-value)
+        (setq xref-value (substring xref-value (match-beginning 1)))
+      (setq xref-value nil))
+    ;; Process each xref info.
+    (while xref-value
+      (if (string-match
+           "^[ \t,]*\\([^ \t,]+\\):\\([0-9]+\\)[^0-9]*" xref-value)
+          (progn
+            (setq xref-list
+                  (cons
+                   (cons
+                    ;; Group name
+                    (substring xref-value (match-beginning 1) (match-end 1))
+                    ;; Article-ID
+                    (string-to-int
+                     (substring xref-value (match-beginning 2) (match-end 2))))
+                   xref-list))
+            (setq xref-value (substring xref-value (match-end 2))))
+        (setq xref-value nil)))
+    ;; Return alist.
+    xref-list
+    ))
+
+(defun gnus-mark-xrefed-as-read (xrefs)
+  "Update unread article information using XREFS alist."
+  (let ((group nil)
+        (idlist nil)
+        (unread nil))
+    (while xrefs
+      (setq group (car (car xrefs)))
+      (setq idlist (cdr (car xrefs)))
+      (setq unread (gnus-uncompress-sequence
+                    (nthcdr 2 (gnus-gethash group gnus-unread-hashtb))))
+      (while idlist
+        (setq unread (delq (car idlist) unread))
+        (setq idlist (cdr idlist)))
+      (gnus-update-unread-articles group unread 'ignore)
+      (setq xrefs (cdr xrefs))
+      )))
+
+(defun gnus-update-unread-articles (group unread-list marked-list)
+  "Update unread articles of GROUP using UNREAD-LIST and MARKED-LIST."
+  (let ((active (nth 2 (gnus-gethash group gnus-active-hashtb)))
+        (unread (gnus-gethash group gnus-unread-hashtb)))
+    (if (or (null active) (null unread))
+        ;; Ignore unknown newsgroup.
+        nil
+      ;; Update gnus-unread-hashtb.
+      (if unread-list
+          (setcdr (cdr unread)
+                  (gnus-compress-sequence unread-list))
+        ;; All of the articles are read.
+        (setcdr (cdr unread) '((0 . 0))))
+      ;; Number of unread articles.
+      (setcar (cdr unread)
+              (gnus-number-of-articles (nthcdr 2 unread)))
+      ;; Update gnus-newsrc-assoc.
+      (if (> (car active) 0)
+          ;; Articles from 1 to N are not active.
+          (setq active (cons 1 (cdr active))))
+      (setcdr (cdr (assoc group gnus-newsrc-assoc))
+              (gnus-difference-of-range active (nthcdr 2 unread)))
+      ;; Update .newsrc buffer.
+      (gnus-update-newsrc-buffer group)
+      ;; Update gnus-marked-assoc.
+      (if (listp marked-list)           ;Includes NIL.
+          (let ((marked (assoc group gnus-marked-assoc)))
+            (cond (marked
+                   (setcdr marked marked-list))
+                  (marked-list          ;Non-NIL.
+                   (setq gnus-marked-assoc
+                         (cons (cons group marked-list)
+                               gnus-marked-assoc)))
+                  )))
+      )))
+
+(defun gnus-read-active-file ()
+  "Get active file from NNTP server."
+  (message "Reading active file...")
+  (if (gnus-request-list)               ;Get active file from server
+      (save-excursion
+        (set-buffer nntp-server-buffer)
+        ;; Save OLD active info.
+        (setq gnus-octive-hashtb gnus-active-hashtb)
+        (setq gnus-active-hashtb (gnus-make-hashtable))
+        (gnus-active-to-gnus-format)
+        (message "Reading active file... done"))
+    (error "Cannot read active file from NNTP server.")))
+
+(defun gnus-active-to-gnus-format ()
+  "Convert active file format to internal format."
+  ;; Delete unnecessary lines.
+  (goto-char (point-min))
+  (delete-matching-lines "^to\\..*$")
+  ;; Store active file in hashtable.
+  (goto-char (point-min))
+  (while
+      (re-search-forward
+       "^\\([^ \t]+\\)[ \t]+\\([0-9]+\\)[ \t]+\\([0-9]+\\)[ \t]+\\([ymn]\\).*$"
+       nil t)
+    (gnus-sethash
+     (buffer-substring (match-beginning 1) (match-end 1))
+     (list (buffer-substring (match-beginning 1) (match-end 1))
+           (string-equal
+            "y" (buffer-substring (match-beginning 4) (match-end 4)))
+           (cons (string-to-int
+                  (buffer-substring (match-beginning 3) (match-end 3)))
+                 (string-to-int
+                  (buffer-substring (match-beginning 2) (match-end 2)))))
+     gnus-active-hashtb)))
+
+(defun gnus-read-newsrc-file (&optional rawfile)
+  "Read startup FILE.
+If optional argument RAWFILE is non-nil, the raw startup file is read."
+  (setq gnus-current-startup-file
+        (let* ((file (expand-file-name gnus-startup-file nil))
+               (real-file (concat file "-" gnus-nntp-server)))
+          (if (file-exists-p real-file)
+              real-file file)))
+  ;; Reset variables which may be included in the quick startup file.
+  (let ((variables gnus-variable-list))
+    (while variables
+      (set (car variables) nil)
+      (setq variables (cdr variables))))
+  (let* ((newsrc-file gnus-current-startup-file)
+         (quick-file (concat newsrc-file ".el"))
+         (quick-loaded nil)
+         (newsrc-mod (nth 5 (file-attributes newsrc-file)))
+         (quick-mod (nth 5 (file-attributes quick-file))))
+    (save-excursion
+      ;; Prepare .newsrc buffer.
+      (set-buffer (find-file-noselect newsrc-file))
+      ;; It is not so good idea turning off undo.
+      ;;(buffer-flush-undo (current-buffer))
+      ;; Load quick .newsrc to restore gnus-marked-assoc and
+      ;; gnus-killed-assoc even if gnus-newsrc-assoc is out of date.
+      (condition-case nil
+          (setq quick-loaded (load quick-file t t t))
+        (error nil))
+      (cond ((and (not rawfile)         ;Not forced to read the raw file.
+                  (or (and (fboundp 'file-newer-than-file-p)
+                           (file-newer-than-file-p quick-file newsrc-file))
+                      (and newsrc-mod quick-mod
+                           ;; .newsrc.el is newer than .newsrc.
+                           ;; Some older version does not support function
+                           ;; `file-newer-than-file-p'.
+                           (or (< (car newsrc-mod) (car quick-mod))
+                               (and (= (car newsrc-mod) (car quick-mod))
+                                    (<= (nth 1 newsrc-mod) (nth 1 quick-mod))))
+                           ))
+                  quick-loaded
+                  gnus-newsrc-assoc     ;Really loaded?
+                  )
+             ;; We don't have to read the raw startup file.
+             )
+            (t
+             ;; Since .newsrc file is newer than quick file, read it.
+             (message "Reading %s..." newsrc-file)
+             (gnus-newsrc-to-gnus-format)
+             (gnus-check-killed-newsgroups)
+             (message "Reading %s... Done" newsrc-file)))
+      )))
+
+(defun gnus-make-newsrc-file (file)
+  "Make server dependent file name by catenating FILE and server host name."
+  (let* ((file (expand-file-name file nil))
+         (real-file (concat file "-" gnus-nntp-server)))
+    (if (file-exists-p real-file)
+        real-file file)
+    ))
+
+(defun gnus-newsrc-to-gnus-format ()
+  "Parse current buffer as .newsrc file."
+  (let ((newsgroup nil)
+        (subscribe nil)
+        (ranges nil)
+        (subrange nil)
+        (read-list nil))
+    ;; We have to re-initialize these variable (except for
+    ;; gnus-marked-assoc and gnus-killed-assoc) because quick startup
+    ;; file may contain bogus values.
+    (setq gnus-newsrc-options nil)
+    (setq gnus-newsrc-options-n-yes nil)
+    (setq gnus-newsrc-options-n-no nil)
+    (setq gnus-newsrc-assoc nil)
+    ;; Save options line to variable.
+    ;; Lines beginning with white spaces are treated as continuation
+    ;; line.  Refer man page of newsrc(5).
+    (goto-char (point-min))
+    (if (re-search-forward
+         "^[ \t]*options[ \t]*\\(.*\\(\n[ \t]+.*\\)*\\)[ \t]*$" nil t)
+        (progn
+          ;; Save entire options line.
+          (setq gnus-newsrc-options
+                (buffer-substring (match-beginning 1) (match-end 1)))
+          ;; Compile "-n" option.
+          (if (string-match "\\(^\\|[ \t\n]\\)-n" gnus-newsrc-options)
+              (let ((yes-and-no
+                     (gnus-parse-n-options
+                      (substring gnus-newsrc-options (match-end 0)))))
+                (setq gnus-newsrc-options-n-yes (car yes-and-no))
+                (setq gnus-newsrc-options-n-no  (cdr yes-and-no))
+                ))
+          ))
+    ;; Parse body of .newsrc file
+    ;; Options line continuation lines must be also considered here.
+    ;; Before supporting continuation lines, " newsgroup ! 1-5" was
+    ;; okay, but now it is invalid.  It should be "newsgroup! 1-5".
+    (goto-char (point-min))
+    ;; Due to overflows in regex.c, change the following regexp:
+    ;; "^\\([^:! \t\n]+\\)\\([:!]\\)[ \t]*\\(.*\\)$"
+    ;; Suggested by composer@bucsf.bu.edu (Jeff Kellem).
+    (while (re-search-forward
+            "^\\([^:! \t\n]+\\)\\([:!]\\)[ \t]*\\(\\(...\\)*.*\\)$" nil t)
+      (setq newsgroup (buffer-substring (match-beginning 1) (match-end 1)))
+      ;; Check duplications of newsgroups.
+      ;; Note: Checking the duplications takes very long time.
+      (if (assoc newsgroup gnus-newsrc-assoc)
+          (message "Ignore duplicated newsgroup: %s" newsgroup)
+        (setq subscribe
+              (string-equal
+               ":" (buffer-substring (match-beginning 2) (match-end 2))))
+        (setq ranges (buffer-substring (match-beginning 3) (match-end 3)))
+        (setq read-list nil)
+        (while (string-match "^[, \t]*\\([0-9-]+\\)" ranges)
+          (setq subrange (substring ranges (match-beginning 1) (match-end 1)))
+          (setq ranges (substring ranges (match-end 1)))
+          (cond ((string-match "^\\([0-9]+\\)-\\([0-9]+\\)$" subrange)
+                 (setq read-list
+                       (cons
+                        (cons (string-to-int
+                               (substring subrange
+                                          (match-beginning 1) (match-end 1)))
+                              (string-to-int
+                               (substring subrange
+                                          (match-beginning 2) (match-end 2))))
+                        read-list)))
+                ((string-match "^[0-9]+$" subrange)
+                 (setq read-list
+                       (cons (cons (string-to-int subrange)
+                                   (string-to-int subrange))
+                             read-list)))
+                (t
+                 (ding) (message "Ignoring bogus lines of %s" newsgroup)
+                 (sit-for 0))
+                ))
+        (setq gnus-newsrc-assoc
+              (cons (cons newsgroup (cons subscribe (nreverse read-list)))
+                    gnus-newsrc-assoc))
+        ))
+    (setq gnus-newsrc-assoc
+          (nreverse gnus-newsrc-assoc))
+    ))
+
+(defun gnus-parse-n-options (options)
+  "Parse -n NEWSGROUPS options and return a cons of YES and NO regexps."
+  (let ((yes nil)
+        (no nil)
+        (yes-or-no nil)                 ;`!' or not.
+        (newsgroup nil))
+    ;; Parse each newsgroup description such as "comp.all".  Commas
+    ;; and white spaces can be a newsgroup separator.
+    (while
+        (string-match "^[ \t\n,]*\\(!?\\)\\([^--- \t\n,][^ \t\n,]*\\)" options)
+      (setq yes-or-no
+            (substring options (match-beginning 1) (match-end 1)))
+      (setq newsgroup
+            (regexp-quote
+             (substring options
+                        (match-beginning 2) (match-end 2))))
+      (setq options (substring options (match-end 2)))
+      ;; Rewrite "all" to ".+" not ".*".  ".+" requires at least one
+      ;; character.
+      (while (string-match "\\(^\\|\\\\[.]\\)all\\(\\\\[.]\\|$\\)" newsgroup)
+        (setq newsgroup
+              (concat (substring newsgroup 0 (match-end 1))
+                      ".+"
+                      (substring newsgroup (match-beginning 2)))))
+      (cond ((string-equal yes-or-no "!")
+             (setq no (cons newsgroup no)))
+            ((string-equal newsgroup ".+")) ;Ignore `all'.
+            (t
+             (setq yes (cons newsgroup yes)))
+            ))
+    ;; Make a cons of regexps from parsing result.
+    (cons (if yes
+              (concat "^\\("
+                      (apply (function concat)
+                             (mapcar
+                              (function
+                               (lambda (newsgroup)
+                                 (concat newsgroup "\\|")))
+                              (cdr yes)))
+                      (car yes) "\\)"))
+          (if no
+              (concat "^\\("
+                      (apply (function concat)
+                             (mapcar
+                              (function
+                               (lambda (newsgroup)
+                                 (concat newsgroup "\\|")))
+                              (cdr no)))
+                      (car no) "\\)")))
+    ))
+
+(defun gnus-save-newsrc-file ()
+  "Save to .newsrc FILE."
+  ;; Note: We cannot save .newsrc file if all newsgroups are removed
+  ;; from the variable gnus-newsrc-assoc.
+  (and (or gnus-newsrc-assoc gnus-killed-assoc)
+       gnus-current-startup-file
+       (save-excursion
+         ;; A buffer containing .newsrc file may be deleted.
+         (set-buffer (find-file-noselect gnus-current-startup-file))
+         (if (not (buffer-modified-p))
+             (message "(No changes need to be saved)")
+           (message "Saving %s..." gnus-current-startup-file)
+           (let ((make-backup-files t)
+                 (version-control nil)
+                 (require-final-newline t)) ;Don't ask even if requested.
+             ;; Make backup file of master newsrc.
+             ;; You can stop or change version control of backup file.
+             ;; Suggested by jason@violet.berkeley.edu.
+             (run-hooks 'gnus-Save-newsrc-hook)
+             (save-buffer))
+           ;; Quickly loadable .newsrc.
+           (set-buffer (get-buffer-create " *GNUS-newsrc*"))
+           (buffer-flush-undo (current-buffer))
+           (erase-buffer)
+           (gnus-gnus-to-quick-newsrc-format)
+           (let ((make-backup-files nil)
+                 (version-control nil)
+                 (require-final-newline t)) ;Don't ask even if requested.
+             (write-file (concat gnus-current-startup-file ".el")))
+           (kill-buffer (current-buffer))
+           (message "Saving %s... Done" gnus-current-startup-file)
+           ))
+    ))
+
+(defun gnus-update-newsrc-buffer (group &optional delete next)
+  "Incrementally update .newsrc buffer about GROUP.
+If optional second argument DELETE is non-nil, delete the group.
+If optional third argument NEXT is non-nil, inserted before it."
+  (save-excursion
+    ;; Taking account of the killed startup file.
+    ;; Suggested by tale@pawl.rpi.edu.
+    (set-buffer (or (get-file-buffer gnus-current-startup-file)
+                    (find-file-noselect gnus-current-startup-file)))
+    ;; Options line continuation lines must be also considered here.
+    ;; Before supporting continuation lines, " newsgroup ! 1-5" was
+    ;; okay, but now it is invalid.  It should be "newsgroup! 1-5".
+    (let ((deleted nil)
+          (buffer-read-only nil))       ;May be not modifiable.
+      ;; Delete ALL entries which match for GROUP.
+      (goto-char (point-min))
+      (while (re-search-forward
+              (concat "^" (regexp-quote group) "[:!]") nil t)
+        (beginning-of-line)
+        (delete-region (point) (progn (forward-line 1) (point)))
+        (setq deleted t)                ;Old entry is deleted.
+        )
+      (if delete
+          nil
+        ;; Insert group entry.
+        (let ((newsrc (assoc group gnus-newsrc-assoc)))
+          (if (null newsrc)
+              nil
+            ;; Find insertion point.
+            (cond (deleted nil)         ;Insert here.
+                  ((and (stringp next)
+                        (progn
+                          (goto-char (point-min))
+                          (re-search-forward
+                           (concat "^" (regexp-quote next) "[:!]") nil t)))
+                   (beginning-of-line))
+                  (t
+                   (goto-char (point-max))
+                   (or (bolp)
+                       (insert "\n"))))
+            ;; Insert after options line.
+            (if (looking-at "^[ \t]*options\\([ \t]\\|$\\)")
+                (progn
+                  (forward-line 1)
+                  ;; Skip continuation lines.
+                  (while (and (not (eobp))
+                              (looking-at "^[ \t]+"))
+                    (forward-line 1))))
+            (insert group               ;Group name
+                    (if (nth 1 newsrc) ": " "! ")) ;Subscribed?
+            (gnus-ranges-to-newsrc-format (nthcdr 2 newsrc)) ;Read articles
+            (insert "\n")
+            )))
+      )))
+
+(defun gnus-gnus-to-quick-newsrc-format ()
+  "Insert GNUS variables such as `gnus-newsrc-assoc' in Lisp format."
+  (insert ";; GNUS internal format of .newsrc.\n")
+  (insert ";; Touch .newsrc instead if you think to remove this file.\n")
+  (let ((variable nil)
+        (variables gnus-variable-list)
+        ;; Temporary rebind to make changes invisible.
+        (gnus-killed-assoc gnus-killed-assoc))
+    ;; Remove duplicated or unsubscribed newsgroups in gnus-killed-assoc.
+    (gnus-check-killed-newsgroups)
+    ;; Then, insert lisp expressions.
+    (while variables
+      (setq variable (car variables))
+      (and (boundp variable)
+           (symbol-value variable)
+           (insert "(setq " (symbol-name variable) " '"
+                   (prin1-to-string (symbol-value variable))
+                   ")\n"))
+      (setq variables (cdr variables)))
+    ))
+
+(defun gnus-ranges-to-newsrc-format (ranges)
+  "Insert ranges of read articles."
+  (let ((range nil))                    ;Range is a pair of BEGIN and END.
+    (while ranges
+      (setq range (car ranges))
+      (setq ranges (cdr ranges))
+      (cond ((= (car range) (cdr range))
+             (if (= (car range) 0)
+                 (setq ranges nil)      ;No unread articles.
+               (insert (int-to-string (car range)))
+               (if ranges (insert ","))
+               ))
+            (t
+             (insert (int-to-string (car range))
+                     "-"
+                     (int-to-string (cdr range)))
+             (if ranges (insert ","))
+             ))
+      )))
+
+(defun gnus-compress-sequence (numbers)
+  "Convert list of sorted numbers to ranges."
+  (let* ((numbers (sort (copy-sequence numbers) (function <)))
+         (first (car numbers))
+         (last (car numbers))
+         (result nil))
+    (while numbers
+      (cond ((= last (car numbers)) nil) ;Omit duplicated number
+            ((= (1+ last) (car numbers)) ;Still in sequence
+             (setq last (car numbers)))
+            (t                          ;End of one sequence
+             (setq result (cons (cons first last) result))
+             (setq first (car numbers))
+             (setq last  (car numbers)))
+            )
+      (setq numbers (cdr numbers))
+      )
+    (nreverse (cons (cons first last) result))
+    ))
+
+(defun gnus-uncompress-sequence (ranges)
+  "Expand compressed format of sequence."
+  (let ((first nil)
+        (last  nil)
+        (result nil))
+    (while ranges
+      (setq first (car (car ranges)))
+      (setq last  (cdr (car ranges)))
+      (while (< first last)
+        (setq result (cons first result))
+        (setq first (1+ first)))
+      (setq result (cons first result))
+      (setq ranges (cdr ranges))
+      )
+    (nreverse result)
+    ))
+
+(defun gnus-number-of-articles (range)
+  "Compute number of articles from RANGE `((beg1 . end1) (beg2 . end2) ...)'."
+  (let ((count 0))
+    (while range
+      (if (/= (cdr (car range)) 0)
+          ;; If end1 is 0, it must be skipped. Usually no articles in
+          ;;  this group.
+          (setq count (+ count 1 (- (cdr (car range)) (car (car range))))))
+      (setq range (cdr range))
+      )
+    count                               ;Result
+    ))
+
+(defun gnus-difference-of-range (src obj)
+  "Compute (SRC - OBJ) on range.
+Range of SRC is expressed as `(beg . end)'.
+Range of OBJ is expressed as `((beg1 . end1) (beg2 . end2) ...)."
+  (let ((beg (car src))
+        (end (cdr src))
+        (range nil))                    ;This is result.
+    ;; Src may be nil.
+    (while (and src obj)
+      (let ((beg1 (car (car obj)))
+            (end1 (cdr (car obj))))
+        (cond ((> beg end)
+               (setq obj nil))          ;Terminate loop
+              ((< beg beg1)
+               (setq range (cons (cons beg (min (1- beg1) end)) range))
+               (setq beg (1+ end1)))
+              ((>= beg beg1)
+               (setq beg (max beg (1+ end1))))
+              )
+        (setq obj (cdr obj))            ;Next OBJ
+        ))
+    ;; Src may be nil.
+    (if (and src (<= beg end))
+        (setq range (cons (cons beg end) range)))
+    ;; Result
+    (if range
+        (nreverse range)
+      (list (cons 0 0)))
+    ))
+
+
+;;Local variables:
+;;eval: (put 'gnus-eval-in-buffer-window 'lisp-indent-function 1)
+;;end:
diff --git a/lisp/informat.el b/lisp/informat.el
new file mode 100644
index 00000000000..1f91cb5b8be
--- /dev/null
+++ b/lisp/informat.el
@@ -0,0 +1,415 @@
+;; Info support functions package for Emacs
+;; Copyright (C) 1986 Free Software Foundation, Inc.
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 1, or (at your option)
+;; any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs; see the file COPYING.  If not, write to
+;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+(require 'info)
+
+;;;###autoload
+(defun Info-tagify ()
+  "Create or update Info-file tag table in current buffer."
+  (interactive)
+  ;; Save and restore point and restrictions.
+  ;; save-restrictions would not work
+  ;; because it records the old max relative to the end.
+  ;; We record it relative to the beginning.
+  (message "Tagifying %s ..." (file-name-nondirectory (buffer-file-name)))
+  (let ((omin (point-min))
+        (omax (point-max))
+        (nomax (= (point-max) (1+ (buffer-size))))
+        (opoint (point)))
+    (unwind-protect
+        (progn
+          (widen)
+          (goto-char (point-min))
+          (if (search-forward "\^_\nIndirect:\n" nil t)
+              (message "Cannot tagify split info file")
+            (let ((regexp "Node:[ \t]*\\([^,\n\t]\\)*[,\t\n]")
+                  (case-fold-search t)
+                  list)
+              (while (search-forward "\n\^_" nil t)
+                (forward-line 1)
+                (let ((beg (point)))
+                  (forward-line 1)
+                  (if (re-search-backward regexp beg t)
+                      (setq list
+                            (cons (list (buffer-substring
+                                          (match-beginning 1)
+                                          (match-end 1))
+                                        beg)
+                                  list)))))
+              (goto-char (point-max))
+              (forward-line -8)
+              (let ((buffer-read-only nil))
+                (if (search-forward "\^_\nEnd tag table\n" nil t)
+                    (let ((end (point)))
+                      (search-backward "\nTag table:\n")
+                      (beginning-of-line)
+                      (delete-region (point) end)))
+                (goto-char (point-max))
+                (insert "\^_\f\nTag table:\n")
+                (move-marker Info-tag-table-marker (point))
+                (setq list (nreverse list))
+                (while list
+                  (insert "Node: " (car (car list)) ?\177)
+                  (princ (car (cdr (car list))) (current-buffer))
+                  (insert ?\n)
+                  (setq list (cdr list)))
+                (insert "\^_\nEnd tag table\n")))))
+      (goto-char opoint)
+      (narrow-to-region omin (if nomax (1+ (buffer-size))
+                               (min omax (point-max))))))
+  (message "Tagifying %s ... done" (file-name-nondirectory (buffer-file-name))))
+
+;;;###autoload
+(defun Info-split ()
+  "Split an info file into an indirect file plus bounded-size subfiles.
+Each subfile will be up to 50,000 characters plus one node.
+
+To use this command, first visit a large Info file that has a tag
+table.  The buffer is modified into a (small) indirect info file which
+should be saved in place of the original visited file.
+
+The subfiles are written in the same directory the original file is
+in, with names generated by appending `-' and a number to the original
+file name.  The indirect file still functions as an Info file, but it
+contains just the tag table and a directory of subfiles."
+
+  (interactive)
+  (if (< (buffer-size) 70000)
+      (error "This is too small to be worth splitting"))
+  (goto-char (point-min))
+  (search-forward "\^_")
+  (forward-char -1)
+  (let ((start (point))
+        (chars-deleted 0)
+        subfiles
+        (subfile-number 1)
+        (case-fold-search t)
+        (filename (file-name-sans-versions buffer-file-name)))
+    (goto-char (point-max))
+    (forward-line -8)
+    (setq buffer-read-only nil)
+    (or (search-forward "\^_\nEnd tag table\n" nil t)
+        (error "Tag table required; use M-x Info-tagify"))
+    (search-backward "\nTag table:\n")
+    (if (looking-at "\nTag table:\n\^_")
+        (error "Tag table is just a skeleton; use M-x Info-tagify"))
+    (beginning-of-line)
+    (forward-char 1)
+    (save-restriction
+      (narrow-to-region (point-min) (point))
+      (goto-char (point-min))
+      (while (< (1+ (point)) (point-max))
+        (goto-char (min (+ (point) 50000) (point-max)))
+        (search-forward "\^_" nil 'move)
+        (setq subfiles
+              (cons (list (+ start chars-deleted)
+                          (concat (file-name-nondirectory filename)
+                                  (format "-%d" subfile-number)))
+                    subfiles))
+        ;; Put a newline at end of split file, to make Unix happier.
+        (insert "\n")
+        (write-region (point-min) (point)
+                      (concat filename (format "-%d" subfile-number)))
+        (delete-region (1- (point)) (point))
+        ;; Back up over the final ^_.
+        (forward-char -1)
+        (setq chars-deleted (+ chars-deleted (- (point) start)))
+        (delete-region start (point))
+        (setq subfile-number (1+ subfile-number))))
+    (while subfiles
+      (goto-char start)
+      (insert (nth 1 (car subfiles))
+              (format ": %d" (car (car subfiles)))
+              "\n")
+      (setq subfiles (cdr subfiles)))
+    (goto-char start)
+    (insert "\^_\nIndirect:\n")
+    (search-forward "\nTag Table:\n")
+    (insert "(Indirect)\n")))
+
+;;;###autoload
+(defun Info-validate ()
+  "Check current buffer for validity as an Info file.
+Check that every node pointer points to an existing node."
+  (interactive)
+  (save-excursion
+    (save-restriction
+      (widen)
+      (goto-char (point-min))
+      (if (search-forward "\nTag table:\n(Indirect)\n" nil t)
+          (error "Don't yet know how to validate indirect info files: \"%s\""
+                 (buffer-name (current-buffer))))
+      (goto-char (point-min))
+      (let ((allnodes '(("*")))
+            (regexp "Node:[ \t]*\\([^,\n\t]*\\)[,\t\n]")
+            (case-fold-search t)
+            (tags-losing nil)
+            (lossages ()))
+        (while (search-forward "\n\^_" nil t)
+          (forward-line 1)
+          (let ((beg (point)))
+            (forward-line 1)
+            (if (re-search-backward regexp beg t)
+                (let ((name (downcase
+                              (buffer-substring
+                                (match-beginning 1)
+                                (progn
+                                  (goto-char (match-end 1))
+                                  (skip-chars-backward " \t")
+                                  (point))))))
+                  (if (assoc name allnodes)
+                      (setq lossages
+                            (cons (list name "Duplicate node-name" nil)
+                                  lossages))
+                      (setq allnodes
+                            (cons (list name
+                                        (progn
+                                          (end-of-line)
+                                          (and (re-search-backward
+                                                "prev[ious]*:" beg t)
+                                               (progn
+                                                 (goto-char (match-end 0))
+                                                 (downcase
+                                                   (Info-following-node-name)))))
+                                        beg)
+                                  allnodes)))))))
+        (goto-char (point-min))
+        (while (search-forward "\n\^_" nil t)
+          (forward-line 1)
+          (let ((beg (point))
+                thisnode next)
+            (forward-line 1)
+            (if (re-search-backward regexp beg t)
+                (save-restriction
+                  (search-forward "\n\^_" nil 'move)
+                  (narrow-to-region beg (point))
+                  (setq thisnode (downcase
+                                   (buffer-substring
+                                     (match-beginning 1)
+                                     (progn
+                                       (goto-char (match-end 1))
+                                       (skip-chars-backward " \t")
+                                       (point)))))
+                  (end-of-line)
+                  (and (search-backward "next:" nil t)
+                       (setq next (Info-validate-node-name "invalid Next"))
+                       (assoc next allnodes)
+                       (if (equal (car (cdr (assoc next allnodes)))
+                                  thisnode)
+                           ;; allow multiple `next' pointers to one node
+                           (let ((tem lossages))
+                             (while tem
+                               (if (and (equal (car (cdr (car tem)))
+                                               "should have Previous")
+                                        (equal (car (car tem))
+                                               next))
+                                   (setq lossages (delq (car tem) lossages)))
+                               (setq tem (cdr tem))))
+                         (setq lossages
+                               (cons (list next
+                                           "should have Previous"
+                                           thisnode)
+                                     lossages))))
+                  (end-of-line)
+                  (if (re-search-backward "prev[ious]*:" nil t)
+                      (Info-validate-node-name "invalid Previous"))
+                  (end-of-line)
+                  (if (search-backward "up:" nil t)
+                      (Info-validate-node-name "invalid Up"))
+                  (if (re-search-forward "\n* Menu:" nil t)
+                      (while (re-search-forward "\n\\* " nil t)
+                        (Info-validate-node-name
+                          (concat "invalid menu item "
+                                  (buffer-substring (point)
+                                                    (save-excursion
+                                                      (skip-chars-forward "^:")
+                                                      (point))))
+                          (Info-extract-menu-node-name))))
+                  (goto-char (point-min))
+                  (while (re-search-forward "\\*note[ \n]*[^:\t]*:" nil t)
+                    (goto-char (+ (match-beginning 0) 5))
+                    (skip-chars-forward " \n")
+                    (Info-validate-node-name
+                     (concat "invalid reference "
+                             (buffer-substring (point)
+                                               (save-excursion
+                                                 (skip-chars-forward "^:")
+                                                 (point))))
+                     (Info-extract-menu-node-name "Bad format cross-reference")))))))
+        (setq tags-losing (not (Info-validate-tags-table)))
+        (if (or lossages tags-losing)
+            (with-output-to-temp-buffer " *problems in info file*"
+              (while lossages
+                (princ "In node \"")
+                (princ (car (car lossages)))
+                (princ "\", ")
+                (let ((tem (nth 1 (car lossages))))
+                  (cond ((string-match "\n" tem)
+                         (princ (substring tem 0 (match-beginning 0)))
+                         (princ "..."))
+                        (t
+                         (princ tem))))
+                (if (nth 2 (car lossages))
+                    (progn
+                      (princ ": ")
+                      (let ((tem (nth 2 (car lossages))))
+                        (cond ((string-match "\n" tem)
+                               (princ (substring tem 0 (match-beginning 0)))
+                               (princ "..."))
+                              (t
+                               (princ tem))))))
+                (terpri)
+                (setq lossages (cdr lossages)))
+              (if tags-losing (princ "\nTags table must be recomputed\n")))
+          ;; Here if info file is valid.
+          ;; If we already made a list of problems, clear it out.
+          (save-excursion
+            (if (get-buffer " *problems in info file*")
+                (progn
+                  (set-buffer " *problems in info file*")
+                  (kill-buffer (current-buffer)))))
+          (message "File appears valid"))))))
+
+(defun Info-validate-node-name (kind &optional name)
+  (if name
+      nil
+    (goto-char (match-end 0))
+    (skip-chars-forward " \t")
+    (if (= (following-char) ?\()
+        nil
+      (setq name
+            (buffer-substring
+             (point)
+             (progn
+              (skip-chars-forward "^,\t\n")
+              (skip-chars-backward " ")
+              (point))))))
+  (if (null name)
+      nil
+    (setq name (downcase name))
+    (or (and (> (length name) 0) (= (aref name 0) ?\())
+        (assoc name allnodes)
+        (setq lossages
+              (cons (list thisnode kind name) lossages))))
+  name)
+
+(defun Info-validate-tags-table ()
+  (goto-char (point-min))
+  (if (not (search-forward "\^_\nEnd tag table\n" nil t))
+      t
+    (not (catch 'losing
+           (let* ((end (match-beginning 0))
+                  (start (progn (search-backward "\nTag table:\n")
+                                (1- (match-end 0))))
+                  tem)
+             (setq tem allnodes)
+             (while tem
+               (goto-char start)
+               (or (equal (car (car tem)) "*")
+                   (search-forward (concat "Node: "
+                                           (car (car tem))
+                                           "\177")
+                                   end t)
+                   (throw 'losing 'x))
+               (setq tem (cdr tem)))
+             (goto-char (1+ start))
+             (while (looking-at ".*Node: \\(.*\\)\177\\([0-9]+\\)$")
+               (setq tem (downcase (buffer-substring
+                                     (match-beginning 1)
+                                     (match-end 1))))
+               (setq tem (assoc tem allnodes))
+               (if (or (not tem)
+                       (< 1000 (progn
+                                 (goto-char (match-beginning 2))
+                                 (setq tem (- (car (cdr (cdr tem)))
+                                              (read (current-buffer))))
+                                 (if (> tem 0) tem (- tem)))))
+                   (throw 'losing 'y)))
+             (forward-line 1))
+           (or (looking-at "End tag table\n")
+               (throw 'losing 'z))
+           nil))))
+
+;;;###autoload
+(defun batch-info-validate ()
+  "Runs `Info-validate' on the files remaining on the command line.
+Must be used only with -batch, and kills Emacs on completion.
+Each file will be processed even if an error occurred previously.
+For example, invoke \"emacs -batch -f batch-info-validate $info/ ~/*.info\""
+  (if (not noninteractive)
+      (error "batch-info-validate may only be used -batch."))
+  (let ((version-control t)
+        (auto-save-default nil)
+        (find-file-run-dired nil)
+        (kept-old-versions 259259)
+        (kept-new-versions 259259))
+    (let ((error 0)
+          file
+          (files ()))
+      (while command-line-args-left
+        (setq file (expand-file-name (car command-line-args-left)))
+        (cond ((not (file-exists-p file))
+               (message ">> %s does not exist!" file)
+               (setq error 1
+                     command-line-args-left (cdr command-line-args-left))) 
+              ((file-directory-p file)
+               (setq command-line-args-left (nconc (directory-files file)
+                                              (cdr command-line-args-left))))
+              (t
+               (setq files (cons file files)
+                     command-line-args-left (cdr command-line-args-left)))))
+      (while files
+        (setq file (car files)
+              files (cdr files))
+        (let ((lose nil))
+          (condition-case err
+              (progn
+                (if buffer-file-name (kill-buffer (current-buffer)))
+                (find-file file)
+                (buffer-disable-undo (current-buffer))
+                (set-buffer-modified-p nil)
+                (fundamental-mode)
+                (let ((case-fold-search nil))
+                  (goto-char (point-max))
+                  (cond ((search-backward "\n\^_\^L\nTag table:\n" nil t)
+                         (message "%s already tagified" file))
+                        ((< (point-max) 30000)
+                         (message "%s too small to bother tagifying" file))
+                        (t
+                         (Info-tagify file))))
+                (let ((loss-name " *problems in info file*"))
+                  (message "Checking validity of info file %s..." file)
+                  (if (get-buffer loss-name)
+                      (kill-buffer loss-name))
+                  (Info-validate)
+                  (if (not (get-buffer loss-name))
+                      nil ;(message "Checking validity of info file %s... OK" file)
+                    (message "----------------------------------------------------------------------")
+                    (message ">> PROBLEMS IN INFO FILE %s" file)
+                    (save-excursion
+                      (set-buffer loss-name)
+                      (princ (buffer-substring (point-min) (point-max))))
+                    (message "----------------------------------------------------------------------")
+                    (setq error 1 lose t)))
+                (if (and (buffer-modified-p)
+                         (not lose))
+                    (progn (message "Saving modified %s" file)
+                           (save-buffer))))
+            (error (message ">> Error: %s" (prin1-to-string err))))))
+      (kill-emacs error))))
diff --git a/lisp/progmodes/awk-mode.el b/lisp/progmodes/awk-mode.el
new file mode 100644
index 00000000000..7b70f82b748
--- /dev/null
+++ b/lisp/progmodes/awk-mode.el
@@ -0,0 +1,83 @@
+;; C code editing commands for Emacs
+;; Copyright (C) 1988 Free Software Foundation, Inc.
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 1, or (at your option)
+;; any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs; see the file COPYING.  If not, write to
+;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+
+(defvar awk-mode-syntax-table nil
+  "Syntax table in use in Awk-mode buffers.")
+
+(if awk-mode-syntax-table
+    ()
+  (setq awk-mode-syntax-table (make-syntax-table))
+  (modify-syntax-entry ?\\ "\\" awk-mode-syntax-table)
+  (modify-syntax-entry ?\n ">   " emacs-lisp-mode-syntax-table)
+  (modify-syntax-entry ?\f ">   " emacs-lisp-mode-syntax-table)
+  (modify-syntax-entry ?\# "<   " emacs-lisp-mode-syntax-table)
+  (modify-syntax-entry ?/ "." awk-mode-syntax-table)
+  (modify-syntax-entry ?* "." awk-mode-syntax-table)
+  (modify-syntax-entry ?+ "." awk-mode-syntax-table)
+  (modify-syntax-entry ?- "." awk-mode-syntax-table)
+  (modify-syntax-entry ?= "." awk-mode-syntax-table)
+  (modify-syntax-entry ?% "." awk-mode-syntax-table)
+  (modify-syntax-entry ?< "." awk-mode-syntax-table)
+  (modify-syntax-entry ?> "." awk-mode-syntax-table)
+  (modify-syntax-entry ?& "." awk-mode-syntax-table)
+  (modify-syntax-entry ?| "." awk-mode-syntax-table)
+  (modify-syntax-entry ?\' "\"" awk-mode-syntax-table))
+
+(defvar awk-mode-abbrev-table nil
+  "Abbrev table in use in Awk-mode buffers.")
+(define-abbrev-table 'awk-mode-abbrev-table ())
+
+;;;###autoload
+(defun awk-mode ()
+  "Major mode for editing AWK code.
+This is much like C mode except for the syntax of comments.  It uses
+the same keymap as C mode and has the same variables for customizing
+indentation.  It has its own abbrev table and its own syntax table.
+
+Turning on AWK mode calls the value of the variable `awk-mode-hook'
+with no args, if that value is non-nil."
+  (interactive)
+  (kill-all-local-variables)
+  (use-local-map c-mode-map)
+  (setq major-mode 'awk-mode)
+  (setq mode-name "AWK")
+  (setq local-abbrev-table awk-mode-abbrev-table)
+  (set-syntax-table awk-mode-syntax-table)
+  (make-local-variable 'paragraph-start)
+  (setq paragraph-start (concat "^$\\|" page-delimiter))
+  (make-local-variable 'paragraph-separate)
+  (setq paragraph-separate paragraph-start)
+  (make-local-variable 'paragraph-ignore-fill-prefix)
+  (setq paragraph-ignore-fill-prefix t)
+  (make-local-variable 'indent-line-function)
+  (setq indent-line-function 'awk-indent-line)
+  (make-local-variable 'require-final-newline)
+  (setq require-final-newline t)
+  (make-local-variable 'comment-start)
+  (setq comment-start "# ")
+  (make-local-variable 'comment-end)
+  (setq comment-end "")
+  (make-local-variable 'comment-column)
+  (setq comment-column 32)
+  (make-local-variable 'comment-start-skip)
+  (setq comment-start-skip "#+ *")
+  (make-local-variable 'comment-indent-hook)
+  (setq comment-indent-hook 'c-comment-indent)
+  (run-hooks 'awk-mode-hook))
diff --git a/lisp/progmodes/cplus-md.el b/lisp/progmodes/cplus-md.el
new file mode 100644
index 00000000000..f5082895e1e
--- /dev/null
+++ b/lisp/progmodes/cplus-md.el
@@ -0,0 +1,966 @@
+;; C++ code editing commands for Emacs
+;; 1987 Dave Detlefs  (dld@cs.cmu.edu) 
+;; and  Stewart Clamen (clamen@cs.cmu.edu).
+;; Done by fairly faithful modification of:
+;; c-mode.el, Copyright (C) 1985 Richard M. Stallman.
+;;
+;; Feb, 1990 (Dave Detlefs, dld@cs.cmu.edu)
+;;   Fixed electric-c++-terminator to handle double colons, at the
+;;   request of John Hagerman.
+;; 
+;; Jan, 1990 (Doug Lea, dl@oswego.edu)
+;;   Replaced c++-comment-region and c++-uncomment-region with
+;;     versions from Igor Metz that avoid potential infinite loops.
+;;
+;; Oct, 1989 (Dave Detlefs, dld@cs.cmu.edu)
+;;   Added contribution from Igor Metz <metz@iam.unibe.ch>:
+;;     functions c++-comment-region and c++-uncomment-region and 
+;;     corresponding key-binding.
+;;   Also fixed bug in indentation of second line after an empty
+;;   arglist with empty-arglist non-null.
+;;   
+;; Sept, 1989 (Glen Ditchfield, gjditchfield@violet.uwaterloo.ca):
+;;   Textual changes to more closely imitate Emacs 18.55's c-mode.
+;;   Fixed handling of "default:", where ":" was the last character in the
+;;   buffer.  Fixed indentation of comments starting in column 0, and when
+;;   previous line contained more than one comment start string.  Fixed
+;;   handling of "friend class".
+;;
+;; Aug 7, 1989; John Hagerman (hagerman@ece.cmu.edu):
+;;   Changed calculate-c++-indent to handle member initializations
+;;   more flexibly. Two new variables are used to control behavior:
+;;   c++-member-init-indent and c++-continued-member-init-offset.
+;;   Note the assumption that member initializations and argument
+;;   declarations are not mixed in one function definition.
+;;
+;; June 1989 (Dave Detlefs, dld@cs.cmu.edu)
+;;   Fixed calculate-c++-indent to handle continued lines ending in
+;;   {'s.  (I wasn't following C-mode closely enough, or C-mode
+;;   changed.)  Made ' a quote character, at the behest of someone
+;;   whose mail I apparently deleted (if they send me mail I'll credit
+;;   them here in a future revision.)
+;;   Dan Weinreb (dlw@odi.com) pointed out that 'c++-mode successively
+;;   bound c++-indent-exp and c++-indent-defun to ESC-^q.  ESC-^q is
+;;   now bound to c++-indent-exp, while, c++-indent-defun is invoked
+;;   with ESC-^x.
+
+;; February 1989 (Dave Detlefs, dld@cs.cmu.edu)
+;;   Fixed some errors in c++-indent-defun, as pointed out by Sam
+;;   Haradhvala (odi!sam@talcott.harvard.edu).
+;; October 1988 (Dave Detlefs, dld@cs.cmu.edu)
+;;   It turns out I had only *thought* I had made
+;;   beginning(end)-of-defun work.  It should work better now -- you
+;;   can either attempt to match defun headers "strongly," using a
+;;   very complicated regexp, or "weakly," using a simple one.  This
+;;   is settable by a variable; the default is the cheaper weak
+;;   method.  (Stewart Clamen was intimately involved in this, too.)
+;;
+;;   I made "'" *not* be a string delimiter, because that was causing
+;;   comments containing contractions to ("// don't") to mess up paren
+;;   balancing.
+;;
+;;   I also incorporated another slight indentation fix from Glen
+;;   Ditchfield.
+;;
+;;   We hope this is will make into version 19 of gnu-emacs.
+;;
+;; September 1988: incorporated changes from Fred Calm at Schlumberger.
+;;   Also, made beginning(end)-of-defun, indent-defun work.
+;;
+;; August 1987: incorporated changes done by Glen Ditchfield of Waterloo.
+
+(defvar c++-mode-abbrev-table nil
+  "Abbrev table used in C++ mode.")
+(define-abbrev-table 'c++-mode-abbrev-table ())
+
+(defvar c++-mode-map ()
+  "Keymap used in C++ mode.")
+(if c++-mode-map
+    ()
+  (setq c++-mode-map (make-sparse-keymap))
+  (define-key c++-mode-map "\C-j" 'reindent-then-newline-and-indent)
+  (define-key c++-mode-map "{" 'electric-c++-brace)
+  (define-key c++-mode-map "}" 'electric-c++-brace)
+  (define-key c++-mode-map ";" 'electric-c++-semi)
+  (define-key c++-mode-map "\e\C-h" 'mark-c-function)
+  (define-key c++-mode-map "\e\C-q" 'indent-c++-exp)
+  (define-key c++-mode-map "\177" 'backward-delete-char-untabify)
+  (define-key c++-mode-map "\t" 'c++-indent-command)
+  (define-key c++-mode-map "\C-c\C-i" 'c++-insert-header)
+  (define-key c++-mode-map "\C-c\C-\\" 'c++-macroize-region)
+  (define-key c++-mode-map "\C-c\C-c" 'c++-comment-region)
+  (define-key c++-mode-map "\C-c\C-u" 'c++-uncomment-region)
+  (define-key c++-mode-map "\e\C-a" 'c++-beginning-of-defun)
+  (define-key c++-mode-map "\e\C-e" 'c++-end-of-defun)
+  (define-key c++-mode-map "\e\C-x" 'c++-indent-defun))
+
+(defvar c++-mode-syntax-table nil
+  "Syntax table used in C++ mode.")
+
+(if c++-mode-syntax-table
+    ()
+  (setq c++-mode-syntax-table (copy-syntax-table c-mode-syntax-table))
+  (modify-syntax-entry ?/ ". 12" c++-mode-syntax-table)
+  (modify-syntax-entry ?\n ">" c++-mode-syntax-table)
+  (modify-syntax-entry ?\' "." c++-mode-syntax-table))
+
+(defvar c++-continued-member-init-offset nil
+  "*Extra indent for continuation lines of member inits;
+NIL means to align with previous initializations rather than
+with the colon on the first line.")
+(defvar c++-member-init-indent 0
+  "*Indentation level of member initializations in function declarations.")
+(defvar c++-friend-offset -4
+  "*Offset of C++ friend class declarations relative to member declarations.")
+(defvar c++-electric-colon t
+  "*If t, colon is an electric terminator.")
+(defvar c++-empty-arglist-indent nil
+  "*Indicates how far to indent an line following an empty argument
+list.  Nil indicates to just after the paren.")
+
+
+;;;###autoload
+(defun c++-mode ()
+  "Major mode for editing C++ code.  Very much like editing C code.
+Expression and list commands understand all C++ brackets.
+Tab at left margin indents for C++ code
+Comments are delimited with /* ... */ {or with // ... <newline>}
+Paragraphs are separated by blank lines only.
+Delete converts tabs to spaces as it moves back.
+\\{c++-mode-map}
+Variables controlling indentation style:
+ c-tab-always-indent
+    Non-nil means TAB in C mode should always reindent the current line,
+    regardless of where in the line point is when the TAB command is used.
+    Default is t.
+ c-auto-newline
+    Non-nil means automatically newline before and after braces,
+    and after colons and semicolons, inserted in C code.
+ c-indent-level
+    Indentation of C statements within surrounding block.
+    The surrounding block's indentation is the indentation
+    of the line on which the open-brace appears.
+ c-continued-statement-offset
+    Extra indentation given to a substatement, such as the
+    then-clause of an if or body of a while.
+ c-continued-brace-offset
+    Extra indentation given to a brace that starts a substatement.
+    This is in addition to c-continued-statement-offset.
+ c-brace-offset
+    Extra indentation for line if it starts with an open brace.
+ c-brace-imaginary-offset
+    An open brace following other text is treated as if it were
+    this far to the right of the start of its line.
+ c-argdecl-indent
+    Indentation level of declarations of C function arguments.
+ c-label-offset
+    Extra indentation for line that is a label, or case or ``default:'', or
+    ``public:'' or ``private:'', or ``protected:''.
+ c++-electric-colon
+    If non-nil at invocation of c++-mode (t is the default) colon electricly
+    indents.
+ c++-empty-arglist-indent
+    If non-nil, a function declaration or invocation which ends a line with a
+    left paren is indented this many extra spaces, instead of flush with the
+    left paren.
+ c++-friend-offset
+    Offset of C++ friend class declarations relative to member declarations.
+ c++-member-init-indent
+    Indentation level of member initializations in function declarations,
+    if they are on a separate line beginning with a colon.
+ c++-continued-member-init-offset
+    Extra indentation for continuation lines of member initializations; NIL
+    means to align with previous initializations rather than with the colon.
+
+Settings for K&R, BSD, and Stroustrup indentation styles are
+  c-indent-level                5    8    4
+  c-continued-statement-offset  5    8    4
+  c-continued-brace-offset                0
+  c-brace-offset               -5   -8    0
+  c-brace-imaginary-offset                0
+  c-argdecl-indent              0    8    4
+  c-label-offset               -5   -8   -4
+  c++-empty-arglist-indent                4
+  c++-friend-offset                       0
+
+Turning on C++ mode calls the value of the variable `c++-mode-hook' with
+no args if that value is non-nil."
+  (interactive)
+  (kill-all-local-variables)
+  (use-local-map c++-mode-map)
+  (set-syntax-table c++-mode-syntax-table)
+  (setq major-mode 'c++-mode
+        mode-name "C++"
+        comment-column 32
+        local-abbrev-table c++-mode-abbrev-table)
+  (set (make-local-variable 'indent-line-function) 'c++-indent-line)
+  (set (make-local-variable 'comment-start) "// ")
+  (set (make-local-variable 'comment-end) "")
+  (set (make-local-variable 'comment-start-skip) "/\\*+ *\\|// *")
+  (set (make-local-variable 'comment-indent-hook) 'c++-comment-indent)
+  (set (make-local-variable 'paragraph-start) (concat "^$\\|" page-delimiter))
+  (set (make-local-variable 'paragraph-separate) paragraph-start)
+  (set (make-local-variable 'paragraph-ignore-fill-prefix) t)
+  (set (make-local-variable 'require-final-newline) t)
+  (set (make-local-variable 'parse-sexp-ignore-comments) nil)
+  (run-hooks 'c++-mode-hook)
+  (if c++-electric-colon
+      (define-key c++-mode-map ":" 'electric-c++-terminator)))
+
+;; This is used by indent-for-comment
+;; to decide how much to indent a comment in C++ code
+;; based on its context.
+(defun c++-comment-indent ()
+  (if (looking-at "^\\(/\\*\\|//\\)")
+      0                                 ; Existing comment at bol stays there.
+    (save-excursion
+      (skip-chars-backward " \t")
+      (max
+       ;; leave at least one space on non-empty lines.
+       (if (zerop (current-column)) 0 (1+ (current-column)))
+       (let ((cur-pt (point)))
+         (beginning-of-line 0)
+         ;; If previous line had a comment, use it's indent
+         (if (re-search-forward comment-start-skip cur-pt t)
+             (progn
+               (goto-char (match-beginning 0))
+               (current-column))
+           comment-column))))))         ; otherwise indent at comment column.
+
+(defun electric-c++-brace (arg)
+  "Insert character and correct line's indentation."
+  (interactive "P")
+  (let (insertpos)
+    (if (and (not arg)
+             (eolp)
+             (or (save-excursion
+                   (skip-chars-backward " \t")
+                   (bolp))
+                 (if c-auto-newline (progn (c++-indent-line) (newline) t))))
+        (progn
+          (insert last-command-char)
+          (c++-indent-line)
+          (if c-auto-newline
+              (progn
+                (newline)
+                ;; (newline) may have done auto-fill
+                (setq insertpos (- (point) 2))
+                (c++-indent-line)))
+          (save-excursion
+            (if insertpos (goto-char (1+ insertpos)))
+            (delete-char -1))))
+    (if insertpos
+        (save-excursion
+          (goto-char insertpos)
+          (self-insert-command (prefix-numeric-value arg)))
+      (self-insert-command (prefix-numeric-value arg)))))
+
+(defun electric-c++-semi (arg)
+  "Insert character and correct line's indentation."
+  (interactive "P")
+  (if c-auto-newline
+      (electric-c++-terminator arg)
+    (self-insert-command (prefix-numeric-value arg))))
+
+(defun electric-c++-terminator (arg)
+  "Insert character and correct line's indentation."
+  (interactive "P")
+  (let (insertpos (end (point)))
+    (if (and (not arg) (eolp)
+             (not (save-excursion
+                    (beginning-of-line)
+                    (skip-chars-forward " \t")
+                    (or (= (following-char) ?#)
+                        ;; Colon is special only after a label, or
+                        ;; case, or another colon.
+                        ;; So quickly rule out most other uses of colon
+                        ;; and do no indentation for them.
+                        (and (eq last-command-char ?:)
+                             (not (looking-at "case[ \t]"))
+                             (save-excursion
+                               (forward-word 1)
+                               (skip-chars-forward " \t")
+                               (< (point) end))
+                             ;; Do re-indent double colons
+                             (save-excursion
+                               (end-of-line 1)
+                               (looking-at ":")))
+                        (progn
+                          (beginning-of-defun)
+                          (let ((pps (parse-partial-sexp (point) end)))
+                            (or (nth 3 pps) (nth 4 pps) (nth 5 pps))))))))
+        (progn
+          (insert last-command-char)
+          (c++-indent-line)
+          (and c-auto-newline
+               (not (c-inside-parens-p))
+               (progn
+                 ;; the new marker object, used to be just an integer
+                 (setq insertpos (make-marker))
+                 ;; changed setq to set-marker
+                 (set-marker insertpos (1- (point)))
+                 ;; do this before the newline, since in auto fill can break
+                 (newline)
+                 (c-indent-line)))
+          (save-excursion
+            (if insertpos (goto-char (1+ insertpos)))
+            (delete-char -1))))
+    (if insertpos
+        (save-excursion
+          (goto-char insertpos)
+          (self-insert-command (prefix-numeric-value arg)))
+      (self-insert-command (prefix-numeric-value arg)))))
+
+(defun c++-indent-command (&optional whole-exp)
+  "Indent current line as C++ code, or in some cases insert a tab character.
+If `c-tab-always-indent' is non-nil (the default), always indent current
+line.  Otherwise, indent the current line only if point is at the left
+margin or in the line's indentation; otherwise insert a tab.
+
+A numeric argument, regardless of its value, means indent rigidly all means
+indent rigidly all the lines of the expression starting after point so that
+this line becomes properly indented.  The relative indentation among the
+lines of the expression are preserved."
+  (interactive "P")
+  (if whole-exp
+      ;; If arg, always indent this line as C
+      ;; and shift remaining lines of expression the same amount.
+      (let ((shift-amt (c++-indent-line))
+            beg end)
+        (save-excursion
+          (if c-tab-always-indent
+              (beginning-of-line))
+          (setq beg (point))
+          (forward-sexp 1)
+          (setq end (point))
+          (goto-char beg)
+          (forward-line 1)
+          (setq beg (point)))
+        (if (> end beg)
+            (indent-code-rigidly beg end shift-amt "#")))
+    (if (and (not c-tab-always-indent)
+             (save-excursion
+               (skip-chars-backward " \t")
+               (not (bolp))))
+        (insert-tab)
+      (c++-indent-line))))
+
+(defun c++-indent-line ()
+  "Indent current line as C++ code.
+Return the amount the indentation changed by."
+  (let ((indent (calculate-c++-indent nil))
+        beg shift-amt
+        (case-fold-search nil)
+        (pos (- (point-max) (point))))
+    (beginning-of-line)
+    (setq beg (point))
+    (cond ((eq indent nil)
+           (setq indent (current-indentation)))
+          ((eq indent t)
+           (setq indent (calculate-c-indent-within-comment)))
+          ((looking-at "[ \t]*#")
+           (setq indent 0))
+          (t
+           (skip-chars-forward " \t")
+           (if (listp indent) (setq indent (car indent)))
+           (cond ((looking-at "\\(default\\|public\\|private\\|protected\\):")
+                  (setq indent (+ indent c-label-offset)))
+                 ((or (looking-at "case\\b")
+                      (and (looking-at "[A-Za-z]")
+                           (save-excursion
+                             (forward-sexp 1)
+                             (looking-at ":[^:]"))))
+                  (setq indent (max 1 (+ indent c-label-offset))))
+                 ((and (looking-at "else\\b")
+                       (not (looking-at "else\\s_")))
+                  (setq indent (save-excursion
+                                 (c-backward-to-start-of-if)
+                                 (current-indentation))))
+                 ((looking-at "friend\[ \t]class[ \t]")
+                  (setq indent (+ indent c++-friend-offset)))
+                 ((= (following-char) ?})
+                  (setq indent (- indent c-indent-level)))
+                 ((= (following-char) ?{)
+                  (setq indent (+ indent c-brace-offset))))))
+    (skip-chars-forward " \t")
+    (setq shift-amt (- indent (current-column)))
+    (if (zerop shift-amt)
+        (if (> (- (point-max) pos) (point))
+            (goto-char (- (point-max) pos)))
+      (delete-region beg (point))
+      (indent-to indent)
+      ;; If initial point was within line's indentation,
+      ;; position after the indentation.  Else stay at same point in text.
+      (if (> (- (point-max) pos) (point))
+          (goto-char (- (point-max) pos))))
+    shift-amt))
+
+(defun calculate-c++-indent (&optional parse-start)
+  "Return appropriate indentation for current line as C++ code.
+In usual case returns an integer: the column to indent to.
+Returns nil if line starts inside a string, t if in a comment."
+  (save-excursion
+    (beginning-of-line)
+    (let ((indent-point (point))
+          (case-fold-search nil)
+          state
+          containing-sexp)
+      (if parse-start
+          (goto-char parse-start)
+        (beginning-of-defun))
+      (while (< (point) indent-point)
+        (setq parse-start (point))
+        (setq state (parse-partial-sexp (point) indent-point 0))
+        (setq containing-sexp (car (cdr state))))
+      (cond ((or (nth 3 state) (nth 4 state))
+             ;; return nil or t if should not change this line
+             (nth 4 state))
+            ((null containing-sexp)
+             ;; Line is at top level.  May be data or function definition, or
+             ;; may be function argument declaration or member initialization.
+             ;; Indent like the previous top level line unless
+             ;; (1) the previous line ends in a closeparen without semicolon,
+             ;; in which case this line is the first argument declaration or
+             ;; member initialization, or
+             ;; (2) the previous line begins with a colon,
+             ;; in which case this is the second line of member inits.
+             ;; It is assumed that arg decls and member inits are not mixed.
+             (goto-char indent-point)
+             (skip-chars-forward " \t")
+             (if (= (following-char) ?{)
+                 0   ; Unless it starts a function body
+               (c++-backward-to-noncomment (or parse-start (point-min)))
+               (if (= (preceding-char) ?\))
+                   (progn               ; first arg decl or member init
+                     (goto-char indent-point)
+                     (skip-chars-forward " \t")
+                     (if (= (following-char) ?:)
+                         c++-member-init-indent
+                       c-argdecl-indent))
+                 (if (= (preceding-char) ?\;)
+                     (backward-char 1))
+                 (if (= (preceding-char) ?})
+                     0
+                   (beginning-of-line)  ; continued arg decls or member inits
+                   (skip-chars-forward " \t")
+                   (if (= (following-char) ?:)
+                       (if c++-continued-member-init-offset
+                           (+ (current-indentation)
+                              c++-continued-member-init-offset)
+                         (progn
+                           (forward-char 1)
+                           (skip-chars-forward " \t")
+                           (current-column)))
+                     (current-indentation)))
+                 )))
+            ((/= (char-after containing-sexp) ?{)
+             ;; line is expression, not statement:
+             ;; indent to just after the surrounding open -- unless
+             ;; empty arg list, in which case we do what
+             ;; c++-empty-arglist-indent says to do.
+             (if (and c++-empty-arglist-indent
+                      (or (null (nth 2 state))  ;; indicates empty arg
+                                                ;; list.
+                          ;; Use a heuristic: if the first
+                          ;; non-whitespace following left paren on
+                          ;; same line is not a comment,
+                          ;; is not an empty arglist.
+                          (save-excursion
+                            (goto-char (1+ containing-sexp))
+                            (not
+                             (looking-at "\\( \\|\t\\)*[^/\n]")))))
+                 (progn
+                   (goto-char containing-sexp)
+                   (beginning-of-line)
+                   (skip-chars-forward " \t")
+                   (goto-char (min (+ (point) c++-empty-arglist-indent)
+                                   (1+ containing-sexp)))
+                   (current-column))
+               ;; In C-mode, we would always indent to one after the
+               ;; left paren.  Here, though, we may have an
+               ;; empty-arglist, so we'll indent to the min of that
+               ;; and the beginning of the first argument.
+               (goto-char (1+ containing-sexp))
+               (current-column)))
+            (t
+             ;; Statement.  Find previous non-comment character.
+             (goto-char indent-point)
+             (c++-backward-to-noncomment containing-sexp)
+             (if (not (memq (preceding-char) '(nil ?\, ?\; ?} ?: ?\{)))
+                 ;; This line is continuation of preceding line's statement;
+                 ;; indent  c-continued-statement-offset  more than the
+                 ;; previous line of the statement.
+                 (progn
+                   (c-backward-to-start-of-continued-exp containing-sexp)
+                   (+ c-continued-statement-offset (current-column)))
+               ;; This line starts a new statement.
+               ;; Position following last unclosed open.
+               (goto-char containing-sexp)
+               ;; Is line first statement after an open-brace?
+               (or
+                 ;; If no, find that first statement and indent like it.
+                 (save-excursion
+                   (forward-char 1)
+                   (while (progn (skip-chars-forward " \t\n")
+                                 (looking-at
+                                  (concat
+                                   "#\\|/\\*\\|//"
+                                   "\\|case[ \t]"
+                                   "\\|[a-zA-Z0-9_$]*:[^:]"
+                                   "\\|friend[ \t]class[ \t]")))
+                     ;; Skip over comments and labels following openbrace.
+                     (cond ((= (following-char) ?\#)
+                            (forward-line 1))
+                           ((looking-at "/\\*")
+                            (search-forward "*/" nil 'move))
+                           ((looking-at "//\\|friend[ \t]class[ \t]")
+                            (forward-line 1))
+                           (t
+                            (re-search-forward ":[^:]" nil 'move))))
+                      ;; The first following code counts
+                      ;; if it is before the line we want to indent.
+                      (and (< (point) indent-point)
+                           (current-column)))
+                 ;; If no previous statement,
+                 ;; indent it relative to line brace is on.
+                 ;; For open brace in column zero, don't let statement
+                 ;; start there too.  If c-indent-offset is zero,
+                 ;; use c-brace-offset + c-continued-statement-offset instead.
+                 ;; For open-braces not the first thing in a line,
+                 ;; add in c-brace-imaginary-offset.
+                 (+ (if (and (bolp) (zerop c-indent-level))
+                        (+ c-brace-offset c-continued-statement-offset)
+                      c-indent-level)
+                    ;; Move back over whitespace before the openbrace.
+                    ;; If openbrace is not first nonwhite thing on the line,
+                    ;; add the c-brace-imaginary-offset.
+                    (progn (skip-chars-backward " \t")
+                           (if (bolp) 0 c-brace-imaginary-offset))
+                    ;; If the openbrace is preceded by a parenthesized exp,
+                    ;; move to the beginning of that;
+                    ;; possibly a different line
+                    (progn
+                      (if (eq (preceding-char) ?\))
+                          (forward-sexp -1))
+                      ;; Get initial indentation of the line we are on.
+                      (current-indentation))))))))))
+
+(defun c++-backward-to-noncomment (lim)
+  (let (opoint stop)
+    (while (not stop)
+      (skip-chars-backward " \t\n\r\f" lim)
+      (setq opoint (point))
+      (cond ((and (>= (point) (+ 2 lim))
+                  (save-excursion
+                    (forward-char -2)
+                    (looking-at "\\*/")))
+             (search-backward "/*" lim 'move))
+            ((and
+              (search-backward "//" (max (point-bol) lim) 'move)
+              (not (within-string-p (point) opoint))))
+          (t (beginning-of-line)
+             (skip-chars-forward " \t")
+             (if (looking-at "#")
+                 (setq stop (<= (point) lim))
+               (setq stop t)
+               (goto-char opoint)))))))
+
+(defun indent-c++-exp ()
+  "Indent each line of the C++ grouping following point."
+  (interactive)
+  (let ((indent-stack (list nil))
+        (contain-stack (list (point)))
+        (case-fold-search nil)
+        restart outer-loop-done inner-loop-done state ostate
+        this-indent last-sexp
+        at-else at-brace
+        (opoint (point))
+        (next-depth 0))
+    (save-excursion
+      (forward-sexp 1))
+    (save-excursion
+      (setq outer-loop-done nil)
+      (while (and (not (eobp)) (not outer-loop-done))
+        (setq last-depth next-depth)
+        ;; Compute how depth changes over this line
+        ;; plus enough other lines to get to one that
+        ;; does not end inside a comment or string.
+        ;; Meanwhile, do appropriate indentation on comment lines.
+        (setq innerloop-done nil)
+        (while (and (not innerloop-done)
+                    (not (and (eobp) (setq outer-loop-done t))))
+          (setq ostate state)
+          (setq state (parse-partial-sexp (point) (progn (end-of-line) (point))
+                                          nil nil state))
+          (setq next-depth (car state))
+          (if (and (car (cdr (cdr state)))
+                   (>= (car (cdr (cdr state))) 0))
+              (setq last-sexp (car (cdr (cdr state)))))
+          (if (or (nth 4 ostate))
+              (c++-indent-line))
+          (if (or (nth 3 state))
+              (forward-line 1)
+            (setq innerloop-done t)))
+        (if (<= next-depth 0)
+            (setq outer-loop-done t))
+        (if outer-loop-done
+            nil
+          ;; If this line had ..))) (((.. in it, pop out of the levels
+          ;; that ended anywhere in this line, even if the final depth
+          ;; doesn't indicate that they ended.
+          (while (> last-depth (nth 6 state))
+            (setq indent-stack (cdr indent-stack)
+                  contain-stack (cdr contain-stack)
+                  last-depth (1- last-depth)))
+          (if (/= last-depth next-depth)
+              (setq last-sexp nil))
+          ;; Add levels for any parens that were started in this line.
+          (while (< last-depth next-depth)
+            (setq indent-stack (cons nil indent-stack)
+                  contain-stack (cons nil contain-stack)
+                  last-depth (1+ last-depth)))
+          (if (null (car contain-stack))
+              (setcar contain-stack (or (car (cdr state))
+                                        (save-excursion (forward-sexp -1)
+                                                        (point)))))
+          (forward-line 1)
+          (skip-chars-forward " \t")
+          (if (eolp)
+              nil
+            (if (and (car indent-stack)
+                     (>= (car indent-stack) 0))
+                ;; Line is on an existing nesting level.
+                ;; Lines inside parens are handled specially.
+                (if (/= (char-after (car contain-stack)) ?{)
+                    (setq this-indent (car indent-stack))
+                  ;; Line is at statement level.
+                  ;; Is it a new statement?  Is it an else?
+                  ;; Find last non-comment character before this line
+                  (save-excursion
+                    (setq at-else (looking-at "else\\W"))
+                    (setq at-brace (= (following-char) ?{))
+                    (c++-backward-to-noncomment opoint)
+                    (if (not (memq (preceding-char) '(nil ?\, ?\; ?} ?: ?{)))
+                        ;; Preceding line did not end in comma or semi;
+                        ;; indent this line  c-continued-statement-offset
+                        ;; more than previous.
+                        (progn
+                          (c-backward-to-start-of-continued-exp
+                           (car contain-stack))
+                          (setq this-indent
+                                (+ c-continued-statement-offset
+                                   (current-column)
+                                   (if at-brace c-continued-brace-offset 0))))
+                      ;; Preceding line ended in comma or semi;
+                      ;; use the standard indent for this level.
+                      (if at-else
+                          (progn (c-backward-to-start-of-if opoint)
+                                 (setq this-indent (current-indentation)))
+                        (setq this-indent (car indent-stack))))))
+              ;; Just started a new nesting level.
+              ;; Compute the standard indent for this level.
+              (let ((val (calculate-c++-indent
+                          (if (car indent-stack)
+                              (- (car indent-stack))))))
+                (setcar indent-stack
+                        (setq this-indent val))))
+            ;; Adjust line indentation according to its contents
+            (if (looking-at "\\(public\\|private\\|protected\\):")
+                (setq this-indent (- this-indent c-indent-level)))
+            (if (or (looking-at "case[ \t]")
+                    (and (looking-at "[A-Za-z]")
+                         (save-excursion
+                           (forward-sexp 1)
+                           (looking-at ":[^:]"))))
+                (setq this-indent (max 1 (+ this-indent c-label-offset))))
+            (if (looking-at "friend[ \t]class[ \t]")
+                (setq this-indent (+ this-indent c++-friend-offset)))
+            (if (= (following-char) ?})
+                (setq this-indent (- this-indent c-indent-level)))
+            (if (= (following-char) ?{)
+                (setq this-indent (+ this-indent c-brace-offset)))
+            ;; Put chosen indentation into effect.
+            (or (= (current-column) this-indent)
+                (= (following-char) ?\#)
+                (progn
+                  (delete-region (point) (progn (beginning-of-line) (point)))
+                  (indent-to this-indent)))
+            ;; Indent any comment following the text.
+            (or (looking-at comment-start-skip)
+                (if (re-search-forward comment-start-skip
+                                       (save-excursion (end-of-line)
+                                                       (point)) t)
+                    (progn
+                      (indent-for-comment)
+                      (beginning-of-line))))))))))
+
+(defun fill-C-comment ()
+  (interactive)
+  (save-excursion
+    (let ((save fill-prefix))
+      (beginning-of-line 1)
+      (save-excursion
+        (re-search-forward comment-start-skip
+                           (save-excursion (end-of-line) (point))
+                           t)
+        (goto-char (match-end 0))
+        (set-fill-prefix))
+      (while (looking-at fill-prefix)
+        (previous-line 1))
+      (next-line 1)
+      (insert-string "\n")
+      (fill-paragraph nil)
+      (delete-char -1)
+      (setq fill-prefix save))))
+
+(defun point-bol ()
+  "Returns the value of the point at the beginning of the current line."
+  (save-excursion
+    (beginning-of-line)
+    (point)))
+
+(defun c++-insert-header ()
+  "Insert header denoting C++ code at top of buffer."
+  (interactive)
+  (save-excursion
+    (goto-char (point-min))
+    (insert "// "
+            "This may look like C code, but it is really "
+            "-*- C++ -*-"
+            "\n\n")))
+
+(defun within-string-p (point1 point2)
+  "Returns true if number of double quotes between two points is odd."
+  (let ((s (buffer-substring point1 point2)))
+    (not (zerop (mod (count-char-in-string ?\" s) 2)))))
+
+(defun count-char-in-string (c s)
+  (let ((count 0)
+        (pos 0))
+    (while (< pos (length s))
+      (setq count (+ count (if (\= (aref s pos) c) 1 0)))
+      (setq pos (1+ pos)))
+    count))
+
+;;; This page covers "macroization;" making C++ parameterized types
+;;; via macros.
+
+(defvar c++-default-macroize-column 78
+  "Place to insert backslashes.")
+
+(defun c++-macroize-region (from to arg)
+  "Insert backslashes at end of every line in region.  Useful for defining cpp
+macros.  If called with negative argument, will remove trailing backslashes,
+so that indentation will work right."
+  (interactive "r\np")
+  (save-excursion
+    (goto-char from)
+    (beginning-of-line 1)
+    (let ((line (count-lines (point-min) (point)))
+          (to-line (save-excursion (goto-char to)
+                                   (count-lines (point-min) (point)))))
+      (while (< line to-line)
+        (backslashify-current-line (> arg 0))
+        (next-line 1) (setq line (1+ line))))))
+
+(defun backslashify-current-line (doit)
+  (end-of-line 1)
+  (cond
+   (doit
+    ;; Note that "\\\\" is needed to get one backslash.
+    (if (not (save-excursion (forward-char -1) (looking-at "\\\\")))
+        (progn
+          (if (>= (current-column) c++-default-macroize-column)
+              (insert " \\")
+            (while (<= (current-column) c++-default-macroize-column)
+              (insert "\t") (end-of-line))
+            (delete-char -1)
+            (while (< (current-column) c++-default-macroize-column)
+              (insert " ") (end-of-line))
+            (insert "\\")))))
+   (t
+    (forward-char -1)
+    (if (looking-at "\\\\")
+        (progn (skip-chars-backward " \t")
+               (kill-line))))))
+
+
+;;; This page covers commenting out multiple lines.
+
+(defun c++-comment-region ()
+  "Comment out all lines in a region between mark and current point.
+Inserts \"// \" (`comment-start') in front of each line."
+  (interactive)
+  (let* ((m      (if (eq (mark) nil) (error "Mark is not set!") (mark)))
+         (start  (if (< (point) m) (point) m))
+         (end    (if (> (point) m) (point) m))
+         (mymark (copy-marker end)))
+    (save-excursion
+        (goto-char start)
+        (while (< (point) (marker-position mymark))
+            (beginning-of-line)
+            (insert comment-start)
+            (beginning-of-line)
+            (next-line 1)))))
+
+(defun c++-uncomment-region ()
+  "Uncomment all lines in region between mark and current point.
+Deletes the leading \"// \" (`comment-start') from each line, if any."
+  (interactive)
+  (let* ((m      (if (eq (mark) nil) (error "Mark is not set!") (mark)))
+         (start  (if (< (point) m) (point) m))
+         (end    (if (> (point) m) (point) m))
+         (mymark (copy-marker end))
+         (len    (length comment-start))
+         (char   (string-to-char comment-start)))
+    (save-excursion
+        (goto-char start)
+        (while (< (point) (marker-position mymark))
+            (beginning-of-line)
+            (if (looking-at (concat " *" comment-start))
+                (progn
+                  (zap-to-char 1 char)
+                  (delete-char len)))
+            (beginning-of-line)
+            (next-line 1)))))
+
+;;; Below are two regular expressions that attempt to match defuns
+;;; "strongly" and "weakly."  The strong one almost reconstructs the
+;;; grammar of C++; the weak one just figures anything id or curly on
+;;; the left begins a defun.  The constant "c++-match-header-strongly"
+;;; determines which to use; the default is the weak one.
+
+(defvar c++-match-header-strongly nil
+  "*If nil, use `c++-defun-header-weak' to identify beginning of definitions.
+If non-nil, use `c++-defun-header-strong'.")
+
+(defvar c++-defun-header-strong-struct-equivs "\\(class\\|struct\\|enum\\)"
+  "Regexp to match names of structure declaration blocks in C++.")
+
+(defconst c++-defun-header-strong
+  (let*
+      (; valid identifiers
+       ;; There's a real wierdness here -- if I switch the below
+       (id "\\(\\w\\|_\\)+")
+       ;; to be
+       ;; (id "\\(_\\|\\w\\)+")
+       ;; things no longer work right.  Try it and see!
+
+       ; overloadable operators
+       (op-sym1
+         "[---+*/%^&|~!=<>]\\|[---+*/%^&|<>=!]=\\|<<=?\\|>>=?")
+       (op-sym2
+         "&&\\|||\\|\\+\\+\\|--\\|()\\|\\[\\]")  
+       (op-sym (concat "\\(" op-sym1 "\\|" op-sym2 "\\)"))
+       ; whitespace
+       (middle "[^\\*]*\\(\\*+[^/\\*][^\\*]*\\)*")
+       (c-comment (concat "/\\*" middle "\\*+/"))
+       (wh (concat "\\(\\s \\|\n\\|//.*$\\|" c-comment "\\)"))
+       (wh-opt (concat wh "*"))
+       (wh-nec (concat wh "+"))
+       (oper (concat "\\(" "operator" "\\("
+                     wh-opt op-sym "\\|" wh-nec id "\\)" "\\)"))
+       (dcl-list "([^():]*)")
+       (func-name (concat "\\(" oper "\\|" id "::" id "\\|" id "\\)"))
+       (inits
+         (concat "\\(:"
+                 "\\(" wh-opt id "(.*\\()" wh-opt "," "\\)\\)*"
+                 wh-opt id "(.*)" wh-opt "{"
+                 "\\|" wh-opt "{\\)"))
+       (type-name (concat
+                    "\\(" c++-defun-header-strong-struct-equivs wh-nec "\\)?"
+                    id))
+       (type (concat "\\(const" wh-nec "\\)?"
+                     "\\(" type-name "\\|" type-name wh-opt "\\*+" "\\|"
+                     type-name wh-opt "&" "\\)"))
+       (modifier "\\(inline\\|virtual\\|overload\\|auto\\|static\\)")
+       (modifiers (concat "\\(" modifier wh-nec "\\)*"))
+       (func-header
+         ;;     type               arg-dcl
+         (concat modifiers type wh-nec func-name wh-opt dcl-list wh-opt inits))
+       (inherit (concat "\\(:" wh-opt "\\(public\\|private\\)?"
+                        wh-nec id "\\)"))
+       (cs-header (concat
+                    c++-defun-header-strong-struct-equivs
+                    wh-nec id wh-opt inherit "?" wh-opt "{")))
+    (concat "^\\(" func-header "\\|" cs-header "\\)"))
+  "Strongly-defined regexp to match beginning of structure or function def.")
+
+
+;; This part has to do with recognizing defuns.
+
+;; The weak convention we will use is that a defun begins any time
+;; there is a left curly brace, or some identifier on the left margin,
+;; followed by a left curly somewhere on the line.  (This will also
+;; incorrectly match some continued strings, but this is after all
+;; just a weak heuristic.)  Suggestions for improvement (short of the
+;; strong scheme shown above) are welcomed.
+
+(defconst c++-defun-header-weak "^{\\|^[_a-zA-Z].*{"
+  "Weakly-defined regexp to match beginning of structure or function def.")
+
+(defun c++-beginning-of-defun (arg)
+  (interactive "p")
+  (let ((c++-defun-header (if c++-match-header-strongly
+                              c++-defun-header-strong
+                            c++-defun-header-weak)))
+    (cond ((or (= arg 0) (and (> arg 0) (bobp))) nil)
+          ((and (not (looking-at c++-defun-header))
+                (let ((curr-pos (point))
+                      (open-pos (if (search-forward "{" nil 'move)
+                                    (point)))
+                      (beg-pos
+                        (if (re-search-backward c++-defun-header nil 'move)
+                            (match-beginning 0))))
+                  (if (and open-pos beg-pos
+                           (< beg-pos curr-pos)
+                           (> open-pos curr-pos))
+                      (progn
+                        (goto-char beg-pos)
+                        (if (= arg 1) t nil));; Are we done?
+                    (goto-char curr-pos)
+                    nil))))
+          (t
+            (if (and (looking-at c++-defun-header) (not (bobp)))
+                (forward-char (if (< arg 0) 1 -1)))
+            (and (re-search-backward c++-defun-header nil 'move (or arg 1))
+                 (goto-char (match-beginning 0)))))))
+
+
+(defun c++-end-of-defun (arg)
+  (interactive "p")
+  (let ((c++-defun-header (if c++-match-header-strongly
+                              c++-defun-header-strong
+                            c++-defun-header-weak)))
+    (if (and (eobp) (> arg 0))
+        nil
+      (if (and (> arg 0) (looking-at c++-defun-header)) (forward-char 1))
+      (let ((pos (point)))
+        (c++-beginning-of-defun 
+          (if (< arg 0)
+              (- (- arg (if (eobp) 0 1)))
+            arg))
+        (if (and (< arg 0) (bobp))
+            t
+          (if (re-search-forward c++-defun-header nil 'move)
+              (progn (forward-char -1)
+                     (forward-sexp)
+                     (beginning-of-line 2)))
+          (if (and (= pos (point)) 
+                   (re-search-forward c++-defun-header nil 'move))
+              (c++-end-of-defun 1))))
+      t)))
+
+(defun c++-indent-defun ()
+  "Indents the current function definition, struct or class declaration."
+  (interactive)
+  (let ((restore (point)))
+    (c++-end-of-defun 1)
+    (beginning-of-line 1)
+    (let ((end (point)))
+      (c++-beginning-of-defun 1)
+      (while (<= (point) end)
+        (c++-indent-line)
+        (next-line 1)
+        (beginning-of-line 1)))
+    (goto-char restore)))
diff --git a/lisp/textmodes/bibtex.el b/lisp/textmodes/bibtex.el
new file mode 100644
index 00000000000..17591f658fe
--- /dev/null
+++ b/lisp/textmodes/bibtex.el
@@ -0,0 +1,1020 @@
+;;; BibTeX mode for GNU Emacs
+;; Copyright (C) 1985, 1986, 1987, 1990 Free Software Foundation, Inc.
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 1, or (at your option)
+;; any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs; see the file COPYING.  If not, write to
+;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+;;; Mike Newton (newton@gumby.cs.caltech.edu) 91.1.20
+;;;  * bibtex.el/bibtex-mode : updated comments to indicate new use of 
+;;;    address, add minor explanations and fix small omissions.
+;;;  * bibtex.el/bibtex-entry : fixed spelling of variable
+
+;;; Mike Newton (newton@gumby.cs.caltech.edu) 90.11.17
+;;;  * Handle items like
+;;;          title = poft # "Fifth Tri-quaterly" # random-conf,
+;;;    and   title = {This title is inside curlies}
+;;;  * added user settable, always present, optional fields
+;;;  * fixed 'bibtex-find-it's doc string's location
+;;;  * bibtex-field-text made more general (it wouldnt handle the # construct)
+;;;             and it now handles a small subset of the {} cases
+;;;  * put DEA thesis back in (why get rid of good code?) 
+;;;  * merged into release 19 version code
+;;;  * if cross-ref'ing is on, put 'pages' near top of OPTs, as the other
+;;;             entries are unlikely to be used.
+;;;  * skip-whitespace replaced by skip-chars-forward (also done 
+;;;             by Marc Shairo)
+
+;;; Bengt Martensson, March 6
+;;;   Adapted to Bibtex 0.99 by updating the optional fields according
+;;;   to the document BibTeXing, Oren Patashnik, dated January 31, 1988.
+;;;   Updated documentation strings accordingly.  Added (provide 'bibtex).
+;;;   If bibtex-include-OPT-crossref is non-nil, every entry will have
+;;;   an OPTcrossref field, analogously for bibtex-include-OPTkey and
+;;;   bibtex-include-OPTannote.  Added bibtex-preamble, bound to ^C^EP,
+;;;   and also found in X- and sun-menus.  Cleaned up the sun-menu
+;;;   stuff, and made it more uniform with the X-menu stuff.  Marc: I
+;;;   strongly suspect that I broke your parsing...  (Or, more
+;;;   correctly, BibTeX 0.99 broke it.)
+;;;   Added bibtex-clean-entry-zap-empty-opts, defvar'd to t.  If it
+;;;   is nil, bibtex-clean-entry will leave empty optional fields alone.
+  
+;;; Marc Shapiro 1-feb-89: integrated changes by Bengt Martensson 88-05-06:
+;;;   Added Sun menu support.  Locally bound to right mouse button in 
+;;;   bibtex-mode.  Emacs 18.49 allows local mouse bindings!!
+;;;   Commented out DEAthesis.
+
+;;; Marc Shapiro 6-oct-88
+;;;  * use indent-to-column instead of inserting tabs (changes to 
+;;;    bibtex-entry, bibtex-make-entry, bibtex-make-OPT-entry, renamed to
+;;;    bibtex-make-optional-entry)
+;;;  * C-c C-k deletes the current OPT entry entirely
+;;;  * C-c C-d replaces text of field with ""
+;;;  * renamed bibtex-find-it to bibtex-find-text.  With arg, now goes to
+;;;    start of text.  Fixed bugs in it.
+
+;;; Marc Shapiro 23-sep-88
+;;;  * bibtex-clean-entry moves past end of entry.
+;;;  * bibtex-clean-entry signals mandatory fields left empty.
+
+;;; Marc Shapiro 18-jul-88
+;;;  * Moved all the entry type keystrokes to "C-c C-e something" (instead of
+;;;    "C-c something" previously) to make room for more.  C-c C-e is
+;;;    supposed to stand for "entry" [idea taken from mail-mode].  Moved
+;;;    bibtex-pop-previous to C-c C-p and bibtex-pop-next to C-c C-n.
+;;;  * removed binding for "\e[25~"
+;;;  * replaced bibtex-clean-optionals by bibtex-clean-entry, bound to
+;;;    C-c C-c
+
+;;; Marc Shapiro 13-jul-88 [based on ideas by Sacha Krakowiak of IMAG]
+;;;  * bibtex-pop-previous replaces current field with value of
+;;;    similar field in previous entry.  May be called n times in a row
+;;;    (or with arg n) to pop similar field of n'th previous entry.
+;;;    There is also a bibtex-pop-next to get similar field of next
+;;;    entry.
+;;;  * C-c C-k now kills all empty optional fields of current entry, and
+;;;    removes "OPT" for those optional fields which have text. 
+
+;;; Marc Shapiro 14-dec-87
+;;;   Cosmetic fixes.  Fixed small bug in bibtex-move-outside-of-entry.
+;;; Skip Montanaro <steinmetz!sprite!montanaro> 7-dec-87, Shapiro 10-dec-87
+;;;   before inserting an entry, make sure we are outside of a bib entry
+;;; Marc Shapiro 3-nov-87
+;;;   addition for France: DEAthesis
+;;; Marc Shapiro 19-oct-1987
+;;;   add X window menu option; bug fixes. TAB, LFD, C-c " and C-c C-o now
+;;;   behave consistently; deletion never occurs blindly.
+;;; Marc Shapiro <shapiro@inria.inria.fr> 15-oct-1986
+;;;    align long lines nicely; C-c C-o checks for the "OPT" string;
+;;;    TAB goes to the end of the string; use lower case; use
+;;;    run-hooks
+
+;;; Bengt Martensson <ubrinf!mond!bengt> 87-06-28
+;;; (Bengt Martensson <bengt@mathematik.uni-Bremen.de> 87-06-28)
+;;;   Original version
+
+;;; NOTE by Marc Shapiro, 14-dec-87:
+;;; (bibtex-x-environment) binds an X menu for bibtex mode to x-button-c-right.
+;;; Trouble is, in Emacs 18.44 you can't have a mode-specific mouse binding,
+;;; so it will remain active in all windows.  Yuck!
+
+(provide 'bibtex)
+
+(defvar bibtex-mode-syntax-table nil "")
+(defvar bibtex-mode-abbrev-table nil "")
+(define-abbrev-table 'bibtex-mode-abbrev-table ())
+(defvar bibtex-mode-map (make-sparse-keymap) "")
+(defvar bibtex-pop-previous-search-point nil
+  "Next point where `bibtex-pop-previous' should start looking for a similar
+entry.")
+(defvar bibtex-pop-next-search-point nil
+  "Next point where `bibtex-pop-next' should start looking for a similar
+entry.")
+
+(defvar bibtex-clean-entry-zap-empty-opts t
+  "*If non-nil, `bibtex-clean-entry' will delete all empty optional fields.")
+(defvar bibtex-include-OPTcrossref t
+  "*If non-nil, all entries will have an `OPTcrossref' field.")
+(defvar bibtex-include-OPTkey t
+  "*If non-nil, all entries will have an `OPTkey' field.")
+(defvar bibtex-include-OPTannote t
+  "*If non-nil, all entries will have an `OPTannote' field.")
+
+;; note: the user should be allowed to have their own list of always
+;;       available optional fields.  exs: "keywords" "categories"
+(defvar bibtex-mode-user-optional-fields nil            ;no default value
+  "*List of optional fields that user always wants present in a bibtex entry.
+One possibility is for ``keywords''")
+
+
+;;; A bibtex file is a sequence of entries, either string definitions
+;;; or reference entries.  A reference entry has a type part, a
+;;; key part, and a comma-separated sequence of fields.  A string
+;;; entry has a single field.  A field has a left and right part,
+;;; separated by a '='.  The left part is the name, the right part is
+;;; the text.  Here come the definitions allowing to create and/or parse
+;;; entries and fields:
+
+;;; fields
+(defun bibtex-cfield (name text)
+  "Create a regexp for a bibtex field of name NAME and text TEXT."
+  (concat ",[ \t\n]*\\("
+          name
+          "\\)[ \t\n]*=[ \t\n]*\\("
+          text
+          "\\)"))
+(defconst bibtex-name-in-cfield 1
+  "The regexp subexpression number of the name part in `bibtex-cfield'.")
+(defconst bibtex-text-in-cfield 2
+  "The regexp subexpression number of the text part in `bibtex-cfield'.")
+
+(defconst bibtex-field-name "[A-Za-z][---A-Za-z0-9:_+]*"
+  "Regexp defining the name part of a bibtex field.")
+
+;; bibtex-field-text must be able to handle
+;;   title = "Proc. Fifteenth Annual" # STOC,
+;;   month = "10~" # jan,
+;;   year = "{\noopsort{1973c}}1981",
+;;   month = apr # "-" # may,
+;;   key = {Volume-2},
+;;   note = "Volume~2 is listed under Knuth \cite{book-full}"
+;; i have added a few of these, but not all! -- MON
+
+(defconst bibtex-field-const
+  "[0-9A-Za-z][---A-Za-z0-9:_+]*"
+  "Format of a bibtex field constant.")
+(defconst bibtex-field-string
+  (concat
+    "\"[^\"]*[^\\\\]\"\\|\"\"")
+  "Match either a string or an empty string.")
+(defconst bibtex-field-string-or-const
+  (concat bibtex-field-const "\\|" bibtex-field-string)
+  "Match either `bibtex-field-string' or `bibtex-field-const'.")
+
+;(defconst bibtex-field-text
+;  "\"[^\"]*[^\\\\]\"\\|\"\"\\|[0-9A-Za-z][---A-Za-z0-9:_+]*"
+;  "Regexp defining the text part of a bibtex field: either a string, or an empty string, or a constant.")
+
+(defconst bibtex-field-text
+  (concat
+    "\\(" bibtex-field-string-or-const "\\)"
+        "\\([ \t\n]+#[ \t\n]+\\(" bibtex-field-string-or-const "\\)\\)*\\|"
+    "{[^{}]*[^\\\\]}")
+  "Regexp defining the text part of a bibtex field: either a string, or
+an empty string, or a constant followed by one or more # / constant pairs.
+Also matches simple {...} patterns.")
+
+(defconst bibtex-field
+  (bibtex-cfield bibtex-field-name bibtex-field-text)
+  "Regexp defining the format of a bibtex field")
+
+(defconst bibtex-name-in-field bibtex-name-in-cfield
+  "The regexp subexpression number of the name part in `bibtex-field'.")
+(defconst bibtex-text-in-field bibtex-text-in-cfield
+  "The regexp subexpression number of the text part in `bibtex-field'.")
+
+;;; references
+(defconst bibtex-reference-type
+  "@[A-Za-z]+"
+  "Regexp defining the type part of a bibtex reference entry.")
+(defconst bibtex-reference-head
+  (concat "^[ \t]*\\("
+          bibtex-reference-type
+          "\\)[ \t]*[({]\\("
+          bibtex-field-name
+          "\\)")
+  "Regexp defining format of the header line of a bibtex reference entry.")
+(defconst bibtex-type-in-head 1
+  "The regexp subexpression number of the type part in `bibtex-reference-head'.")
+(defconst bibtex-key-in-head 2
+  "The regexp subexpression number of the key part in `bibtex-reference-head'.")
+
+(defconst bibtex-reference
+  (concat bibtex-reference-head
+          "\\([ \t\n]*" bibtex-field "\\)*"
+          "[ \t\n]*[})]")
+  "Regexp defining the format of a bibtex reference entry.")
+(defconst bibtex-type-in-reference bibtex-type-in-head
+  "The regexp subexpression number of the type part in `bibtex-reference'.")
+(defconst bibtex-key-in-reference bibtex-key-in-head
+  "The regexp subexpression number of the key part in `bibtex-reference'.")
+
+;;; strings
+(defconst bibtex-string
+  (concat "^[ \t]*@[sS][tT][rR][iI][nN][gG][ \t\n]*[({][ \t\n]*\\("
+          bibtex-field-name
+          "\\)[ \t\n]*=[ \t\n]*\\("
+          bibtex-field-text
+          "\\)[ \t\n]*[})]")
+  "Regexp defining the format of a bibtex string entry.")
+(defconst bibtex-name-in-string 1
+  "The regexp subexpression of the name part in `bibtex-string'.")
+(defconst bibtex-text-in-string 2
+  "The regexp subexpression of the text part in `bibtex-string'.")
+
+(defconst bibtex-name-alignement 2
+  "Alignment for the name part in BibTeX fields.
+Chosen on aesthetic grounds only.")
+
+(defconst bibtex-text-alignment (length "  organization = ")
+  "Alignment for the text part in BibTeX fields.
+Equal to the space needed for the longest name part.")
+
+;;; bibtex mode:
+
+;;;###autoload
+(defun bibtex-mode () 
+  "Major mode for editing bibtex files.
+
+\\{bibtex-mode-map}
+
+A command such as \\[bibtex-Book] will outline the fields for a BibTeX book entry.
+
+The optional fields start with the string OPT, and thus ignored by BibTeX.
+The OPT string may be removed from a field with \\[bibtex-remove-OPT].
+\\[bibtex-kill-optional-field] kills the current optional field entirely.
+\\[bibtex-remove-double-quotes] removes the double-quotes around the text of
+the current field.  \\[bibtex-empty-field] replaces the text of the current
+field with the default \"\".
+
+The command \\[bibtex-clean-entry] cleans the current entry, i.e. (i) removes
+double-quotes from entirely numerical fields, (ii) removes OPT from all
+non-empty optional fields, (iii) removes all empty optional fields, and (iv)
+checks that no non-optional fields are empty.
+
+Use \\[bibtex-find-text] to position the dot at the end of the current field.
+Use \\[bibtex-next-field] to move to end of the next field.
+
+\\[bibtex-x-environment] binds a mode-specific X menu to control+right
+mouse button.
+\\[bibtex-sun-environment] binds a mode-specific Sun menu to right
+mouse button.
+
+Fields:
+    address
+           Publisher's address, or for conference, location held
+    annote
+           Long annotation used for annotated bibliographies (begins sentence)
+    author
+           Name(s) of author(s), in BibTeX name format
+    booktitle
+           Book title when the thing being referenced isn't the whole book.
+           For book entries, the title field should be used instead.
+    chapter
+           Chapter number (or section or whatever).
+    crossref
+           The database key of the entry being cross referenced.
+    edition
+           Edition of a book (e.g., \"second\")
+    editor
+           Name(s) of editor(s), in BibTeX name format.
+           If there is also an author field, then the editor field should be
+           for the book or collection that the work appears in
+    howpublished
+            How something strange has been published (begins sentence)
+    institution
+           Sponsoring institution
+    journal
+           Journal name (macros are provided for many)
+    key
+           Alphabetizing, labeling and cross-refing key (needed when no 
+           author or editor)
+    month
+           Month (macros are provided)
+    note
+           To help the reader find a reference (begins sentence)
+    number
+           Number of a journal or technical report
+    organization
+           Organization (sponsoring a conference)
+    pages
+           Page number or numbers (use `--' to separate a range)
+    publisher
+           Publisher name
+    school
+           School name (for theses)
+    series
+           The name of a series or set of books.
+           An individual book will will also have it's own title
+    title
+           The title of the thing being referenced
+    type
+           Type of a technical report (e.g., \"Research Note\") to be used
+           instead of the default \"Technical Report\"
+    volume
+           Volume of a journal or multivolume work
+    year
+           Year---should contain only numerals
+---------------------------------------------------------
+Entry to this mode calls the value of bibtex-mode-hook if that value is
+non-nil."
+  (interactive)
+  (kill-all-local-variables)
+  (if bibtex-mode-syntax-table
+      (set-syntax-table bibtex-mode-syntax-table)
+     (setq bibtex-mode-syntax-table (make-syntax-table))
+     (set-syntax-table bibtex-mode-syntax-table)
+     (modify-syntax-entry ?\" ".")
+     (modify-syntax-entry ?$ "$$  ")
+     (modify-syntax-entry ?% "<   ")
+     (modify-syntax-entry ?'  "w   ")
+     (modify-syntax-entry ?@  "w   ")
+     (modify-syntax-entry ?\\ "\\")
+     (modify-syntax-entry ?\f ">   ")
+     (modify-syntax-entry ?\n ">   ")
+     (modify-syntax-entry ?~ " "))
+  (use-local-map bibtex-mode-map)
+  (setq major-mode 'bibtex-mode)
+
+
+  (setq mode-name "BibTeX")
+  (set-syntax-table bibtex-mode-syntax-table)
+  (setq local-abbrev-table bibtex-mode-abbrev-table)
+  (make-local-variable 'paragraph-start)
+  (setq paragraph-start "^[ \f\n\t]*$")
+
+  (define-key bibtex-mode-map "\t" 'bibtex-find-text)
+  (define-key bibtex-mode-map "\n" 'bibtex-next-field)
+  (define-key bibtex-mode-map "\C-c\"" 'bibtex-remove-double-quotes)
+  (define-key bibtex-mode-map "\C-c\C-c" 'bibtex-clean-entry)
+  (define-key bibtex-mode-map "\C-c?" 'describe-mode)
+  (define-key bibtex-mode-map "\C-c\C-p" 'bibtex-pop-previous)
+  (define-key bibtex-mode-map "\C-c\C-n" 'bibtex-pop-next)
+  (define-key bibtex-mode-map "\C-c\C-k" 'bibtex-kill-optional-field)
+  (define-key bibtex-mode-map "\C-c\C-d" 'bibtex-empty-field)
+
+  (define-key bibtex-mode-map "\C-c\C-e\C-a" 'bibtex-Article)
+  (define-key bibtex-mode-map "\C-c\C-e\C-b" 'bibtex-Book)
+  (define-key bibtex-mode-map "\C-c\C-e\C-d" 'bibtex-DEAthesis)
+  (define-key bibtex-mode-map "\C-c\C-e\C-c" 'bibtex-InProceedings)
+  (define-key bibtex-mode-map "\C-c\C-e\C-i" 'bibtex-InBook)
+  (define-key bibtex-mode-map "\C-c\C-ei" 'bibtex-InCollection)
+  (define-key bibtex-mode-map "\C-c\C-eI" 'bibtex-InProceedings)
+  (define-key bibtex-mode-map "\C-c\C-e\C-m" 'bibtex-Manual)
+  (define-key bibtex-mode-map "\C-c\C-em" 'bibtex-MastersThesis)
+  (define-key bibtex-mode-map "\C-c\C-eM" 'bibtex-Misc)
+  (define-key bibtex-mode-map "\C-c\C-o" 'bibtex-remove-OPT)
+  (define-key bibtex-mode-map "\C-c\C-e\C-p" 'bibtex-PhdThesis)
+  (define-key bibtex-mode-map "\C-c\C-ep" 'bibtex-Proceedings)
+  (define-key bibtex-mode-map "\C-c\C-eP" 'bibtex-preamble)
+  (define-key bibtex-mode-map "\C-c\C-e\C-t" 'bibtex-TechReport)
+  (define-key bibtex-mode-map "\C-c\C-e\C-s" 'bibtex-string)
+  (define-key bibtex-mode-map "\C-c\C-e\C-u" 'bibtex-Unpublished)
+
+  (auto-fill-mode 1)                    ; nice alignements
+  (setq left-margin (+ bibtex-text-alignment 1))
+
+  (run-hooks 'bibtex-mode-hook))
+
+(defun bibtex-move-outside-of-entry ()
+  "Make sure we are outside of a bib entry"
+  (cond ((or
+          (= (point) (point-max))
+          (= (point) (point-min))
+          (looking-at "[ \n]*@")
+          )
+         t)
+        (t
+         (backward-paragraph)
+         (forward-paragraph)))
+  (re-search-forward "[ \t\n]*" (point-max) t))
+
+;;
+;; note: this should really take lists of strings OR of lists.  in the
+;;       second case, one can use either list.  (ie:
+;;                "name" (("crossref") ("journal" "year"))     )
+;;
+
+(defun bibtex-entry (entry-type required optional)
+  (bibtex-move-outside-of-entry)
+  (insert "@" entry-type "{")
+  (mapcar 'bibtex-make-field required)
+  (if bibtex-include-OPTcrossref
+      (bibtex-make-optional-field "crossref"))
+  (if bibtex-include-OPTkey
+      (bibtex-make-optional-field "key"))
+  (mapcar 'bibtex-make-optional-field optional)
+  (if bibtex-mode-user-optional-fields          ;MON...
+      (mapcar 'bibtex-make-optional-field
+              bibtex-mode-user-optional-fields))
+  (if bibtex-include-OPTannote
+      (bibtex-make-optional-field "annote"))
+  (insert "\n}\n\n")
+  (forward-char -3)
+  (up-list -1)
+  (forward-char 1))  
+
+(defun bibtex-make-field (str)
+  (interactive "sBibTeX entry type: ")
+  (insert ",\n")
+  (indent-to-column bibtex-name-alignement)
+  (insert str " = ")
+  (indent-to-column bibtex-text-alignment)
+  (insert "\"\"")
+  nil)
+
+(defun bibtex-make-optional-field (str)
+  (interactive "sOptional BibTeX entry type: ")
+  (insert ",\n")
+  (indent-to-column bibtex-name-alignement)
+  (insert "OPT" str " = ")
+  (indent-to-column bibtex-text-alignment)
+  (insert "\"\"")
+  nil)
+
+;; What to do about crossref?  if present, journal and year are 
+;; both optional.  Due to this, i move all of them into optional. -- MON
+
+(defun bibtex-Article ()
+  (interactive)
+  (if bibtex-include-OPTcrossref
+      (bibtex-entry "Article" '("author" "title")
+                    '("journal" "year" "volume" "number" "pages"
+                      "month" "note"))
+    (bibtex-entry "Article" '("author" "title" "journal" "year")
+                  '("volume" "number" "pages" "month" "note"))))
+
+(defun bibtex-Book ()
+  (interactive)
+  (bibtex-entry "Book" '("author" "title" "publisher" "year")
+                '("editor" "volume" "number" "series" "address"
+                  "edition" "month" "note")))
+
+(defun bibtex-Booklet ()
+  (interactive)
+  (bibtex-entry "Booklet" '("title")
+                '("author" "howpublished" "address" "month" "year" "note")))
+
+;; France: Dipl\^{o}me d'Etudes Approfondies (similar to Master's)
+(defun bibtex-DEAthesis ()
+  (interactive)
+  (bibtex-entry "DEAthesis" '("author" "title" "school" "year")
+                '("address" "month" "note")))
+
+(defun bibtex-InBook ()
+  (interactive)
+  (if bibtex-include-OPTcrossref
+      (bibtex-entry "InBook" '("author" "title" "chapter")
+                    '("publisher" "year" "editor" "pages" "volume" "number"
+                      "series" "address" "edition" "month" "type" "note"))
+    (bibtex-entry "InBook" '("author" "title" "chapter" "publisher" "year")
+                  '("editor" "pages" "volume" "number" "series" "address"
+                    "edition" "month" "type" "note"))))
+
+;; In next 2, for crossref case, put pages near beginning of 
+;; optionals as it will be used most often  -- MON
+(defun bibtex-InCollection ()
+  (interactive)
+  (if bibtex-include-OPTcrossref
+      (bibtex-entry "InCollection" '("author" "title")
+                    '("pages" "booktitle" "publisher" "year"
+                      "editor" "volume" "number" "series" "type" "chapter"
+                      "address" "edition" "month" "note"))
+    (bibtex-entry "InCollection" '("author" "title"
+                                   "booktitle" "publisher" "year")
+                  '("editor" "volume" "number" "series" "type" "chapter"
+                    "pages" "address" "edition" "month" "note"))))
+
+(defun bibtex-InProceedings ()
+  (interactive)
+  (if bibtex-include-OPTcrossref
+      (bibtex-entry "InProceedings" '("author" "title")
+                    '( "pages" "editor" "volume" "number" "series"
+                       "booktitle" "year"
+                       "organization" "publisher" "address" "month" "note"))
+    (bibtex-entry "InProceedings" '("author" "title" "booktitle" "year")
+                  '("editor" "volume" "number" "series" "pages"
+                    "organization" "publisher" "address" "month" "note"))))
+
+(defun bibtex-Manual ()
+  (interactive)
+  (bibtex-entry "Manual" '("title")
+                '("author" "organization" "address" "edition" "year"
+                           "month" "note")))
+
+(defun bibtex-MastersThesis ()
+  (interactive)
+  (bibtex-entry "MastersThesis" '("author" "title" "school" "year")
+                '("address" "month" "note" "type")))
+
+(defun bibtex-Misc ()
+  (interactive)
+  (bibtex-entry "Misc" '()
+                '("author" "title" "howpublished" "year" "month" "note")))
+
+(defun bibtex-PhdThesis ()
+  (interactive)
+  (bibtex-entry "PhdThesis" '("author" "title" "school" "year")
+                '("address" "month" "type" "note")))
+
+(defun bibtex-Proceedings ()
+  (interactive)
+  (bibtex-entry "Proceedings" '("title" "year")
+                '("editor" "volume" "number" "series" "publisher"
+                  "organization" "address" "month" "note")))
+
+(defun bibtex-TechReport ()
+  (interactive)
+  (bibtex-entry "TechReport" '("author" "title" "institution" "year")
+                '("type" "number" "address" "month" "note")))
+
+
+(defun bibtex-Unpublished ()
+  (interactive)
+  (bibtex-entry "Unpublished" '("author" "title" "note")
+                '("year" "month")))
+
+(defun bibtex-string ()
+  (interactive)
+  (bibtex-move-outside-of-entry)
+  (insert "@string{ = """"}\n")
+  (previous-line 1)
+  (forward-char 8))
+
+(defun bibtex-preamble ()
+  (interactive)
+  (bibtex-move-outside-of-entry)
+  (insert "@Preamble{}\n")
+  (previous-line 1)
+  (forward-char 10))
+
+(defun bibtex-next-field (arg)
+  "Finds end of text of next BibTeX field; with arg, to its beginning"
+  (interactive "P")
+  (bibtex-inside-field)
+  (let ((start (point)))
+    (condition-case ()
+        (progn
+          (bibtex-enclosing-field)
+          (goto-char (match-end 0))
+          (forward-char 2))
+      (error
+       (goto-char start)
+       (end-of-line)
+       (forward-char 1))))
+  (bibtex-find-text arg))
+
+(defun bibtex-find-text (arg)
+  "Go to end of text of current field; with arg, go to beginning."
+  (interactive "P")
+  (bibtex-inside-field)
+  (bibtex-enclosing-field)
+  (if arg
+      (progn
+        (goto-char (match-beginning bibtex-text-in-field))
+        (if (looking-at "\"")
+            (forward-char 1)))
+    (goto-char (match-end bibtex-text-in-field))
+    (if (= (preceding-char) ?\")
+        (forward-char -1))))
+
+(defun bibtex-remove-OPT ()
+  "Removes the 'OPT' starting optional arguments and goes to end of text"
+  (interactive)
+  (bibtex-inside-field)
+  (bibtex-enclosing-field)
+  (save-excursion
+    (goto-char (match-beginning bibtex-name-in-field))
+    (if (looking-at "OPT")
+        (delete-char (length "OPT"))))
+  (bibtex-inside-field))
+
+(defun bibtex-inside-field ()
+  "Try to avoid point being at end of a bibtex field."
+  (interactive)
+  (end-of-line)
+  (skip-chars-backward " \t")           ;delete these chars? -- MON
+  (cond ((= (preceding-char) ?,)
+         (forward-char -1)))
+  (cond ((= (preceding-char) ?\")
+         (forward-char -1))))           ;only go back if quote
+
+
+(defun bibtex-remove-double-quotes ()
+  "Removes """" around string."
+  (interactive)
+  (save-excursion
+    (bibtex-inside-field)
+    (bibtex-enclosing-field)
+    (let ((start (match-beginning bibtex-text-in-field))
+          (stop (match-end  bibtex-text-in-field)))
+      (goto-char stop)
+      (forward-char -1)
+      (if (looking-at "\"")
+          (delete-char 1))
+      (goto-char start)
+      (if (looking-at "\"")
+          (delete-char 1)))))
+
+(defun bibtex-kill-optional-field ()
+  "Kill the entire enclosing optional BibTeX field"
+  (interactive)
+  (bibtex-inside-field)
+  (bibtex-enclosing-field)
+  (goto-char (match-beginning bibtex-name-in-field))
+  (let ((the-end (match-end 0))
+        (the-beginning (match-beginning 0)))
+    (if (looking-at "OPT")
+        (progn
+          (goto-char the-end)
+          (skip-chars-forward " \t\n,")
+          (kill-region the-beginning the-end))
+      (error "Mandatory fields can't be killed"))))
+
+(defun bibtex-empty-field ()
+  "Delete the text part of the current field, replace with empty text"
+  (interactive)
+  (bibtex-inside-field)
+  (bibtex-enclosing-field)
+  (goto-char (match-beginning bibtex-text-in-field))
+  (kill-region (point) (match-end bibtex-text-in-field))
+  (insert "\"\"")
+  (bibtex-find-text t))
+
+
+(defun bibtex-pop-previous (arg)
+  "Replace text of current field with the text of similar field in previous entry.
+With arg, go up ARG entries.  Repeated, goes up so many times.  May be
+intermixed with \\[bibtex-pop-next] (bibtex-pop-next)."
+  (interactive "p")
+  (bibtex-inside-field)
+  (save-excursion
+    ; parse current field
+    (bibtex-enclosing-field)
+    (let ((start-old-text (match-beginning bibtex-text-in-field))
+          (stop-old-text  (match-end bibtex-text-in-field))
+          (start-name (match-beginning bibtex-name-in-field))
+          (stop-name (match-end bibtex-name-in-field))
+          (new-text))
+      (goto-char start-name)
+      ; construct regexp for previous field with same name as this one
+      (let ((matching-entry
+             (bibtex-cfield
+              (buffer-substring (if (looking-at "OPT")
+                                    (+ (point) (length "OPT"))
+                                  (point))
+                                stop-name)
+              bibtex-field-text)))
+        
+        ; if executed several times in a row, start each search where the
+        ; last one finished
+        (cond ((or (eq last-command 'bibtex-pop-previous)
+                   (eq last-command 'bibtex-pop-next))
+               t
+               )
+              (t
+               (bibtex-enclosing-reference)
+               (setq bibtex-pop-previous-search-point (match-beginning 0))
+               (setq bibtex-pop-next-search-point (match-end 0))))
+        (goto-char bibtex-pop-previous-search-point)
+        
+        ; Now search for arg'th previous similar field
+        (cond
+         ((re-search-backward matching-entry (point-min) t arg)
+          (setq new-text
+                (buffer-substring (match-beginning bibtex-text-in-cfield)
+                                  (match-end bibtex-text-in-cfield)))
+          ; Found a matching field. Remember boundaries.
+          (setq bibtex-pop-next-search-point (match-end 0))
+          (setq bibtex-pop-previous-search-point (match-beginning 0))
+          (bibtex-flash-head)
+          ; Go back to where we started, delete old text, and pop new.
+          (goto-char stop-old-text)
+          (delete-region start-old-text stop-old-text)
+          (insert new-text))
+         (t                             ; search failed
+          (error "No previous matching BibTeX field."))))))
+  (setq this-command 'bibtex-pop-previous))
+
+(defun bibtex-pop-next (arg)
+  "Replace text of current field with the text of similar field in next entry.
+With arg, go up ARG entries.  Repeated, goes up so many times.  May be
+intermixed with \\[bibtex-pop-previous] (bibtex-pop-previous)."
+  (interactive "p")
+  (bibtex-inside-field)
+  (save-excursion
+    ; parse current field
+    (bibtex-enclosing-field)
+    (let ((start-old-text (match-beginning bibtex-text-in-field))
+          (stop-old-text  (match-end bibtex-text-in-field))
+          (start-name (match-beginning bibtex-name-in-field))
+          (stop-name (match-end bibtex-name-in-field))
+          (new-text))
+      (goto-char start-name)
+      ; construct regexp for next field with same name as this one,
+      ; ignoring possible OPT's
+      (let ((matching-entry
+             (bibtex-cfield
+              (buffer-substring (if (looking-at "OPT")
+                                    (+ (point) (length "OPT"))
+                                  (point))
+                                stop-name)
+              bibtex-field-text)))
+        
+        ; if executed several times in a row, start each search where the
+        ; last one finished
+        (cond ((or (eq last-command 'bibtex-pop-next)
+                   (eq last-command 'bibtex-pop-previous))
+               t
+               )
+              (t
+               (bibtex-enclosing-reference)
+               (setq bibtex-pop-previous-search-point (match-beginning 0))
+               (setq bibtex-pop-next-search-point (match-end 0))))
+        (goto-char bibtex-pop-next-search-point)
+        
+        ; Now search for arg'th next similar field
+        (cond
+         ((re-search-forward matching-entry (point-max) t arg)
+          (setq new-text
+                (buffer-substring (match-beginning bibtex-text-in-cfield)
+                                  (match-end bibtex-text-in-cfield)))
+          ; Found a matching field. Remember boundaries.
+          (setq bibtex-pop-next-search-point (match-end 0))
+          (setq bibtex-pop-previous-search-point (match-beginning 0))
+          (bibtex-flash-head)
+          ; Go back to where we started, delete old text, and pop new.
+          (goto-char stop-old-text)
+          (delete-region start-old-text stop-old-text)
+          (insert new-text))
+         (t                             ; search failed
+          (error "No next matching BibTeX field."))))))
+  (setq this-command 'bibtex-pop-next))
+
+(defun bibtex-flash-head ()
+  "Flash at BibTeX reference head before point, if exists.  (Moves point)."
+  (let ((flash))
+    (cond ((re-search-backward bibtex-reference-head (point-min) t)
+           (goto-char (match-beginning bibtex-type-in-head))
+           (setq flash (match-end bibtex-key-in-reference)))
+          (t
+           (end-of-line)
+           (skip-chars-backward " \t")
+           (setq flash (point))
+           (beginning-of-line)
+           (skip-chars-forward " \t")))
+    (if (pos-visible-in-window-p (point))
+        (sit-for 1)
+      (message "From: %s"
+               (buffer-substring (point) flash)))))
+
+
+
+(defun bibtex-enclosing-field ()
+  "Search for BibTeX field enclosing point.
+Point moves to end of field; also, use match-beginning and match-end
+to parse the field."
+  (condition-case errname
+      (bibtex-enclosing-regexp bibtex-field)
+    (search-failed
+     (error "Can't find enclosing BibTeX field."))))
+
+(defun bibtex-enclosing-reference ()
+  "Search for BibTeX reference enclosing point.
+Point moves to end of reference; also, use match-beginning and match-end
+to parse the reference."
+  (condition-case errname
+      (bibtex-enclosing-regexp bibtex-reference)
+    (search-failed
+     (error "Can't find enclosing BibTeX reference."))))
+
+(defun bibtex-enclosing-regexp (regexp)
+  "Search for REGEXP enclosing point.
+Point moves to end of REGEXP.  See also match-beginning and match-end.
+If an enclosing REGEXP is not found, signals search-failed; point is left in
+an undefined location.
+
+[Doesn't something like this exist already?]"
+  
+  (interactive "sRegexp: ")
+  ; compute reasonable limits for the loop
+  (let* ((initial (point))
+         (right (if (re-search-forward regexp (point-max) t)
+                    (match-end 0)
+                  (point-max)))
+         (left
+          (progn
+            (goto-char initial)
+            (if (re-search-backward regexp (point-min) t)
+                (match-beginning 0)
+              (point-min)))))
+    ; within the prescribed limits, loop until a match is found
+    (goto-char left)
+    (re-search-forward regexp right nil 1)
+    (if (> (match-beginning 0) initial)
+        (signal 'search-failed (list regexp)))    
+    (while (<= (match-end 0) initial)
+      (re-search-forward regexp right nil 1)
+      (if (> (match-beginning 0) initial)
+          (signal 'search-failed (list regexp))))
+    ))
+
+(defun bibtex-clean-entry ()
+  "For all optional fields of current BibTeX entry: if empty, kill the whole field; otherwise, remove the \"OPT\" string in the name; if text numerical, remove double-quotes.  For all mandatory fields: if empty, signal error."
+  (interactive)
+  (bibtex-enclosing-reference)
+  (goto-char (match-beginning 0))
+  (let ((start (point)))
+    (save-restriction
+      (narrow-to-region start (match-end 0))
+      (while (re-search-forward bibtex-field (point-max) t 1)
+        (let ((begin-field (match-beginning 0))
+              (end-field (match-end 0))
+              (begin-name (match-beginning bibtex-name-in-field))
+              (end-name (match-end  bibtex-name-in-field))
+              (begin-text (match-beginning bibtex-text-in-field))
+              (end-text (match-end bibtex-text-in-field))
+              )
+          (goto-char begin-name)
+          (cond ((and
+                  (looking-at "OPT")
+                  bibtex-clean-entry-zap-empty-opts)
+                 (goto-char begin-text)
+                 (if (looking-at "\"\"") ; empty: delete whole field
+                     (delete-region begin-field end-field)
+                   ; otherwise: not empty, delete "OPT"
+                   (goto-char begin-name)
+                   (delete-char (length "OPT"))
+                   (goto-char begin-field) ; and loop to go through next test
+                   ))
+                (t
+                 (goto-char begin-text)
+                 (cond ((looking-at "\"[0-9]+\"") ; if numerical,
+                        (goto-char end-text)
+                        (delete-char -1) ; delete enclosing double-quotes
+                        (goto-char begin-text)
+                        (delete-char 1)
+                        (goto-char end-field) ; go to end for next search
+                        (forward-char -2) ; to compensate for the 2 quotes deleted
+                        )
+                       ((looking-at "\"\"") ; if empty quotes, complain
+                        (forward-char 1)
+                        (if (not (or (equal (buffer-substring
+                                             begin-name
+                                             (+ begin-name 3))
+                                            "OPT")
+                                     (equal (buffer-substring
+                                             begin-name
+                                             (+ begin-name 3))
+                                            "opt")))
+                            (error "Mandatory field ``%s'' is empty"
+                                   (buffer-substring begin-name end-name))))
+                       (t
+                        (goto-char end-field))))))))
+    (goto-char start)
+    (skip-chars-forward "@a-zA-Z")
+    (bibtex-enclosing-reference)
+    (goto-char (match-end 0))
+    (skip-chars-forward " \t\n")))
+
+
+
+;;; X window menus for bibtex mode
+
+(defun bibtex-x-help (arg)
+  "Mouse commands for BibTeX mode"
+  
+  (let ((selection
+         (x-popup-menu
+          arg
+          '("BibTeX commands"
+            ("BibTeX entry types"
+             (" article in conference Proceedings " . bibtex-InProceedings)
+             ("        Article in journal         " . bibtex-Article)
+             ("               Book                " . bibtex-Book)
+             ("             Booklet               " . bibtex-Booklet)
+             ("            Conference             " . bibtex-InProceedings)
+             ("         Master's Thesis           " . bibtex-MastersThesis)
+             ("            DEA Thesis             " . bibtex-DEAthesis)
+             ("            Phd. Thesis            " . bibtex-PhdThesis)
+             ("         Technical Report          " . bibtex-TechReport)
+             ("         technical Manual          " . bibtex-Manual)
+             ("      conference Proceedings       " . bibtex-Proceedings)
+             ("        a chapter in a Book        " . bibtex-InBook)
+             ("    an article in a Collection     " . bibtex-InCollection)
+             ("           miscellaneous           " . bibtex-Misc)
+             ("            unpublished            " . bibtex-Unpublished)
+             ("              string               " . bibtex-string)
+             ("             preamble              " . bibtex-preamble)
+             )
+            ("Moving around and editing"
+             ("            next field             " . bibtex-next-field)
+             ("          to end of field          " . bibtex-find-text)
+             ("snatch from similar preceding field" . bibtex-pop-previous)
+             ("snatch from similar following field" . bibtex-pop-next)
+             ("            remove OPT             " . bibtex-remove-OPT)
+             ("           remove quotes           "
+              . bibtex-remove-double-quotes)
+             ("          clean up entry           " . bibtex-clean-entry)
+             )
+            ("help"
+             ("       describe BibTeX mode        " . describe-mode)
+             )))))
+    (and selection (call-interactively selection))))
+
+(defun bibtex-x-environment ()
+  "Set up X menus for BibTeX mode.  Call it as bibtex-mode-hook, or interactively"
+  (interactive)
+  (require 'x-mouse)
+  (define-key mouse-map x-button-c-right 'bibtex-x-help)
+  )
+
+
+
+;; Please don't send anything to bug-gnu-emacs about these Sunwindows functions
+;; since we aren't interested.  See etc/SUN-SUPPORT for the reasons why
+;; we consider this nothing but a distraction from our work.
+
+(if (fboundp 'defmenu)
+    (progn
+
+(defmenu bibtex-sun-entry-menu 
+  ("Article In Conf. Proc."
+   (lambda () (eval-in-window *menu-window* (bibtex-InProceedings))))
+  ("Article In Journal"
+   (lambda () (eval-in-window *menu-window* (bibtex-Article))))
+  ("Book"
+   (lambda () (eval-in-window *menu-window* (bibtex-Book))))
+  ("Booklet"
+   (lambda () (eval-in-window *menu-window* (bibtex-Booklet))))
+  ("Master's Thesis"
+   (lambda () (eval-in-window *menu-window* (bibtex-MastersThesis))))
+  ;;("DEA Thesis" bibtex-DEAthesis)
+  ("PhD. Thesis"
+   (lambda () (eval-in-window *menu-window* (bibtex-PhdThesis))))
+  ("Technical Report"
+   (lambda () (eval-in-window *menu-window* (bibtex-TechReport))))
+  ("Technical Manual"
+   (lambda () (eval-in-window *menu-window* (bibtex-Manual))))
+  ("Conference Proceedings"
+   (lambda () (eval-in-window *menu-window* (bibtex-Proceedings))))
+  ("In A Book"
+   (lambda () (eval-in-window *menu-window* (bibtex-InBook))))
+  ("In A Collection"
+   (lambda () (eval-in-window *menu-window* (bibtex-InCollection))))
+  ("Miscellaneous"
+   (lambda () (eval-in-window *menu-window* (bibtex-Misc))))
+  ("Unpublished"
+   (lambda () (eval-in-window *menu-window* (bibtex-Unpublished)))))
+
+(defmenu bibtex-sun-menu
+  ("BibTeX menu")
+  ("add entry" . bibtex-sun-entry-menu)
+  ("add string"
+   (lambda () (eval-in-window *menu-window* (bibtex-string))))
+  ;("next field" bibtex-next-position)
+  ;("to end of field" bibtex-find-it)
+;  ("remove OPT"
+;   (lambda () (eval-in-window *menu-window* (bibtex-remove-opt))))
+;  ("remove quotes"
+;   (lambda () (eval-in-window *menu-window* (bibtex-remove-double-quotes))))
+;  ("remove this line"
+;   (lambda () (eval-in-window *menu-window* (kill-current-line))))
+  ("describe BibTeX mode"
+   (lambda () (eval-in-window *menu-window* (describe-mode))))
+  ("Main Emacs menu" . emacs-menu))
+ 
+(defun bibtex-sun-menu-eval (window x y)
+  "Pop-up menu of BibTeX commands."
+  (sun-menu-evaluate window (1+ x) (1- y) 'bibtex-sun-menu))
+
+(defun bibtex-sun-environment ()
+  "Set up sun menus for BibTeX mode.  Call it as bibtex-mode-hook, or interactively"
+  (interactive)
+  (local-set-mouse  '(text right) 'bibtex-sun-menu-eval))
+
+))  ; matches (if...
+
+;;; ------------- end bibtex-mode.el -------------------------------