*** empty log message ***

[gnus] / lisp / gnus-score.el

diff --git a/lisp/gnus-score.el b/lisp/gnus-score.el
index 3836528..c56b7e8 100644 (file)
--- a/lisp/gnus-score.el
+++ b/lisp/gnus-score.el
@@ -1,5 +1,5 @@
 ;;; gnus-score.el --- scoring code for Gnus
 ;;; gnus-score.el --- scoring code for Gnus

-;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995,96 Free Software Foundation, Inc.

 
 ;; Author: Per Abrahamsen <amanda@iesd.auc.dk>
 ;;     Lars Magne Ingebrigtsen <larsi@ifi.uio.no>
 
 ;; Author: Per Abrahamsen <amanda@iesd.auc.dk>
 ;;     Lars Magne Ingebrigtsen <larsi@ifi.uio.no>


@@ -18,48 +18,272 @@
 ;; GNU General Public License for more details.
 
 ;; You should have received a copy of the GNU General Public License
 ;; 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.
+;; along with GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.

 
 ;;; Commentary:
 
 ;;; Code:
 
 (require 'gnus)
 
 ;;; Commentary:
 
 ;;; Code:
 
 (require 'gnus)

+(require 'gnus-sum)
+(require 'gnus-range)
+
+(defvar gnus-global-score-files nil
+  "*List of global score files and directories.
+Set this variable if you want to use people's score files.  One entry
+for each score file or each score file directory.  Gnus will decide
+by itself what score files are applicable to which group.
+
+Say you want to use the single score file
+\"/ftp.ifi.uio.no@ftp:/pub/larsi/ding/score/soc.motss.SCORE\" and all
+score files in the \"/ftp.some-where:/pub/score\" directory.
+
+ (setq gnus-global-score-files
+       '(\"/ftp.ifi.uio.no:/pub/larsi/ding/score/soc.motss.SCORE\"
+         \"/ftp.some-where:/pub/score\"))")
+
+(defvar gnus-score-file-single-match-alist nil
+  "*Alist mapping regexps to lists of score files.
+Each element of this alist should be of the form
+       (\"REGEXP\" [ \"SCORE-FILE-1\" ] [ \"SCORE-FILE-2\" ] ... )
+
+If the name of a group is matched by REGEXP, the corresponding scorefiles
+will be used for that group.
+The first match found is used, subsequent matching entries are ignored (to
+use multiple matches, see gnus-score-file-multiple-match-alist).
+
+These score files are loaded in addition to any files returned by
+gnus-score-find-score-files-function (which see).")
+
+(defvar gnus-score-file-multiple-match-alist nil
+  "*Alist mapping regexps to lists of score files.
+Each element of this alist should be of the form
+       (\"REGEXP\" [ \"SCORE-FILE-1\" ] [ \"SCORE-FILE-2\" ] ... )
+
+If the name of a group is matched by REGEXP, the corresponding scorefiles
+will be used for that group.
+If multiple REGEXPs match a group, the score files corresponding to each
+match will be used (for only one match to be used, see
+gnus-score-file-single-match-alist).
+
+These score files are loaded in addition to any files returned by
+gnus-score-find-score-files-function (which see).")
+
+(defvar gnus-score-file-suffix "SCORE"
+  "*Suffix of the score files.")
+
+(defvar gnus-adaptive-file-suffix "ADAPT"
+  "*Suffix of the adaptive score files.")
+
+(defvar gnus-score-find-score-files-function 'gnus-score-find-bnews
+  "*Function used to find score files.
+The function will be called with the group name as the argument, and
+should return a list of score files to apply to that group.  The score
+files do not actually have to exist.
+
+Predefined values are:
+
+gnus-score-find-single: Only apply the group's own score file.
+gnus-score-find-hierarchical: Also apply score files from parent groups.
+gnus-score-find-bnews: Apply score files whose names matches.
+
+See the documentation to these functions for more information.
+
+This variable can also be a list of functions to be called.  Each
+function should either return a list of score files, or a list of
+score alists.")
+
+(defvar gnus-score-interactive-default-score 1000
+  "*Scoring commands will raise/lower the score with this number as the default.")

 
 (defvar gnus-score-expiry-days 7
 
 (defvar gnus-score-expiry-days 7

-  "*Number of days before unused score file entries are expired.")
+  "*Number of days before unused score file entries are expired.
+If this variable is nil, no score file entries will be expired.")
+
+(defvar gnus-update-score-entry-dates t
+  "*In non-nil, update matching score entry dates.
+If this variable is nil, then score entries that provide matches
+will be expired along with non-matching score entries.")

 
 (defvar gnus-orphan-score nil
 
 (defvar gnus-orphan-score nil

-  "*All orphans get this score added. Set in the score file.")
+  "*All orphans get this score added.  Set in the score file.")
+
+(defvar gnus-decay-scores nil
+  "*If non-nil, decay non-permanent scores.")
+
+(defvar gnus-decay-score-function 'gnus-decay-score
+  "*Function called to decay a score.
+It is called with one parameter -- the score to be decayed.")
+
+(defvar gnus-score-decay-constant 3
+  "*Decay all \"small\" scores with this amount.")
+
+(defvar gnus-score-decay-scale .05
+  "*Decay all \"big\" scores with this factor.")
+
+(defvar gnus-home-score-file nil
+  "Variable to control where interactive score entries are to go.
+It can be:
+
+ * A string
+   This file file will be used as the home score file.
+
+ * A function
+   The result of this function will be used as the home score file.
+   The function will be passed the name of the group as its
+   parameter.
+
+ * A list
+   The elements in this list can be:
+
+   * `(regexp file-name ...)'
+     If the `regexp' matches the group name, the first `file-name' will
+     will be used as the home score file.  (Multiple filenames are
+     allowed so that one may use gnus-score-file-single-match-alist to
+     set this variable.)
+
+   * A function.
+     If the function returns non-nil, the result will be used
+     as the home score file.  The function will be passed the 
+     name of the group as its parameter.
+
+   * A string.  Use the string as the home score file.
+
+   The list will be traversed from the beginning towards the end looking
+   for matches.")
+
+(defvar gnus-home-adapt-file nil
+  "Variable to control where new adaptive score entries are to go.
+This variable allows the same syntax as `gnus-home-score-file'.")

 
 (defvar gnus-default-adaptive-score-alist  
   '((gnus-kill-file-mark)
     (gnus-unread-mark)
 
 (defvar gnus-default-adaptive-score-alist  
   '((gnus-kill-file-mark)
     (gnus-unread-mark)

-    (gnus-read-mark (from  3) (subject  30))
+    (gnus-read-mark (from 3) (subject 30))

     (gnus-catchup-mark (subject -10))
     (gnus-killed-mark (from -1) (subject -20))
     (gnus-del-mark (from -2) (subject -15)))
 "*Alist of marks and scores.")
 
     (gnus-catchup-mark (subject -10))
     (gnus-killed-mark (from -1) (subject -20))
     (gnus-del-mark (from -2) (subject -15)))
 "*Alist of marks and scores.")
 

+(defvar gnus-ignored-adaptive-words nil
+  "*List of words to be ignored when doing adaptive word scoring.")
+
+(defvar gnus-default-ignored-adaptive-words
+  '("a" "i" "the" "to" "of" "and" "in" "is" "it" "for" "that" "if" "you"
+    "this" "be" "on" "with" "not" "have" "are" "or" "as" "from" "can"
+    "but" "by" "at" "an" "will" "no" "all" "was" "do" "there" "my" "one"
+    "so" "we" "they" "what" "would" "any" "which" "about" "get" "your"
+    "use" "some" "me" "then" "name" "like" "out" "when" "up" "time"
+    "other" "more" "only" "just" "end" "also" "know" "how" "new" "should"
+    "been" "than" "them" "he" "who" "make" "may" "people" "these" "now"
+    "their" "here" "into" "first" "could" "way" "had" "see" "work" "well"
+    "were" "two" "very" "where" "while" "us" "because" "good" "same"
+    "even" "much" "most" "many" "such" "long" "his" "over" "last" "since"
+    "right" "before" "our" "without" "too" "those" "why" "must" "part"
+    "being" "current" "back" "still" "go" "point" "value" "each" "did"
+    "both" "true" "off" "say" "another" "state" "might" "under" "start"
+    "try" "re")
+  "Default list of words to be ignored when doing adaptive word scoring.")
+
+(defvar gnus-default-adaptive-word-score-alist  
+  `((,gnus-read-mark . 30)
+    (,gnus-catchup-mark . -10)
+    (,gnus-killed-mark . -20)
+    (,gnus-del-mark . -15))
+"*Alist of marks and scores.")
+

 (defvar gnus-score-mimic-keymap nil
   "*Have the score entry functions pretend that they are a keymap.")
 
 (defvar gnus-score-exact-adapt-limit 10
   "*Number that says how long a match has to be before using substring matching.
 When doing adaptive scoring, one normally uses fuzzy or substring
 (defvar gnus-score-mimic-keymap nil
   "*Have the score entry functions pretend that they are a keymap.")
 
 (defvar gnus-score-exact-adapt-limit 10
   "*Number that says how long a match has to be before using substring matching.
 When doing adaptive scoring, one normally uses fuzzy or substring

-matching. However, if the header one matches is short, the possibility
+matching.  However, if the header one matches is short, the possibility

 for false positives is great, so if the length of the match is less
 than this variable, exact matching will be used.
 
 If this variable is nil, exact matching will always be used.")
 
 for false positives is great, so if the length of the match is less
 than this variable, exact matching will be used.
 
 If this variable is nil, exact matching will always be used.")
 

+(defvar gnus-score-uncacheable-files "ADAPT$"
+  "*All score files that match this regexp will not be cached.")
+
+(defvar gnus-score-default-header nil
+  "Default header when entering new scores.
+
+Should be one of the following symbols.
+
+ a: from
+ s: subject
+ b: body
+ h: head
+ i: message-id
+ t: references
+ x: xref
+ l: lines
+ d: date
+ f: followup
+
+If nil, the user will be asked for a header.")
+
+(defvar gnus-score-default-type nil
+  "Default match type when entering new scores.
+
+Should be one of the following symbols.
+
+ s: substring
+ e: exact string
+ f: fuzzy string
+ r: regexp string
+ b: before date
+ a: at date
+ n: this date
+ <: less than number
+ >: greater than number
+ =: equal to number
+
+If nil, the user will be asked for a match type.")
+
+(defvar gnus-score-default-fold nil
+  "Use case folding for new score file entries iff not nil.")
+
+(defvar gnus-score-default-duration nil
+  "Default duration of effect when entering new scores.
+
+Should be one of the following symbols.
+
+ t: temporary
+ p: permanent
+ i: immediate
+
+If nil, the user will be asked for a duration.")
+
+(defvar gnus-score-after-write-file-function nil
+  "*Function called with the name of the score file just written to disk.")
+

 \f
 
 ;; Internal variables.
 
 \f
 
 ;; Internal variables.
 

+(defvar gnus-adaptive-word-syntax-table
+  (let ((table (copy-syntax-table (standard-syntax-table)))
+       (numbers '(?0 ?1 ?2 ?3 ?4 ?5 ?6 ?7 ?8 ?9)))
+    (while numbers
+      (modify-syntax-entry (pop numbers) " " table))
+    (modify-syntax-entry ?' "w" table)
+    table)
+  "Syntax table used when doing adaptive word scoring.")
+
+(defvar gnus-scores-exclude-files nil)
+(defvar gnus-internal-global-score-files nil)
+(defvar gnus-score-file-list nil)
+
+(defvar gnus-short-name-score-file-cache nil)
+

 (defvar gnus-score-help-winconf nil)
 (defvar gnus-adaptive-score-alist gnus-default-adaptive-score-alist)
 (defvar gnus-score-help-winconf nil)
 (defvar gnus-adaptive-score-alist gnus-default-adaptive-score-alist)

+(defvar gnus-adaptive-word-score-alist gnus-default-adaptive-word-score-alist)

 (defvar gnus-score-trace nil)
 (defvar gnus-score-edit-buffer nil)
 
 (defvar gnus-score-trace nil)
 (defvar gnus-score-edit-buffer nil)
 


@@ -73,7 +297,7 @@ expunge: Automatically expunge articles below this.
 files:   List of other score files to load when loading this one.
 eval:    Sexp to be evaluated when the score file is loaded.
 
 files:   List of other score files to load when loading this one.
 eval:    Sexp to be evaluated when the score file is loaded.
 

-String entries have the form (HEADER (MATCH TYPE SCORE DATE) ...) 
+String entries have the form (HEADER (MATCH TYPE SCORE DATE) ...)

 where HEADER is the header being scored, MATCH is the string we are
 looking for, TYPE is a flag indicating whether it should use regexp or
 substring matching, SCORE is the score to add and DATE is the date
 where HEADER is the header being scored, MATCH is the string we are
 looking for, TYPE is a flag indicating whether it should use regexp or
 substring matching, SCORE is the score to add and DATE is the date


@@ -81,32 +305,42 @@ of the last successful match.")
 
 (defvar gnus-score-cache nil)
 (defvar gnus-scores-articles nil)
 
 (defvar gnus-score-cache nil)
 (defvar gnus-scores-articles nil)

-(defvar gnus-scores-exclude-files nil)
-(defvar gnus-header-index nil)

 (defvar gnus-score-index nil)
 
 (defvar gnus-score-index nil)
 

-(eval-and-compile
-  (autoload 'gnus-uu-ctl-map "gnus-uu" nil nil 'keymap)
-  (autoload 'appt-select-lowest-window "appt.el"))

 
 

-;;; Summary mode score maps.
-
-(defvar gnus-summary-score-map nil)
-
-(define-prefix-command 'gnus-summary-score-map)
-(define-key gnus-summary-mode-map "V" 'gnus-summary-score-map)
-(define-key gnus-summary-score-map "s" 'gnus-summary-set-score)
-(define-key gnus-summary-score-map "a" 'gnus-summary-score-entry)
-(define-key gnus-summary-score-map "S" 'gnus-summary-current-score)
-(define-key gnus-summary-score-map "c" 'gnus-score-change-score-file)
-(define-key gnus-summary-score-map "m" 'gnus-score-set-mark-below)
-(define-key gnus-summary-score-map "x" 'gnus-score-set-expunge-below)
-(define-key gnus-summary-score-map "e" 'gnus-score-edit-alist)
-(define-key gnus-summary-score-map "f" 'gnus-score-edit-file)
-(define-key gnus-summary-score-map "t" 'gnus-score-find-trace)
-(define-key gnus-summary-score-map "C" 'gnus-score-customize)
+(defconst gnus-header-index
+  ;; Name to index alist.
+  '(("number" 0 gnus-score-integer)
+    ("subject" 1 gnus-score-string)
+    ("from" 2 gnus-score-string)
+    ("date" 3 gnus-score-date)
+    ("message-id" 4 gnus-score-string)
+    ("references" 5 gnus-score-string)
+    ("chars" 6 gnus-score-integer)
+    ("lines" 7 gnus-score-integer)
+    ("xref" 8 gnus-score-string)
+    ("head" -1 gnus-score-body)
+    ("body" -1 gnus-score-body)
+    ("all" -1 gnus-score-body)
+    ("followup" 2 gnus-score-followup)
+    ("thread" 5 gnus-score-thread)))

 
 

+;;; Summary mode score maps.

 
 

+(gnus-define-keys (gnus-summary-score-map "V" gnus-summary-mode-map)
+  "s" gnus-summary-set-score
+  "a" gnus-summary-score-entry
+  "S" gnus-summary-current-score
+  "c" gnus-score-change-score-file
+  "C" gnus-score-customize
+  "m" gnus-score-set-mark-below
+  "x" gnus-score-set-expunge-below
+  "R" gnus-summary-rescore
+  "e" gnus-score-edit-current-scores
+  "f" gnus-score-edit-file
+  "F" gnus-score-flush-cache
+  "t" gnus-score-find-trace
+  "w" gnus-score-find-favourite-words)

 
 ;; Summary score file commands
 
 
 ;; Summary score file commands
 


@@ -121,6 +355,21 @@ used as score."
   (interactive "P")
   (gnus-summary-increase-score (- (gnus-score-default score))))
 
   (interactive "P")
   (gnus-summary-increase-score (- (gnus-score-default score))))
 

+(defvar gnus-score-default-header nil
+  "*The default header to score on when entering a score rule interactively.")
+
+(defvar gnus-score-default-type nil
+  "*The default score type to use when entering a score rule interactively.")
+
+(defvar gnus-score-default-duration nil
+  "*The default score duration to use on when entering a score rule interactively.")
+
+(defun gnus-score-kill-help-buffer ()
+  (when (get-buffer "*Score Help*")
+    (kill-buffer "*Score Help*")
+    (when gnus-score-help-winconf
+      (set-window-configuration gnus-score-help-winconf))))
+

 (defun gnus-summary-increase-score (&optional score)
   "Make a score entry based on the current article.
 The user will be prompted for header to score on, match type,
 (defun gnus-summary-increase-score (&optional score)
   "Make a score entry based on the current article.
 The user will be prompted for header to score on, match type,


@@ -137,146 +386,155 @@ used as score."
            (?b "body" "" nil body-string)
            (?h "head" "" nil body-string)
            (?i "message-id" nil t string)
            (?b "body" "" nil body-string)
            (?h "head" "" nil body-string)
            (?i "message-id" nil t string)

-           (?t "references" "message-id" t string)
+           (?t "references" "message-id" nil string)

            (?x "xref" nil nil string)
            (?l "lines" nil nil number)
            (?d "date" nil nil date)
            (?x "xref" nil nil string)
            (?l "lines" nil nil number)
            (?d "date" nil nil date)

-           (?f "followup" nil nil string)))
+           (?f "followup" nil nil string)
+           (?T "thread" nil nil string)))

         (char-to-type
          '((?s s "substring" string)
            (?e e "exact string" string)
            (?f f "fuzzy string" string)
            (?r r "regexp string" string)
         (char-to-type
          '((?s s "substring" string)
            (?e e "exact string" string)
            (?f f "fuzzy string" string)
            (?r r "regexp string" string)

-           (?s s "substring" body-string)
-           (?r s "regexp string" body-string)
+           (?z s "substring" body-string)
+           (?p r "regexp string" body-string)

            (?b before "before date" date)
            (?b before "before date" date)

-           (?a at "at date" date) 
+           (?a at "at date" date)

            (?n now "this date" date)
            (?< < "less than number" number)
            (?n now "this date" date)
            (?< < "less than number" number)

-           (?> > "greater than number" number) 
+           (?> > "greater than number" number)

            (?= = "equal to number" number)))
         (char-to-perm
            (?= = "equal to number" number)))
         (char-to-perm

-         (list (list ?t (current-time-string) "temporary") 
+         (list (list ?t (current-time-string) "temporary")

                '(?p perm "permanent") '(?i now "immediate")))
         (mimic gnus-score-mimic-keymap)
                '(?p perm "permanent") '(?i now "immediate")))
         (mimic gnus-score-mimic-keymap)

-        hchar entry temporary tchar pchar end type)
-    ;; First we read the header to score.
-    (while (not hchar)
-      (if mimic
-         (progn 
-           (sit-for 1)
-           (message "%c-" prefix))
-       (message "%s header (%s?): " (if increase "Increase" "Lower")
-                (mapconcat (lambda (s) (char-to-string (car s)))
-                           char-to-header "")))
-      (setq hchar (read-char))
-      (if (not (or (= hchar ??) (= hchar ?\C-h)))
-         ()
-       (setq hchar nil)
-       (gnus-score-insert-help "Match on header" char-to-header 1)))
-
-    (and (get-buffer "*Score Help*")
-        (progn
-          (kill-buffer "*Score Help*")
-          (and gnus-score-help-winconf
-               (set-window-configuration gnus-score-help-winconf))))
-
-    (or (setq entry (assq (downcase hchar) char-to-header))
-       (progn
-         (ding)
-         (setq end t)
-         (if mimic (message "%c %c" prefix hchar) (message ""))))
-    (if (or end (/= (downcase hchar) hchar))
+        (hchar (and gnus-score-default-header 
+                    (aref (symbol-name gnus-score-default-header) 0)))
+        (tchar (and gnus-score-default-type
+                    (aref (symbol-name gnus-score-default-type) 0)))
+        (pchar (and gnus-score-default-duration
+                    (aref (symbol-name gnus-score-default-duration) 0)))
+        entry temporary type match)
+    
+    (unwind-protect

        (progn
        (progn

-         ;; This was a majuscle, so we end reading and set the defaults.
-         (if mimic (message "%c %c" prefix hchar) (message ""))
-         (setq type nil
-               temporary (current-time-string)))
-
-      ;; We continue reading - the type.
-      (while (not tchar)
-       (if mimic
-           (progn
-             (sit-for 1)
-             (message "%c %c-" prefix hchar))
-         (message "%s header '%s' with match type (%s?): "
-                  (if increase "Increase" "Lower")
-                  (nth 1 entry)
-                  (mapconcat (lambda (s) 
-                               (if (eq (nth 4 entry) 
-                                       (nth 3 s))
-                                   (char-to-string (car s))
-                                 ""))
-                             char-to-type "")))
-       (setq tchar (read-char))
-       (if (not (or (= tchar ??) (= tchar ?\C-h)))
-           ()
-         (setq tchar nil)
-         (gnus-score-insert-help "Match type" char-to-type 2)))
-
-      (and (get-buffer "*Score Help*")
-          (progn
-            (and gnus-score-help-winconf
-                 (set-window-configuration gnus-score-help-winconf))
-            (kill-buffer "*Score Help*")))
-      
-      (or (setq type (nth 1 (assq (downcase tchar) char-to-type)))
-         (progn
-           (ding)
+
+         ;; First we read the header to score.
+         (while (not hchar)
+           (if mimic
+               (progn 
+                 (sit-for 1)
+                 (message "%c-" prefix))
+             (message "%s header (%s?): " (if increase "Increase" "Lower")
+                      (mapconcat (lambda (s) (char-to-string (car s)))
+                                 char-to-header "")))
+           (setq hchar (read-char))
+           (when (or (= hchar ??) (= hchar ?\C-h))
+             (setq hchar nil)
+             (gnus-score-insert-help "Match on header" char-to-header 1)))
+
+         (gnus-score-kill-help-buffer)
+         (unless (setq entry (assq (downcase hchar) char-to-header))
+           (if mimic (error "%c %c" prefix hchar) (error "")))
+
+         (when (/= (downcase hchar) hchar)
+           ;; This was a majuscule, so we end reading and set the defaults.

            (if mimic (message "%c %c" prefix hchar) (message ""))
            (if mimic (message "%c %c" prefix hchar) (message ""))

-           (setq end t)))
-      (if (or end (/= (downcase tchar) tchar))
-         (progn
-           ;; It was a majuscle, so we end reading and the the default.
+           (setq tchar (or tchar ?s)
+                 pchar (or pchar ?t)))
+    
+         ;; We continue reading - the type.
+         (while (not tchar)
+           (if mimic
+               (progn
+                 (sit-for 1) (message "%c %c-" prefix hchar))
+             (message "%s header '%s' with match type (%s?): "
+                      (if increase "Increase" "Lower")
+                      (nth 1 entry)
+                      (mapconcat (lambda (s)
+                                   (if (eq (nth 4 entry)
+                                           (nth 3 s))
+                                       (char-to-string (car s))
+                                     ""))
+                                 char-to-type "")))
+           (setq tchar (read-char))
+           (when (or (= tchar ??) (= tchar ?\C-h))
+             (setq tchar nil)
+             (gnus-score-insert-help
+              "Match type"
+              (delq nil
+                    (mapcar (lambda (s)
+                              (if (eq (nth 4 entry)
+                                      (nth 3 s))
+                                  s nil))
+                            char-to-type))
+              2)))
+
+         (gnus-score-kill-help-buffer)
+         (unless (setq type (nth 1 (assq (downcase tchar) char-to-type)))
+           (if mimic (error "%c %c" prefix hchar) (error "")))
+
+         (when (/= (downcase tchar) tchar)
+           ;; It was a majuscule, so we end reading and use the default.

            (if mimic (message "%c %c %c" prefix hchar tchar)
              (message ""))
            (if mimic (message "%c %c %c" prefix hchar tchar)
              (message ""))

-           (setq temporary (current-time-string)))
-
-       ;; We continue reading.
-       (while (not pchar)
-         (if mimic
-             (progn
-               (sit-for 1)
-               (message "%c %c %c-" prefix hchar tchar))
-           (message "%s permanence (%s?): " (if increase "Increase" "Lower")
-                    (mapconcat (lambda (s) (char-to-string (car s)))
-                               char-to-perm "")))
-         (setq pchar (read-char))
-         (if (not (or (= pchar ??) (= pchar ?\C-h)))
-             ()
-           (setq pchar nil)
-           (gnus-score-insert-help "Match permanence" char-to-perm 2)))
-
-       (and (get-buffer "*Score Help*")
-            (progn
-              (and gnus-score-help-winconf
-                   (set-window-configuration gnus-score-help-winconf))
-              (kill-buffer "*Score Help*")))
-
-       (if mimic (message "%c %c %c" prefix hchar tchar pchar)
-         (message ""))
-       (if (setq temporary (nth 1 (assq pchar char-to-perm)))
-           ()
-         (ding)
-         (setq end t)
-         (if mimic 
-             (message "%c %c %c %c" prefix hchar tchar pchar)
-           (message "")))))
+           (setq pchar (or pchar ?p)))
+
+         ;; We continue reading.
+         (while (not pchar)
+           (if mimic
+               (progn
+                 (sit-for 1) (message "%c %c %c-" prefix hchar tchar))
+             (message "%s permanence (%s?): " (if increase "Increase" "Lower")
+                      (mapconcat (lambda (s) (char-to-string (car s)))
+                                 char-to-perm "")))
+           (setq pchar (read-char))
+           (when (or (= pchar ??) (= pchar ?\C-h))
+             (setq pchar nil)
+             (gnus-score-insert-help "Match permanence" char-to-perm 2)))
+
+         (gnus-score-kill-help-buffer)
+         (if mimic (message "%c %c %c" prefix hchar tchar pchar)
+           (message ""))
+         (unless (setq temporary (cadr (assq pchar char-to-perm)))
+           ;; Deal with der(r)ided superannuated paradigms.
+           (when (and (eq (1+ prefix) 77)
+                      (eq (+ hchar 12) 109)
+                      (eq tchar 114)
+                      (eq (- pchar 4) 111))
+             (error "You rang?"))
+           (if mimic 
+               (error "%c %c %c %c" prefix hchar tchar pchar)
+             (error ""))))
+      ;; Always kill the score help buffer.
+      (gnus-score-kill-help-buffer))

 
     ;; We have all the data, so we enter this score.
 
     ;; We have all the data, so we enter this score.

-    (if end
-       ()
-      (gnus-summary-score-entry
-       (nth 1 entry)                   ; Header
-       (if (string= (nth 2 entry) "") ""
-        (gnus-summary-header (or (nth 2 entry) (nth 1 entry)))) ; Match
-       type                            ; Type
-       (if (eq 's score) nil score)     ; Score
-       (if (eq 'perm temporary)         ; Temp
-           nil
-         temporary)
-       (not (nth 3 entry)))            ; Prompt
-      )))
+    (setq match (if (string= (nth 2 entry) "") ""
+                 (gnus-summary-header (or (nth 2 entry) (nth 1 entry)))))
+      
+    ;; Modify the match, perhaps.
+    (cond 
+     ((equal (nth 1 entry) "xref")
+      (when (string-match "^Xref: *" match)
+       (setq match (substring match (match-end 0))))
+      (when (string-match "^[^:]* +" match)
+       (setq match (substring match (match-end 0))))))
+    
+    (when (memq type '(r R regexp Regexp))
+      (setq match (regexp-quote match)))
+
+    (gnus-summary-score-entry
+     (nth 1 entry)                     ; Header
+     match                             ; Match
+     type                              ; Type
+     (if (eq score 's) nil score)      ; Score
+     (if (eq temporary 'perm)          ; Temp
+        nil
+       temporary)
+     (not (nth 3 entry)))              ; Prompt
+    ))

   
 (defun gnus-score-insert-help (string alist idx)
   (setq gnus-score-help-winconf (current-window-configuration))
   
 (defun gnus-score-insert-help (string alist idx)
   (setq gnus-score-help-winconf (current-window-configuration))


@@ -293,12 +551,12 @@ used as score."
       ;; find the longest string to display
       (while list
        (setq n (length (nth idx (car list))))
       ;; find the longest string to display
       (while list
        (setq n (length (nth idx (car list))))

-       (or (> max n)
-           (setq max n))
+       (unless (> max n)
+         (setq max n))

        (setq list (cdr list)))
       (setq max (+ max 4))             ; %c, `:', SPACE, a SPACE at end
        (setq list (cdr list)))
       (setq max (+ max 4))             ; %c, `:', SPACE, a SPACE at end

-      (setq n (/ (window-width) max))  ; items per line
-      (setq width (/ (window-width) n)) ; width of each item
+      (setq n (/ (1- (window-width)) max)) ; items per line
+      (setq width (/ (1- (window-width)) n)) ; width of each item

       ;; insert `n' items, each in a field of width `width' 
       (while alist
        (if (< i n)
       ;; insert `n' items, each in a field of width `width' 
       (while alist
        (if (< i n)


@@ -308,14 +566,15 @@ used as score."
          (insert "\n"))
        (setq pad (- width 3))
        (setq format (concat "%c: %-" (int-to-string pad) "s"))
          (insert "\n"))
        (setq pad (- width 3))
        (setq format (concat "%c: %-" (int-to-string pad) "s"))

-       (insert (format format (car (car alist)) (nth idx (car alist))))
+       (insert (format format (caar alist) (nth idx (car alist))))

        (setq alist (cdr alist))
        (setq i (1+ i))))
     ;; display ourselves in a small window at the bottom
        (setq alist (cdr alist))
        (setq i (1+ i))))
     ;; display ourselves in a small window at the bottom

-    (appt-select-lowest-window)
+    (gnus-appt-select-lowest-window)

     (split-window)
     (pop-to-buffer "*Score Help*")
     (split-window)
     (pop-to-buffer "*Score Help*")

-    (shrink-window-if-larger-than-buffer)
+    (let ((window-min-height 1))
+      (shrink-window-if-larger-than-buffer))

     (select-window (get-buffer-window gnus-summary-buffer))))
   
 (defun gnus-summary-header (header &optional no-err)
     (select-window (get-buffer-window gnus-summary-buffer))))
   
 (defun gnus-summary-header (header &optional no-err)


@@ -323,7 +582,7 @@ used as score."
   (let ((article (gnus-summary-article-number))
        headers)
     (if article
   (let ((article (gnus-summary-article-number))
        headers)
     (if article

-       (if (and (setq headers (gnus-get-header-by-number article))
+       (if (and (setq headers (gnus-summary-article-header article))

                 (vectorp headers))
            (aref headers (nth 1 (assoc header gnus-header-index)))
          (if no-err
                 (vectorp headers))
            (aref headers (nth 1 (assoc header gnus-header-index)))
          (if no-err


@@ -333,8 +592,25 @@ used as score."
          (error "No article on current line")
        nil))))
 
          (error "No article on current line")
        nil))))
 

-(defun gnus-summary-score-entry 
-  (header match type score date &optional prompt silent)
+(defun gnus-newsgroup-score-alist ()
+  (or
+   (let ((param-file (gnus-group-find-parameter 
+                     gnus-newsgroup-name 'score-file)))
+     (when param-file
+       (gnus-score-load param-file)))
+   (gnus-score-load
+    (gnus-score-file-name gnus-newsgroup-name)))
+  gnus-score-alist)
+
+(defsubst gnus-score-get (symbol &optional alist)
+  ;; Get SYMBOL's definition in ALIST.
+  (cdr (assoc symbol 
+             (or alist 
+                 gnus-score-alist
+                 (gnus-newsgroup-score-alist)))))
+
+(defun gnus-summary-score-entry (header match type score date
+                                       &optional prompt silent)

   "Enter score file entry.
 HEADER is the header being scored.
 MATCH is the string we are looking for.
   "Enter score file entry.
 HEADER is the header being scored.
 MATCH is the string we are looking for.


@@ -358,66 +634,80 @@ If optional argument `SILENT' is nil, show effect of score entry."
                (current-time-string))
               (t nil))))
   ;; Regexp is the default type.
                (current-time-string))
               (t nil))))
   ;; Regexp is the default type.

-  (if (eq type t) (setq type 'r))
+  (when (eq type t)
+    (setq type 'r))

   ;; Simplify matches...
   (cond ((or (eq type 'r) (eq type 's) (eq type nil))
         (setq match (if match (gnus-simplify-subject-re match) "")))
        ((eq type 'f)
         (setq match (gnus-simplify-subject-fuzzy match))))
   (let ((score (gnus-score-default score))
   ;; Simplify matches...
   (cond ((or (eq type 'r) (eq type 's) (eq type nil))
         (setq match (if match (gnus-simplify-subject-re match) "")))
        ((eq type 'f)
         (setq match (gnus-simplify-subject-fuzzy match))))
   (let ((score (gnus-score-default score))

-       (header (downcase header)))
-    (and prompt (setq match (read-string 
-                            (format "Match %s on %s, %s: " 
-                                    (cond ((eq date 'now)
-                                           "now")
-                                          ((stringp date)
-                                           "temp")
-                                          (t "permanent"))
-                                    header
-                                    (if (< score 0) "lower" "raise"))
-                            (if (numberp match)
-                                (int-to-string match)
-                              match))))
-    (and (>= (nth 1 (assoc header gnus-header-index)) 0)
-        (eq (nth 2 (assoc header gnus-header-index)) 'gnus-score-string)
-        (not silent)
-        (gnus-summary-score-effect header match type score))
+       (header (format "%s" (downcase header)))
+       new)
+    (when prompt
+      (setq match (read-string 
+                  (format "Match %s on %s, %s: " 
+                          (cond ((eq date 'now)
+                                 "now")
+                                ((stringp date)
+                                 "temp")
+                                (t "permanent"))
+                          header
+                          (if (< score 0) "lower" "raise"))
+                  (if (numberp match)
+                      (int-to-string match)
+                    match))))
+
+    ;; Get rid of string props.
+    (setq match (format "%s" match))

 
     ;; If this is an integer comparison, we transform from string to int. 
 
     ;; If this is an integer comparison, we transform from string to int. 

-    (and (eq (nth 2 (assoc header gnus-header-index)) 'gnus-score-integer)
-        (setq match (string-to-int match)))
-
-    (if (eq date 'now)
-       ()
-      (and (= score gnus-score-interactive-default-score)
-          (setq score nil))
-      (let ((new (cond 
-                 (type
-                  (list match score (and date (gnus-day-number date)) type))
-                 (date
-                  (list match score (gnus-day-number date)))
-                 (score
-                  (list match score))
-                 (t
-                  (list match))))
-           (old (gnus-score-get header))
+    (when (eq (nth 2 (assoc header gnus-header-index)) 'gnus-score-integer)
+      (setq match (string-to-int match)))
+
+    (unless (eq date 'now)
+      ;; Add the score entry to the score file.
+      (when (= score gnus-score-interactive-default-score)
+       (setq score nil))
+      (let ((old (gnus-score-get header))

            elem)
            elem)

+       (setq new
+             (cond 
+              (type
+               (list match score
+                     (and date (if (numberp date) date
+                                 (gnus-day-number date)))
+                     type))
+              (date (list match score (gnus-day-number date)))
+              (score (list match score))
+              (t (list match))))

        ;; We see whether we can collapse some score entries.
        ;; This isn't quite correct, because there may be more elements
        ;; We see whether we can collapse some score entries.
        ;; This isn't quite correct, because there may be more elements

-       ;; later on with the same key that have matching elems... Hm.
+       ;; later on with the same key that have matching elems...  Hm.

        (if (and old
                 (setq elem (assoc match old))
                 (eq (nth 3 elem) (nth 3 new))
                 (or (and (numberp (nth 2 elem)) (numberp (nth 2 new)))
                     (and (not (nth 2 elem)) (not (nth 2 new)))))
            ;; Yup, we just add this new score to the old elem.
        (if (and old
                 (setq elem (assoc match old))
                 (eq (nth 3 elem) (nth 3 new))
                 (or (and (numberp (nth 2 elem)) (numberp (nth 2 new)))
                     (and (not (nth 2 elem)) (not (nth 2 new)))))
            ;; Yup, we just add this new score to the old elem.

-           (setcar (cdr elem) (+ (or (nth 1 elem) 
+           (setcar (cdr elem) (+ (or (nth 1 elem)

                                      gnus-score-interactive-default-score)
                                  (or (nth 1 new)
                                      gnus-score-interactive-default-score)))
          ;; Nope, we have to add a new elem.
                                      gnus-score-interactive-default-score)
                                  (or (nth 1 new)
                                      gnus-score-interactive-default-score)))
          ;; Nope, we have to add a new elem.

-         (gnus-score-set header (if old (cons new old) (list new)))))
-      (gnus-score-set 'touched '(t)))))
+         (gnus-score-set header (if old (cons new old) (list new))))
+       (gnus-score-set 'touched '(t))))
+
+    ;; Score the current buffer.
+    (unless silent
+      (if (and (>= (nth 1 (assoc header gnus-header-index)) 0)
+              (eq (nth 2 (assoc header gnus-header-index))
+                  'gnus-score-string))
+         (gnus-summary-score-effect header match type score)
+       (gnus-summary-rescore)))
+
+    ;; Return the new scoring rule.
+    new))

 
 (defun gnus-summary-score-effect (header match type score)
   "Simulate the effect of a score file entry.
 
 (defun gnus-summary-score-effect (header match type score)
   "Simulate the effect of a score file entry.


@@ -433,22 +723,26 @@ SCORE is the score to add."
                     (y-or-n-p "Use regexp match? ")
                     (prefix-numeric-value current-prefix-arg)))
   (save-excursion
                     (y-or-n-p "Use regexp match? ")
                     (prefix-numeric-value current-prefix-arg)))
   (save-excursion

-    (or (and (stringp match) (> (length match) 0))
-       (error "No match"))
+    (unless (and (stringp match) (> (length match) 0))
+      (error "No match"))

     (goto-char (point-min))
     (let ((regexp (cond ((eq type 'f)
                         (gnus-simplify-subject-fuzzy match))
     (goto-char (point-min))
     (let ((regexp (cond ((eq type 'f)
                         (gnus-simplify-subject-fuzzy match))

-                       (type match)
-                       (t (concat "\\`.*" (regexp-quote match) ".*\\'")))))
+                       ((eq type 'r)
+                        match)
+                       ((eq type 'e)
+                        (concat "\\`" (regexp-quote match) "\\'"))
+                       (t 
+                        (regexp-quote match)))))

       (while (not (eobp))
        (let ((content (gnus-summary-header header 'noerr))
              (case-fold-search t))
          (and content
       (while (not (eobp))
        (let ((content (gnus-summary-header header 'noerr))
              (case-fold-search t))
          (and content

-              (if (if (eq type 'f)
-                      (string-equal (gnus-simplify-subject-fuzzy content)
-                                    regexp)
-                    (string-match regexp content))
-                  (gnus-summary-raise-score score))))
+              (when (if (eq type 'f)
+                        (string-equal (gnus-simplify-subject-fuzzy content)
+                                      regexp)
+                      (string-match regexp content))
+                (gnus-summary-raise-score score))))

        (beginning-of-line 2)))))
 
 (defun gnus-summary-score-crossposting (score date)
        (beginning-of-line 2)))))
 
 (defun gnus-summary-score-crossposting (score date)


@@ -458,15 +752,16 @@ SCORE is the score to add."
   (let ((xref (gnus-summary-header "xref"))
        (start 0)
        group)
   (let ((xref (gnus-summary-header "xref"))
        (start 0)
        group)

-    (or xref (error "This article is not crossposted"))
+    (unless xref
+      (error "This article is not crossposted"))

     (while (string-match " \\([^ \t]+\\):" xref start)
       (setq start (match-end 0))
     (while (string-match " \\([^ \t]+\\):" xref start)
       (setq start (match-end 0))

-      (if (not (string= 
-               (setq group 
-                     (substring xref (match-beginning 1) (match-end 1)))
-               gnus-newsgroup-name))
-         (gnus-summary-score-entry
-          "xref" (concat " " group ":") nil score date t)))))
+      (when (not (string= 
+                 (setq group 
+                       (substring xref (match-beginning 1) (match-end 1)))
+                 gnus-newsgroup-name))
+       (gnus-summary-score-entry
+        "xref" (concat " " group ":") nil score date t)))))

 
 \f
 ;;;
 
 \f
 ;;;


@@ -485,25 +780,76 @@ SCORE is the score to add."
   (gnus-score-set 'mark (list score))
   (gnus-score-set 'touched '(t))
   (setq gnus-summary-mark-below score)
   (gnus-score-set 'mark (list score))
   (gnus-score-set 'touched '(t))
   (setq gnus-summary-mark-below score)

-  (gnus-summary-update-lines))
+  (gnus-score-update-lines))
+
+(defun gnus-score-update-lines ()
+  "Update all lines in the summary buffer."
+  (save-excursion
+    (goto-char (point-min))
+    (while (not (eobp))
+      (gnus-summary-update-line)
+      (forward-line 1))))
+
+(defun gnus-score-update-all-lines ()
+  "Update all lines in the summary buffer, even the hidden ones."
+  (save-excursion
+    (goto-char (point-min))
+    (let (hidden)
+      (while (not (eobp))
+       (when (gnus-summary-show-thread)
+         (push (point) hidden))
+       (gnus-summary-update-line)
+       (forward-line 1))
+      ;; Re-hide the hidden threads.
+      (while hidden
+       (goto-char (pop hidden))
+       (gnus-summary-hide-thread)))))

 
 (defun gnus-score-set-expunge-below (score)
   "Automatically expunge articles with score below SCORE."
   (interactive 
    (list (or (and current-prefix-arg (prefix-numeric-value current-prefix-arg))
 
 (defun gnus-score-set-expunge-below (score)
   "Automatically expunge articles with score below SCORE."
   (interactive 
    (list (or (and current-prefix-arg (prefix-numeric-value current-prefix-arg))

-            (string-to-int (read-string "Expunge below: ")))))
+            (string-to-int (read-string "Set expunge below: ")))))

   (setq score (or score gnus-summary-default-score 0))
   (gnus-score-set 'expunge (list score))
   (gnus-score-set 'touched '(t)))
 
   (setq score (or score gnus-summary-default-score 0))
   (gnus-score-set 'expunge (list score))
   (gnus-score-set 'touched '(t)))
 

+(defun gnus-score-followup-article (&optional score)
+  "Add SCORE to all followups to the article in the current buffer."
+  (interactive "P")
+  (setq score (gnus-score-default score))
+  (when (gnus-buffer-live-p gnus-summary-buffer)
+    (save-excursion
+      (save-restriction
+       (message-narrow-to-headers)
+       (let ((id (mail-fetch-field "message-id")))
+         (when id
+           (set-buffer gnus-summary-buffer)
+           (gnus-summary-score-entry
+            "references" (concat id "[ \t]*$") 'r
+            score (current-time-string) nil t)))))))
+
+(defun gnus-score-followup-thread (&optional score)
+  "Add SCORE to all later articles in the thread the current buffer is part of."
+  (interactive "P")
+  (setq score (gnus-score-default score))
+  (when (gnus-buffer-live-p gnus-summary-buffer)
+    (save-excursion
+      (save-restriction
+       (goto-char (point-min))
+       (let ((id (mail-fetch-field "message-id")))
+         (when id
+           (set-buffer gnus-summary-buffer)
+           (gnus-summary-score-entry
+            "references" id 's
+            score (current-time-string))))))))
+

 (defun gnus-score-set (symbol value &optional alist)
   ;; Set SYMBOL to VALUE in ALIST.
   (let* ((alist 
          (or alist 
              gnus-score-alist
 (defun gnus-score-set (symbol value &optional alist)
   ;; Set SYMBOL to VALUE in ALIST.
   (let* ((alist 
          (or alist 
              gnus-score-alist

-             (progn
-               (gnus-score-load (gnus-score-file-name gnus-newsgroup-name))
-               gnus-score-alist)))
+             (gnus-newsgroup-score-alist)))

         (entry (assoc symbol alist)))
     (cond ((gnus-score-get 'read-only alist)
           ;; This is a read-only score file, so we do nothing.
         (entry (assoc symbol alist)))
     (cond ((gnus-score-get 'read-only alist)
           ;; This is a read-only score file, so we do nothing.


@@ -516,62 +862,91 @@ SCORE is the score to add."
           (setcdr alist
                   (cons (cons symbol value) (cdr alist)))))))
 
           (setcdr alist
                   (cons (cons symbol value) (cdr alist)))))))
 

-(defun gnus-score-get (symbol &optional alist)
-  ;; Get SYMBOL's definition in ALIST.
-  (cdr (assoc symbol 
-             (or alist 
-                 gnus-score-alist
-                 (progn
-                   (gnus-score-load 
-                    (gnus-score-file-name gnus-newsgroup-name))
-                   gnus-score-alist)))))
+(defun gnus-summary-raise-score (n)
+  "Raise the score of the current article by N."
+  (interactive "p")
+  (gnus-set-global-variables)
+  (gnus-summary-set-score (+ (gnus-summary-article-score)
+                            (or n gnus-score-interactive-default-score ))))
+
+(defun gnus-summary-set-score (n)
+  "Set the score of the current article to N."
+  (interactive "p")
+  (gnus-set-global-variables)
+  (save-excursion
+    (gnus-summary-show-thread)
+    (let ((buffer-read-only nil))
+      ;; Set score.
+      (gnus-summary-update-mark
+       (if (= n (or gnus-summary-default-score 0)) ? 
+        (if (< n (or gnus-summary-default-score 0))
+            gnus-score-below-mark gnus-score-over-mark))
+       'score))
+    (let* ((article (gnus-summary-article-number))
+          (score (assq article gnus-newsgroup-scored)))
+      (if score (setcdr score n)
+       (push (cons article n) gnus-newsgroup-scored)))
+    (gnus-summary-update-line)))
+
+(defun gnus-summary-current-score ()
+  "Return the score of the current article."
+  (interactive)
+  (gnus-set-global-variables)
+  (gnus-message 1 "%s" (gnus-summary-article-score)))

 
 (defun gnus-score-change-score-file (file)
   "Change current score alist."
   (interactive 
 
 (defun gnus-score-change-score-file (file)
   "Change current score alist."
   (interactive 

-   (list (read-file-name "Edit score file: " gnus-kill-files-directory)))
+   (list (read-file-name "Change to score file: " gnus-kill-files-directory)))

   (gnus-score-load-file file)
   (gnus-set-mode-line 'summary))
 
   (gnus-score-load-file file)
   (gnus-set-mode-line 'summary))
 

-(defun gnus-score-edit-alist (file)
+(defvar gnus-score-edit-exit-function)
+(defun gnus-score-edit-current-scores (file)

   "Edit the current score alist."
   (interactive (list gnus-current-score-file))
   (let ((winconf (current-window-configuration)))
   "Edit the current score alist."
   (interactive (list gnus-current-score-file))
   (let ((winconf (current-window-configuration)))

-    (and (buffer-name gnus-summary-buffer) (gnus-score-save))
+    (when (buffer-name gnus-summary-buffer)
+      (gnus-score-save))
+    (gnus-make-directory (file-name-directory file))

     (setq gnus-score-edit-buffer (find-file-noselect file))
     (gnus-configure-windows 'edit-score)
     (gnus-score-mode)
     (setq gnus-score-edit-buffer (find-file-noselect file))
     (gnus-configure-windows 'edit-score)
     (gnus-score-mode)

+    (setq gnus-score-edit-exit-function 'gnus-score-edit-done)

     (make-local-variable 'gnus-prev-winconf)
     (setq gnus-prev-winconf winconf))
   (gnus-message 
    4 (substitute-command-keys 
     (make-local-variable 'gnus-prev-winconf)
     (setq gnus-prev-winconf winconf))
   (gnus-message 
    4 (substitute-command-keys 

-      "\\<gnus-score-mode-map>\\[gnus-score-edit-done] to save edits")))
+      "\\<gnus-score-mode-map>\\[gnus-score-edit-exit] to save edits")))

   
 (defun gnus-score-edit-file (file)
   "Edit a score file."
   (interactive 
    (list (read-file-name "Edit score file: " gnus-kill-files-directory)))
   
 (defun gnus-score-edit-file (file)
   "Edit a score file."
   (interactive 
    (list (read-file-name "Edit score file: " gnus-kill-files-directory)))

-  (and (buffer-name gnus-summary-buffer) (gnus-score-save))
+  (gnus-make-directory (file-name-directory file))
+  (when (buffer-name gnus-summary-buffer)
+    (gnus-score-save))

   (let ((winconf (current-window-configuration)))
     (setq gnus-score-edit-buffer (find-file-noselect file))
     (gnus-configure-windows 'edit-score)
     (gnus-score-mode)
   (let ((winconf (current-window-configuration)))
     (setq gnus-score-edit-buffer (find-file-noselect file))
     (gnus-configure-windows 'edit-score)
     (gnus-score-mode)

+    (setq gnus-score-edit-exit-function 'gnus-score-edit-done)

     (make-local-variable 'gnus-prev-winconf)
     (setq gnus-prev-winconf winconf))
   (gnus-message 
    4 (substitute-command-keys 
     (make-local-variable 'gnus-prev-winconf)
     (setq gnus-prev-winconf winconf))
   (gnus-message 
    4 (substitute-command-keys 

-      "\\<gnus-score-mode-map>\\[gnus-score-edit-done] to save edits")))
+      "\\<gnus-score-mode-map>\\[gnus-score-edit-exit] to save edits")))

   
 (defun gnus-score-load-file (file)
   ;; Load score file FILE.  Returns a list a retrieved score-alists.
   
 (defun gnus-score-load-file (file)
   ;; Load score file FILE.  Returns a list a retrieved score-alists.

-  (setq gnus-kill-files-directory (or gnus-kill-files-directory "~/News/"))

   (let* ((file (expand-file-name 
                (or (and (string-match
                          (concat "^" (expand-file-name
   (let* ((file (expand-file-name 
                (or (and (string-match
                          (concat "^" (expand-file-name

-                                      gnus-kill-files-directory)) 
+                                      gnus-kill-files-directory))

                          (expand-file-name file))
                         file)
                          (expand-file-name file))
                         file)

-                   (concat gnus-kill-files-directory file))))
+                   (concat (file-name-as-directory gnus-kill-files-directory)
+                           file))))

         (cached (assoc file gnus-score-cache))
         (global (member file gnus-internal-global-score-files))
         lists alist)
         (cached (assoc file gnus-score-cache))
         (global (member file gnus-internal-global-score-files))
         lists alist)


@@ -583,18 +958,25 @@ SCORE is the score to add."
       (setq alist (gnus-score-load-score-alist file))
       ;; We add '(touched) to the alist to signify that it hasn't been
       ;; touched (yet). 
       (setq alist (gnus-score-load-score-alist file))
       ;; We add '(touched) to the alist to signify that it hasn't been
       ;; touched (yet). 

-      (or (assq 'touched alist) (setq alist (cons (list 'touched nil) alist)))
+      (unless (assq 'touched alist)
+       (push (list 'touched nil) alist))

       ;; If it is a global score file, we make it read-only.
       (and global
           (not (assq 'read-only alist))
       ;; If it is a global score file, we make it read-only.
       (and global
           (not (assq 'read-only alist))

-          (setq alist (cons (list 'read-only t) alist)))
-      ;; Update cache.
-      (setq gnus-score-cache
-           (cons (cons file alist) gnus-score-cache)))
-    ;; If there are actual scores in the alist, we add it to the
-    ;; return value of this function.
-    (if (memq t (mapcar (lambda (e) (stringp (car e))) alist))
-       (setq lists (list alist)))
+          (push (list 'read-only t) alist))
+      (push (cons file alist) gnus-score-cache))
+    (let ((a alist)
+         found)
+      (while a
+       ;; Downcase all header names.
+       (when (stringp (caar a))
+         (setcar (car a) (downcase (caar a)))
+         (setq found t))
+       (pop a))
+      ;; If there are actual scores in the alist, we add it to the
+      ;; return value of this function.
+      (when found
+       (setq lists (list alist))))

     ;; Treat the other possible atoms in the score alist.
     (let ((mark (car (gnus-score-get 'mark alist)))
          (expunge (car (gnus-score-get 'expunge alist)))
     ;; Treat the other possible atoms in the score alist.
     (let ((mark (car (gnus-score-get 'mark alist)))
          (expunge (car (gnus-score-get 'expunge alist)))


@@ -603,29 +985,48 @@ SCORE is the score to add."
          (exclude-files (gnus-score-get 'exclude-files alist))
           (orphan (car (gnus-score-get 'orphan alist)))
          (adapt (gnus-score-get 'adapt alist))
          (exclude-files (gnus-score-get 'exclude-files alist))
           (orphan (car (gnus-score-get 'orphan alist)))
          (adapt (gnus-score-get 'adapt alist))

+         (thread-mark-and-expunge
+          (car (gnus-score-get 'thread-mark-and-expunge alist)))
+         (adapt-file (car (gnus-score-get 'adapt-file alist)))

          (local (gnus-score-get 'local alist))
          (local (gnus-score-get 'local alist))

+         (decay (car (gnus-score-get 'decay alist)))

          (eval (car (gnus-score-get 'eval alist))))
          (eval (car (gnus-score-get 'eval alist))))

+      ;; Perform possible decays.
+      (when (and gnus-decay-scores
+                (gnus-decay-scores 
+                 alist (or decay (gnus-time-to-day (current-time)))))
+       (gnus-score-set 'touched '(t) alist)
+       (gnus-score-set 'decay (list (gnus-time-to-day (current-time)))))

       ;; We do not respect eval and files atoms from global score
       ;; files. 
       (and files (not global)
           (setq lists (apply 'append lists
                              (mapcar (lambda (file)
       ;; We do not respect eval and files atoms from global score
       ;; files. 
       (and files (not global)
           (setq lists (apply 'append lists
                              (mapcar (lambda (file)

-                                       (gnus-score-load-file file)) 
-                                     files))))
+                                       (gnus-score-load-file file))
+                                     (if adapt-file (cons adapt-file files)
+                                       files)))))

       (and eval (not global) (eval eval))
       (and eval (not global) (eval eval))

-      (setq gnus-scores-exclude-files exclude-files)
+      ;; We then expand any exclude-file directives.
+      (setq gnus-scores-exclude-files 
+           (nconc 
+            (mapcar 
+             (lambda (sfile)
+               (expand-file-name sfile (file-name-directory file)))
+             exclude-files)
+            gnus-scores-exclude-files))

       (if (not local)
          ()
        (save-excursion
          (set-buffer gnus-summary-buffer)
          (while local
            (and (consp (car local))
       (if (not local)
          ()
        (save-excursion
          (set-buffer gnus-summary-buffer)
          (while local
            (and (consp (car local))

-                (symbolp (car (car local)))
+                (symbolp (caar local))

                 (progn
                 (progn

-                  (make-local-variable (car (car local)))
-                  (set (car (car local)) (nth 1 (car local)))))
+                  (make-local-variable (caar local))
+                  (set (caar local) (nth 1 (car local)))))

            (setq local (cdr local)))))
            (setq local (cdr local)))))

-      (if orphan (setq gnus-orphan-score orphan))
+      (when orphan
+       (setq gnus-orphan-score orphan))

       (setq gnus-adaptive-score-alist
            (cond ((equal adapt '(t))
                   (setq gnus-newsgroup-adaptive t)
       (setq gnus-adaptive-score-alist
            (cond ((equal adapt '(t))
                   (setq gnus-newsgroup-adaptive t)


@@ -638,10 +1039,14 @@ SCORE is the score to add."
                  (t
                   ;;(setq gnus-newsgroup-adaptive gnus-use-adaptive-scoring)
                   gnus-default-adaptive-score-alist)))
                  (t
                   ;;(setq gnus-newsgroup-adaptive gnus-use-adaptive-scoring)
                   gnus-default-adaptive-score-alist)))

+      (setq gnus-thread-expunge-below 
+           (or thread-mark-and-expunge gnus-thread-expunge-below))

       (setq gnus-summary-mark-below 
            (or mark mark-and-expunge gnus-summary-mark-below))
       (setq gnus-summary-expunge-below 
       (setq gnus-summary-mark-below 
            (or mark mark-and-expunge gnus-summary-mark-below))
       (setq gnus-summary-expunge-below 

-           (or expunge mark-and-expunge gnus-summary-expunge-below)))
+           (or expunge mark-and-expunge gnus-summary-expunge-below))
+      (setq gnus-newsgroup-adaptive-score-file 
+           (or adapt-file gnus-newsgroup-adaptive-score-file)))

     (setq gnus-current-score-file file)
     (setq gnus-score-alist alist)
     lists))
     (setq gnus-current-score-file file)
     (setq gnus-score-alist alist)
     lists))


@@ -653,42 +1058,42 @@ SCORE is the score to add."
        (setq gnus-score-alist (cdr cache))
       (setq gnus-score-alist nil)
       (gnus-score-load-score-alist file)
        (setq gnus-score-alist (cdr cache))
       (setq gnus-score-alist nil)
       (gnus-score-load-score-alist file)

-      (or gnus-score-alist
-         (setq gnus-score-alist (copy-alist '((touched nil)))))
-      (setq gnus-score-cache
-           (cons (cons file gnus-score-alist) gnus-score-cache)))))
+      (unless gnus-score-alist
+       (setq gnus-score-alist (copy-alist '((touched nil)))))
+      (push (cons file gnus-score-alist) gnus-score-cache))))

 
 (defun gnus-score-remove-from-cache (file)
   (setq gnus-score-cache 
        (delq (assoc file gnus-score-cache) gnus-score-cache)))
 
 (defun gnus-score-load-score-alist (file)
 
 (defun gnus-score-remove-from-cache (file)
   (setq gnus-score-cache 
        (delq (assoc file gnus-score-cache) gnus-score-cache)))
 
 (defun gnus-score-load-score-alist (file)

+  "Read score FILE."

   (let (alist)
   (let (alist)

-    (if (file-readable-p file)
-