cgit.sxemacs.org Git - gnus/blob - lisp/gnus-kill.el

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