lisp/gnus/gnus-kill.el

   1 ;;; gnus-kill.el --- kill commands for Gnus
   2
   3 ;; Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
   4 ;;   2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
   5
   6 ;; Author: Masanobu UMEDA <umerin@flab.flab.fujitsu.junet>
   7 ;;      Lars Magne Ingebrigtsen <larsi@gnus.org>
   8 ;; Keywords: news
   9
  10 ;; This file is part of GNU Emacs.
  11
  12 ;; GNU Emacs is free software: you can redistribute it and/or modify
  13 ;; it under the terms of the GNU General Public License as published by
  14 ;; the Free Software Foundation, either version 3 of the License, or
  15 ;; (at your option) any later version.
  16
  17 ;; GNU Emacs is distributed in the hope that it will be useful,
  18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 ;; GNU General Public License for more details.
  21
  22 ;; You should have received a copy of the GNU General Public License
  23 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  24
  25 ;;; Commentary:
  26
  27 ;;; Code:
  28
  29 (eval-when-compile (require 'cl))
  30
  31 (require 'gnus)
  32 (require 'gnus-art)
  33 (require 'gnus-range)
  34
  35 (defcustom gnus-kill-file-mode-hook nil
  36   "Hook for Gnus kill file mode."
  37   :group 'gnus-score-kill
  38   :type 'hook)
  39
  40 (defcustom gnus-kill-expiry-days 7
  41   "*Number of days before expiring unused kill file entries."
  42   :group 'gnus-score-kill
  43   :group 'gnus-score-expire
  44   :type 'integer)
  45
  46 (defcustom gnus-kill-save-kill-file nil
  47   "*If non-nil, will save kill files after processing them."
  48   :group 'gnus-score-kill
  49   :type 'boolean)
  50
  51 (defcustom gnus-winconf-kill-file nil
  52   "What does this do, Lars?
  53 I don't know, Per."
  54   :group 'gnus-score-kill
  55   :type 'sexp)
  56
  57 (defcustom gnus-kill-killed t
  58   "*If non-nil, Gnus will apply kill files to already killed articles.
  59 If it is nil, Gnus will never apply kill files to articles that have
  60 already been through the scoring process, which might very well save lots
  61 of time."
  62   :group 'gnus-score-kill
  63   :type 'boolean)
  64
  65 \f
  66
  67 (defmacro gnus-raise (field expression level)
  68   `(gnus-kill ,field ,expression
  69               (function (gnus-summary-raise-score ,level)) t))
  70
  71 (defmacro gnus-lower (field expression level)
  72   `(gnus-kill ,field ,expression
  73               (function (gnus-summary-raise-score (- ,level))) t))
  74
  75 ;;;
  76 ;;; Gnus Kill File Mode
  77 ;;;
  78
  79 (defvar gnus-kill-file-mode-map nil)
  80
  81 (unless gnus-kill-file-mode-map
  82   (gnus-define-keymap (setq gnus-kill-file-mode-map
  83                             (copy-keymap emacs-lisp-mode-map))
  84     "\C-c\C-k\C-s" gnus-kill-file-kill-by-subject
  85     "\C-c\C-k\C-a" gnus-kill-file-kill-by-author
  86     "\C-c\C-k\C-t" gnus-kill-file-kill-by-thread
  87     "\C-c\C-k\C-x" gnus-kill-file-kill-by-xref
  88     "\C-c\C-a" gnus-kill-file-apply-buffer
  89     "\C-c\C-e" gnus-kill-file-apply-last-sexp
  90     "\C-c\C-c" gnus-kill-file-exit))
  91
  92 (defun gnus-kill-file-mode ()
  93   "Major mode for editing kill files.
  94
  95 If you are using this mode - you probably shouldn't.  Kill files
  96 perform badly and paint with a pretty broad brush.  Score files, on
  97 the other hand, are vastly faster (40x speedup) and give you more
  98 control over what to do.
  99
 100 In addition to Emacs-Lisp Mode, the following commands are available:
 101
 102 \\{gnus-kill-file-mode-map}
 103
 104   A kill file contains Lisp expressions to be applied to a selected
 105 newsgroup.  The purpose is to mark articles as read on the basis of
 106 some set of regexps.  A global kill file is applied to every newsgroup,
 107 and a local kill file is applied to a specified newsgroup.  Since a
 108 global kill file is applied to every newsgroup, for better performance
 109 use a local one.
 110
 111   A kill file can contain any kind of Emacs Lisp expressions expected
 112 to be evaluated in the Summary buffer.  Writing Lisp programs for this
 113 purpose is not so easy because the internal working of Gnus must be
 114 well-known.  For this reason, Gnus provides a general function which
 115 does this easily for non-Lisp programmers.
 116
 117   The `gnus-kill' function executes commands available in Summary Mode
 118 by their key sequences.  `gnus-kill' should be called with FIELD,
 119 REGEXP and optional COMMAND and ALL.  FIELD is a string representing
 120 the header field or an empty string.  If FIELD is an empty string, the
 121 entire article body is searched for.  REGEXP is a string which is
 122 compared with FIELD value.  COMMAND is a string representing a valid
 123 key sequence in Summary mode or Lisp expression.  COMMAND defaults to
 124 '(gnus-summary-mark-as-read nil \"X\").  Make sure that COMMAND is
 125 executed in the Summary buffer.  If the second optional argument ALL
 126 is non-nil, the COMMAND is applied to articles which are already
 127 marked as read or unread.  Articles which are marked are skipped over
 128 by default.
 129
 130   For example, if you want to mark articles of which subjects contain
 131 the string `AI' as read, a possible kill file may look like:
 132
 133         (gnus-kill \"Subject\" \"AI\")
 134
 135   If you want to mark articles with `D' instead of `X', you can use
 136 the following expression:
 137
 138         (gnus-kill \"Subject\" \"AI\" \"d\")
 139
 140 In this example it is assumed that the command
 141 `gnus-summary-mark-as-read-forward' is assigned to `d' in Summary Mode.
 142
 143   It is possible to delete unnecessary headers which are marked with
 144 `X' in a kill file as follows:
 145
 146         (gnus-expunge \"X\")
 147
 148   If the Summary buffer is empty after applying kill files, Gnus will
 149 exit the selected newsgroup normally.  If headers which are marked
 150 with `D' are deleted in a kill file, it is impossible to read articles
 151 which are marked as read in the previous Gnus sessions.  Marks other
 152 than `D' should be used for articles which should really be deleted.
 153
 154 Entry to this mode calls emacs-lisp-mode-hook and
 155 gnus-kill-file-mode-hook with no arguments, if that value is non-nil."
 156   (interactive)
 157   (kill-all-local-variables)
 158   (use-local-map gnus-kill-file-mode-map)
 159   (set-syntax-table emacs-lisp-mode-syntax-table)
 160   (setq major-mode 'gnus-kill-file-mode)
 161   (setq mode-name "Kill")
 162   (lisp-mode-variables nil)
 163   (gnus-run-mode-hooks 'emacs-lisp-mode-hook 'gnus-kill-file-mode-hook))
 164
 165 (defun gnus-kill-file-edit-file (newsgroup)
 166   "Begin editing a kill file for NEWSGROUP.
 167 If NEWSGROUP is nil, the global kill file is selected."
 168   (interactive "sNewsgroup: ")
 169   (let ((file (gnus-newsgroup-kill-file newsgroup)))
 170     (gnus-make-directory (file-name-directory file))
 171     ;; Save current window configuration if this is first invocation.
 172     (or (and (get-file-buffer file)
 173              (get-buffer-window (get-file-buffer file)))
 174         (setq gnus-winconf-kill-file (current-window-configuration)))
 175     ;; Hack windows.
 176     (let ((buffer (find-file-noselect file)))
 177       (cond ((get-buffer-window buffer)
 178              (pop-to-buffer buffer))
 179             ((eq major-mode 'gnus-group-mode)
 180              (gnus-configure-windows 'group) ;Take all windows.
 181              (pop-to-buffer buffer))
 182             ((eq major-mode 'gnus-summary-mode)
 183              (gnus-configure-windows 'article)
 184              (pop-to-buffer gnus-article-buffer)
 185              (bury-buffer gnus-article-buffer)
 186              (switch-to-buffer buffer))
 187             (t                          ;No good rules.
 188              (find-file-other-window file))))
 189     (gnus-kill-file-mode)))
 190
 191 ;; Fix by Sudish Joseph <joseph@cis.ohio-state.edu>.
 192 (defun gnus-kill-set-kill-buffer ()
 193   (let* ((file (gnus-newsgroup-kill-file gnus-newsgroup-name))
 194          (buffer (find-file-noselect file)))
 195     (set-buffer buffer)
 196     (gnus-kill-file-mode)
 197     (bury-buffer buffer)))
 198
 199 (defun gnus-kill-file-enter-kill (field regexp &optional dont-move)
 200   ;; Enter kill file entry.
 201   ;; FIELD: String containing the name of the header field to kill.
 202   ;; REGEXP: The string to kill.
 203   (save-excursion
 204     (let (string)
 205       (unless (eq major-mode 'gnus-kill-file-mode)
 206         (gnus-kill-set-kill-buffer))
 207       (unless dont-move
 208         (goto-char (point-max)))
 209       (insert (setq string (format "(gnus-kill %S %S)\n" field regexp)))
 210       (gnus-kill-file-apply-string string))))
 211
 212 (defun gnus-kill-file-kill-by-subject ()
 213   "Kill by subject."
 214   (interactive)
 215   (gnus-kill-file-enter-kill
 216    "Subject"
 217    (if (vectorp gnus-current-headers)
 218        (regexp-quote
 219         (gnus-simplify-subject (mail-header-subject gnus-current-headers)))
 220      "")
 221    t))
 222
 223 (defun gnus-kill-file-kill-by-author ()
 224   "Kill by author."
 225   (interactive)
 226   (gnus-kill-file-enter-kill
 227    "From"
 228    (if (vectorp gnus-current-headers)
 229        (regexp-quote (mail-header-from gnus-current-headers))
 230      "") t))
 231
 232 (defun gnus-kill-file-kill-by-thread ()
 233   "Kill by author."
 234   (interactive)
 235   (gnus-kill-file-enter-kill
 236    "References"
 237    (if (vectorp gnus-current-headers)
 238        (regexp-quote (mail-header-id gnus-current-headers))
 239      "")))
 240
 241 (defun gnus-kill-file-kill-by-xref ()
 242   "Kill by Xref."
 243   (interactive)
 244   (let ((xref (and (vectorp gnus-current-headers)
 245                    (mail-header-xref gnus-current-headers)))
 246         (start 0)
 247         group)
 248     (if xref
 249         (while (string-match " \\([^ \t]+\\):" xref start)
 250           (setq start (match-end 0))
 251           (when (not (string=
 252                       (setq group
 253                             (substring xref (match-beginning 1) (match-end 1)))
 254                       gnus-newsgroup-name))
 255             (gnus-kill-file-enter-kill
 256              "Xref" (concat " " (regexp-quote group) ":") t)))
 257       (gnus-kill-file-enter-kill "Xref" "" t))))
 258
 259 (defun gnus-kill-file-raise-followups-to-author (level)
 260   "Raise score for all followups to the current author."
 261   (interactive "p")
 262   (let ((name (mail-header-from gnus-current-headers))
 263         string)
 264     (save-excursion
 265       (gnus-kill-set-kill-buffer)
 266       (goto-char (point-min))
 267       (setq name (read-string (concat "Add " level
 268                                       " to followup articles to: ")
 269                               (regexp-quote name)))
 270       (setq
 271        string
 272        (format
 273         "(gnus-kill %S %S '(gnus-summary-temporarily-raise-by-thread %S))\n"
 274         "From" name level))
 275       (insert string)
 276       (gnus-kill-file-apply-string string))
 277     (gnus-message
 278      6 "Added temporary score file entry for followups to %s." name)))
 279
 280 (defun gnus-kill-file-apply-buffer ()
 281   "Apply current buffer to current newsgroup."
 282   (interactive)
 283   (if (and gnus-current-kill-article
 284            (get-buffer gnus-summary-buffer))
 285       ;; Assume newsgroup is selected.
 286       (gnus-kill-file-apply-string (buffer-string))
 287     (ding) (gnus-message 2 "No newsgroup is selected.")))
 288
 289 (defun gnus-kill-file-apply-string (string)
 290   "Apply STRING to current newsgroup."
 291   (interactive)
 292   (let ((string (concat "(progn \n" string "\n)")))
 293     (save-excursion
 294       (save-window-excursion
 295         (pop-to-buffer gnus-summary-buffer)
 296         (eval (car (read-from-string string)))))))
 297
 298 (defun gnus-kill-file-apply-last-sexp ()
 299   "Apply sexp before point in current buffer to current newsgroup."
 300   (interactive)
 301   (if (and gnus-current-kill-article
 302            (get-buffer gnus-summary-buffer))
 303       ;; Assume newsgroup is selected.
 304       (let ((string
 305              (buffer-substring
 306               (save-excursion (forward-sexp -1) (point)) (point))))
 307         (save-excursion
 308           (save-window-excursion
 309             (pop-to-buffer gnus-summary-buffer)
 310             (eval (car (read-from-string string))))))
 311     (ding) (gnus-message 2 "No newsgroup is selected.")))
 312
 313 (defun gnus-kill-file-exit ()
 314   "Save a kill file, then return to the previous buffer."
 315   (interactive)
 316   (save-buffer)
 317   (let ((killbuf (current-buffer)))
 318     ;; We don't want to return to article buffer.
 319     (when (get-buffer gnus-article-buffer)
 320       (bury-buffer gnus-article-buffer))
 321     ;; Delete the KILL file windows.
 322     (delete-windows-on killbuf)
 323     ;; Restore last window configuration if available.
 324     (when gnus-winconf-kill-file
 325       (set-window-configuration gnus-winconf-kill-file))
 326     (setq gnus-winconf-kill-file nil)
 327     ;; Kill the KILL file buffer.  Suggested by tale@pawl.rpi.edu.
 328     (kill-buffer killbuf)))
 329
 330 ;; For kill files
 331
 332 (defun gnus-Newsgroup-kill-file (newsgroup)
 333   "Return the name of a kill file for NEWSGROUP.
 334 If NEWSGROUP is nil, return the global kill file instead."
 335   (cond ((or (null newsgroup)
 336              (string-equal newsgroup ""))
 337          ;; The global kill file is placed at top of the directory.
 338          (expand-file-name gnus-kill-file-name gnus-kill-files-directory))
 339         (gnus-use-long-file-name
 340          ;; Append ".KILL" to capitalized newsgroup name.
 341          (expand-file-name (concat (gnus-capitalize-newsgroup newsgroup)
 342                                    "." gnus-kill-file-name)
 343                            gnus-kill-files-directory))
 344         (t
 345          ;; Place "KILL" under the hierarchical directory.
 346          (expand-file-name (concat (gnus-newsgroup-directory-form newsgroup)
 347                                    "/" gnus-kill-file-name)
 348                            gnus-kill-files-directory))))
 349
 350 (defun gnus-expunge (marks)
 351   "Remove lines marked with MARKS."
 352   (save-excursion
 353     (set-buffer gnus-summary-buffer)
 354     (gnus-summary-limit-to-marks marks 'reverse)))
 355
 356 (defun gnus-apply-kill-file-unless-scored ()
 357   "Apply .KILL file, unless a .SCORE file for the same newsgroup exists."
 358   (cond ((file-exists-p (gnus-score-file-name gnus-newsgroup-name))
 359          ;; Ignores global KILL.
 360          (when (file-exists-p (gnus-newsgroup-kill-file gnus-newsgroup-name))
 361            (gnus-message 3 "Note: Ignoring %s.KILL; preferring .SCORE"
 362                          gnus-newsgroup-name))
 363          0)
 364         ((or (file-exists-p (gnus-newsgroup-kill-file nil))
 365              (file-exists-p (gnus-newsgroup-kill-file gnus-newsgroup-name)))
 366          (gnus-apply-kill-file-internal))
 367         (t
 368          0)))
 369
 370 (defun gnus-apply-kill-file-internal ()
 371   "Apply a kill file to the current newsgroup.
 372 Returns the number of articles marked as read."
 373   (let* ((kill-files (list (gnus-newsgroup-kill-file nil)
 374                            (gnus-newsgroup-kill-file gnus-newsgroup-name)))
 375          (unreads (length gnus-newsgroup-unreads))
 376          (gnus-summary-inhibit-highlight t)
 377          beg)
 378     (setq gnus-newsgroup-kill-headers nil)
 379     ;; If there are any previously scored articles, we remove these
 380     ;; from the `gnus-newsgroup-headers' list that the score functions
 381     ;; will see.  This is probably pretty wasteful when it comes to
 382     ;; conses, but is, I think, faster than having to assq in every
 383     ;; single score function.
 384     (let ((files kill-files))
 385       (while files
 386         (if (file-exists-p (car files))
 387             (let ((headers gnus-newsgroup-headers))
 388               (if gnus-kill-killed
 389                   (setq gnus-newsgroup-kill-headers
 390                         (mapcar (lambda (header) (mail-header-number header))
 391                                 headers))
 392                 (while headers
 393                   (unless (gnus-member-of-range
 394                            (mail-header-number (car headers))
 395                            gnus-newsgroup-killed)
 396                     (push (mail-header-number (car headers))
 397                           gnus-newsgroup-kill-headers))
 398                   (setq headers (cdr headers))))
 399               (setq files nil))
 400           (setq files (cdr files)))))
 401     (if (not gnus-newsgroup-kill-headers)
 402         ()
 403       (save-window-excursion
 404         (save-excursion
 405           (while kill-files
 406             (if (not (file-exists-p (car kill-files)))
 407                 ()
 408               (gnus-message 6 "Processing kill file %s..." (car kill-files))
 409               (find-file (car kill-files))
 410               (goto-char (point-min))
 411
 412               (if (consp (ignore-errors (read (current-buffer))))
 413                   (gnus-kill-parse-gnus-kill-file)
 414                 (gnus-kill-parse-rn-kill-file))
 415
 416               (gnus-message
 417                6 "Processing kill file %s...done" (car kill-files)))
 418             (setq kill-files (cdr kill-files)))))
 419
 420       (gnus-set-mode-line 'summary)
 421
 422       (if beg
 423           (let ((nunreads (- unreads (length gnus-newsgroup-unreads))))
 424             (or (eq nunreads 0)
 425                 (gnus-message 6 "Marked %d articles as read" nunreads))
 426             nunreads)
 427         0))))
 428
 429 ;; Parse a Gnus killfile.
 430 (defun gnus-kill-parse-gnus-kill-file ()
 431   (goto-char (point-min))
 432   (gnus-kill-file-mode)
 433   (let (beg form)
 434     (while (progn
 435              (setq beg (point))
 436              (setq form (ignore-errors (read (current-buffer)))))
 437       (unless (listp form)
 438         (error "Invalid kill entry (possibly rn kill file?): %s" form))
 439       (if (or (eq (car form) 'gnus-kill)
 440               (eq (car form) 'gnus-raise)
 441               (eq (car form) 'gnus-lower))
 442           (progn
 443             (delete-region beg (point))
 444             (insert (or (eval form) "")))
 445         (save-excursion
 446           (set-buffer gnus-summary-buffer)
 447           (ignore-errors (eval form)))))
 448     (and (buffer-modified-p)
 449          gnus-kill-save-kill-file
 450          (save-buffer))
 451     (set-buffer-modified-p nil)))
 452
 453 ;; Parse an rn killfile.
 454 (defun gnus-kill-parse-rn-kill-file ()
 455   (goto-char (point-min))
 456   (gnus-kill-file-mode)
 457   (let ((mod-to-header
 458          '((?a . "")
 459            (?h . "")
 460            (?f . "from")
 461            (?: . "subject")))
 462         ;;(com-to-com
 463         ;; '((?m . " ")
 464         ;;   (?j . "X")))
 465         pattern modifier commands)
 466     (while (not (eobp))
 467       (if (not (looking-at "[ \t]*/\\([^/]*\\)/\\([ahfcH]\\)?:\\([a-z=:]*\\)"))
 468           ()
 469         (setq pattern (buffer-substring (match-beginning 1) (match-end 1)))
 470         (setq modifier (if (match-beginning 2) (char-after (match-beginning 2))
 471                          ?s))
 472         (setq commands (buffer-substring (match-beginning 3) (match-end 3)))
 473
 474         ;; The "f:+" command marks everything *but* the matches as read,
 475         ;; so we simply first match everything as read, and then unmark
 476         ;; PATTERN later.
 477         (when (string-match "\\+" commands)
 478           (gnus-kill "from" ".")
 479           (setq commands "m"))
 480
 481         (gnus-kill
 482          (or (cdr (assq modifier mod-to-header)) "subject")
 483          pattern
 484          (if (string-match "m" commands)
 485              '(gnus-summary-mark-as-unread nil " ")
 486            '(gnus-summary-mark-as-read nil "X"))
 487          nil t))
 488       (forward-line 1))))
 489
 490 ;; Kill changes and new format by suggested by JWZ and Sudish Joseph
 491 ;; <joseph@cis.ohio-state.edu>.
 492 (defun gnus-kill (field regexp &optional exe-command all silent)
 493   "If FIELD of an article matches REGEXP, execute COMMAND.
 494 Optional 1st argument COMMAND is default to
 495         (gnus-summary-mark-as-read nil \"X\").
 496 If optional 2nd argument ALL is non-nil, articles marked are also applied to.
 497 If FIELD is an empty string (or nil), entire article body is searched for.
 498 COMMAND must be a Lisp expression or a string representing a key sequence."
 499   ;; We don't want to change current point nor window configuration.
 500   (let ((old-buffer (current-buffer)))
 501     (save-excursion
 502       (save-window-excursion
 503         ;; Selected window must be summary buffer to execute keyboard
 504         ;; macros correctly.  See command_loop_1.
 505         (switch-to-buffer gnus-summary-buffer 'norecord)
 506         (goto-char (point-min))         ;From the beginning.
 507         (let ((kill-list regexp)
 508               (date (current-time-string))
 509               (command (or exe-command '(gnus-summary-mark-as-read
 510                                          nil gnus-kill-file-mark)))
 511               kill kdate prev)
 512           (if (listp kill-list)
 513               ;; It is a list.
 514               (if (not (consp (cdr kill-list)))
 515                   ;; It's of the form (regexp . date).
 516                   (if (zerop (gnus-execute field (car kill-list)
 517                                            command nil (not all)))
 518                       (when (> (days-between date (cdr kill-list))
 519                                gnus-kill-expiry-days)
 520                         (setq regexp nil))
 521                     (setcdr kill-list date))
 522                 (while (setq kill (car kill-list))
 523                   (if (consp kill)
 524                       ;; It's a temporary kill.
 525                       (progn
 526                         (setq kdate (cdr kill))
 527                         (if (zerop (gnus-execute
 528                                     field (car kill) command nil (not all)))
 529                             (when (> (days-between date kdate)
 530                                      gnus-kill-expiry-days)
 531                               ;; Time limit has been exceeded, so we
 532                               ;; remove the match.
 533                               (if prev
 534                                   (setcdr prev (cdr kill-list))
 535                                 (setq regexp (cdr regexp))))
 536                           ;; Successful kill.  Set the date to today.
 537                           (setcdr kill date)))
 538                     ;; It's a permanent kill.
 539                     (gnus-execute field kill command nil (not all)))
 540                   (setq prev kill-list)
 541                   (setq kill-list (cdr kill-list))))
 542             (gnus-execute field kill-list command nil (not all))))))
 543     (switch-to-buffer old-buffer)
 544     (when (and (eq major-mode 'gnus-kill-file-mode) regexp (not silent))
 545       (gnus-pp-gnus-kill
 546        (nconc (list 'gnus-kill field
 547                     (if (consp regexp) (list 'quote regexp) regexp))
 548               (when (or exe-command all)
 549                 (list (list 'quote exe-command)))
 550               (if all (list t) nil))))))
 551
 552 (defun gnus-pp-gnus-kill (object)
 553   (if (or (not (consp (nth 2 object)))
 554           (not (consp (cdr (nth 2 object))))
 555           (and (eq 'quote (car (nth 2 object)))
 556                (not (consp (cdadr (nth 2 object))))))
 557       (concat "\n" (gnus-prin1-to-string object))
 558     (save-excursion
 559       (set-buffer (gnus-get-buffer-create "*Gnus PP*"))
 560       (buffer-disable-undo)
 561       (erase-buffer)
 562       (insert (format "\n(%S %S\n  '(" (nth 0 object) (nth 1 object)))
 563       (let ((klist (cadr (nth 2 object)))
 564             (first t))
 565         (while klist
 566           (insert (if first (progn (setq first nil) "")  "\n    ")
 567                   (gnus-prin1-to-string (car klist)))
 568           (setq klist (cdr klist))))
 569       (insert ")")
 570       (and (nth 3 object)
 571            (insert "\n  "
 572                    (if (and (consp (nth 3 object))
 573                             (not (eq 'quote (car (nth 3 object)))))
 574                        "'" "")
 575                    (gnus-prin1-to-string (nth 3 object))))
 576       (when (nth 4 object)
 577         (insert "\n  t"))
 578       (insert ")")
 579       (prog1
 580           (buffer-string)
 581         (kill-buffer (current-buffer))))))
 582
 583 (defun gnus-execute-1 (function regexp form header)
 584   (save-excursion
 585     (let (did-kill)
 586       (if (null header)
 587           nil                           ;Nothing to do.
 588         (if function
 589             ;; Compare with header field.
 590             (let (value)
 591               (and header
 592                    (progn
 593                      (setq value (funcall function header))
 594                      ;; Number (Lines:) or symbol must be converted to string.
 595                      (unless (stringp value)
 596                        (setq value (gnus-prin1-to-string value)))
 597                      (setq did-kill (string-match regexp value)))
 598                    (cond ((stringp form) ;Keyboard macro.
 599                           (execute-kbd-macro form))
 600                          ((functionp form)
 601                           (funcall form))
 602                          (t
 603                           (eval form)))))
 604           ;; Search article body.
 605           (let ((gnus-current-article nil) ;Save article pointer.
 606                 (gnus-last-article nil)
 607                 (gnus-break-pages nil)  ;No need to break pages.
 608                 (gnus-mark-article-hook nil)) ;Inhibit marking as read.
 609             (gnus-message
 610              6 "Searching for article: %d..." (mail-header-number header))
 611             (gnus-article-setup-buffer)
 612             (gnus-article-prepare (mail-header-number header) t)
 613             (when (save-excursion
 614                     (set-buffer gnus-article-buffer)
 615                     (goto-char (point-min))
 616                     (setq did-kill (re-search-forward regexp nil t)))
 617               (cond ((stringp form)     ;Keyboard macro.
 618                      (execute-kbd-macro form))
 619                     ((functionp form)
 620                      (funcall form))
 621                     (t
 622                      (eval form)))))))
 623       did-kill)))
 624
 625 (defun gnus-execute (field regexp form &optional backward unread)
 626   "If FIELD of article header matches REGEXP, execute Lisp FORM (or a string).
 627 If FIELD is an empty string (or nil), entire article body is searched for.
 628 If optional 1st argument BACKWARD is non-nil, do backward instead.
 629 If optional 2nd argument UNREAD is non-nil, articles which are
 630 marked as read or ticked are ignored."
 631   (save-excursion
 632     (let ((killed-no 0)
 633           function article header extras)
 634       (cond
 635        ;; Search body.
 636        ((or (null field)
 637             (string-equal field ""))
 638         (setq function nil))
 639        ;; Get access function of header field.
 640        ((cond ((fboundp
 641                 (setq function
 642                       (intern-soft
 643                        (concat "mail-header-" (downcase field)))))
 644                (setq function `(lambda (h) (,function h))))
 645               ((when (setq extras
 646                            (member (downcase field)
 647                                    (mapcar (lambda (header)
 648                                              (downcase (symbol-name header)))
 649                                            gnus-extra-headers)))
 650                  (setq function
 651                        `(lambda (h)
 652                           (gnus-extra-header
 653                            (quote ,(nth (- (length gnus-extra-headers)
 654                                            (length extras))
 655                                         gnus-extra-headers))
 656                            h)))))))
 657        ;; Signal error.
 658        (t
 659         (error "Unknown header field: \"%s\"" field)))
 660       ;; Starting from the current article.
 661       (while (or
 662               ;; First article.
 663               (and (not article)
 664                    (setq article (gnus-summary-article-number)))
 665               ;; Find later articles.
 666               (setq article
 667                     (gnus-summary-search-forward unread nil backward)))
 668         (and (or (null gnus-newsgroup-kill-headers)
 669                  (memq article gnus-newsgroup-kill-headers))
 670              (vectorp (setq header (gnus-summary-article-header article)))
 671              (gnus-execute-1 function regexp form header)
 672              (setq killed-no (1+ killed-no))))
 673       ;; Return the number of killed articles.
 674       killed-no)))
 675
 676 ;;;###autoload
 677 (defalias 'gnus-batch-kill 'gnus-batch-score)
 678 ;;;###autoload
 679 (defun gnus-batch-score ()
 680   "Run batched scoring.
 681 Usage: emacs -batch -l ~/.emacs -l gnus -f gnus-batch-score"
 682   (interactive)
 683   (let* ((gnus-newsrc-options-n
 684           (gnus-newsrc-parse-options
 685            (concat "options -n "
 686                    (mapconcat 'identity command-line-args-left " "))))
 687          (gnus-expert-user t)
 688          (mail-sources nil)
 689          (gnus-use-dribble-file nil)
 690          (gnus-batch-mode t)
 691          info group newsrc unread
 692          ;; Disable verbose message.
 693          gnus-novice-user gnus-large-newsgroup
 694          gnus-options-subscribe gnus-auto-subscribed-groups
 695          gnus-options-not-subscribe)
 696     ;; Eat all arguments.
 697     (setq command-line-args-left nil)
 698     (gnus-slave)
 699     ;; Apply kills to specified newsgroups in command line arguments.
 700     (setq newsrc (cdr gnus-newsrc-alist))
 701     (while (setq info (pop newsrc))
 702       (setq group (gnus-info-group info)
 703             unread (gnus-group-unread group))
 704       (when (and (<= (gnus-info-level info) gnus-level-subscribed)
 705                  (and unread
 706                       (or (eq unread t)
 707                           (not (zerop unread)))))
 708         (ignore-errors
 709           (gnus-summary-read-group group nil t nil t))
 710         (when (eq (current-buffer) (get-buffer gnus-summary-buffer))
 711           (gnus-summary-exit))))
 712     ;; Exit Emacs.
 713     (switch-to-buffer gnus-group-buffer)
 714     (gnus-group-save-newsrc)))
 715
 716 (provide 'gnus-kill)
 717
 718 ;; arch-tag: b30c0f53-df1a-490b-b81e-17b13474f395
 719 ;;; gnus-kill.el ends here