Mercurial > emacs
changeset 270:f8d0e0ecd474
Initial revision
| author | Roland McGrath <roland@gnu.org> |
|---|---|
| date | Mon, 13 May 1991 22:34:50 +0000 |
| parents | 2ca8cdb96a9f |
| children | d548f9619751 |
| files | lisp/mail/rmail.el |
| diffstat | 1 files changed, 1600 insertions(+), 0 deletions(-) [+] |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lisp/mail/rmail.el Mon May 13 22:34:50 1991 +0000 @@ -0,0 +1,1600 @@ +;; "RMAIL" mail reader for Emacs. +;; Copyright (C) 1985, 1986, 1987, 1988 Free Software Foundation, Inc. + +;; This file is part of GNU Emacs. + +;; GNU Emacs is free software; you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation; either version 1, or (at your option) +;; any later version. + +;; GNU Emacs is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. + +;; You should have received a copy of the GNU General Public License +;; along with GNU Emacs; see the file COPYING. If not, write to +;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + + +;; Souped up by shane@mit-ajax based on ideas of rlk@athena.mit.edu +;; New features include attribute and keyword support, message +;; selection by dispatch table, summary by attributes and keywords, +;; expunging by dispatch table, sticky options for file commands. + +(require 'mail-utils) +(provide 'rmail) + +; These variables now declared paths.el +;(defvar rmail-spool-directory "/usr/spool/mail/" +; "This is the name of the directory used by the system mailer for\n\ +;delivering new mail. It's name should end with a slash.") +;(defvar rmail-file-name +; (expand-file-name "~/RMAIL") +; "") + +;;;###autoload +(defvar rmail-dont-reply-to-names nil "\ +*A regexp specifying names to prune of reply to messages. +nil means dont reply to yourself.") + +;;;###autoload +(defvar rmail-default-dont-reply-to-names "info-" "\ +A regular expression specifying part of the value of the default value of +the variable `rmail-dont-reply-to-names', for when the user does not set +`rmail-dont-reply-to-names' explicitly. (The other part of the default +value is the user's name.) +It is useful to set this variable in the site customisation file.") + +;;;###autoload +(defvar rmail-ignored-headers "^via:\\|^mail-from:\\|^origin:\\|^status:\\|^received:\\|^message-id:\\|^summary-line:" "\ +*Gubbish headers one would rather not see.") + +;;;###autoload +(defvar rmail-delete-after-output nil "\ +*Non-nil means automatically delete a message that is copied to a file.") + +;;;###autoload +(defconst rmail-primary-inbox-list nil "\ +*List of files which are inboxes for user's primary mail file ~/RMAIL. +`nil' means the default, which is (\"/usr/spool/mail/$USER\" \"~/mbox\") +\(the first name varies depending on the operating system, +and the value of the environment variable MAIL overrides it).") + +;; these may be altered by site-init.el to match the format of mmdf files +;; delimitation used on a given host (delim1 and delim2 from the config +;; files) + +(defvar mmdf-delim1 "^\001\001\001\001\n" + "Regexp marking the start of an mmdf message") +(defvar mmdf-delim2 "^\001\001\001\001\n" + "Regexp marking the end of an mmdf message") + +(defvar rmail-message-filter nil + "If non nil, is a filter function for new headers in RMAIL. +Called with region narrowed to unformatted header.") + +(defvar rmail-mode-map nil) + +(defvar rmail-inbox-list nil) +(defvar rmail-keywords nil) + +;; Message counters and markers. Deleted flags. + +(defvar rmail-current-message nil) +(defvar rmail-total-messages nil) +(defvar rmail-message-vector nil) +(defvar rmail-deleted-vector nil) + +;; These are used by autoloaded rmail-summary. + +(defvar rmail-summary-buffer nil) +(defvar rmail-summary-vector nil) + +;; `Sticky' default variables. + +;; Last individual label specified to a or k. +(defvar rmail-last-label nil) +;; Last set of labels specified to C-M-n or C-M-p or C-M-l. +(defvar rmail-last-multi-labels nil) +(defvar rmail-last-file nil) +(defvar rmail-last-rmail-file nil) + +;;;; *** Rmail Mode *** + +;;;###autoload +(defun rmail (&optional file-name-arg) + "Read and edit incoming mail. +Moves messages into file named by rmail-file-name (a babyl format file) + and edits that file in RMAIL Mode. +Type \\[describe-mode] once editing that file, for a list of RMAIL commands. + +May be called with filename as argument; then performs rmail editing on +that file, but does not copy any new mail into the file." + (interactive (if current-prefix-arg + (list (read-file-name "Run rmail on RMAIL file: " + nil nil t)))) + (or rmail-last-file + (setq rmail-last-file (expand-file-name "~/xmail"))) + (or rmail-last-rmail-file + (setq rmail-last-rmail-file (expand-file-name "~/XMAIL"))) + (let* ((file-name (expand-file-name (or file-name-arg rmail-file-name))) + (existed (get-file-buffer file-name))) + ;; Like find-file, but in the case where a buffer existed + ;; and the file was reverted, recompute the message-data. + (if (and existed (not (verify-visited-file-modtime existed))) + (progn + ;; Don't be confused by apparent local-variables spec + ;; in the last message in the RMAIL file. + (let ((inhibit-local-variables t)) + (find-file file-name)) + (if (verify-visited-file-modtime existed) + (progn (rmail-forget-messages) + (rmail-set-message-counters)))) + (let ((inhibit-local-variables t)) + (find-file file-name))) + (if (and existed (> (buffer-size) 0)) + ;; Buffer not new and not empty; ensure in proper mode, but that's all. + (or (eq major-mode 'rmail-mode) + (rmail-mode-2)) + (rmail-mode-2) + ;; Provide default set of inboxes for primary mail file ~/RMAIL. + (and (null rmail-inbox-list) + (null file-name-arg) + (setq rmail-inbox-list + (or rmail-primary-inbox-list + (list "~/mbox" + (or (getenv "MAIL") + (concat rmail-spool-directory + (user-original-login-name))))))) + ;; Convert all or part to Babyl file if possible. + (rmail-convert-file) + (goto-char (point-max)) + (if (null rmail-inbox-list) + (progn + (rmail-set-message-counters) + (rmail-show-message)))) + (rmail-get-new-mail) + ;; Show the first unseen message, which might be from a previous session + ;; or might have been just read in by rmail-get-new-mail. + (rmail-first-unseen-message))) + +;; Given the value of MAILPATH, return a list of inbox file names. +;; This is turned off because it is not clear that the user wants +;; all these inboxes to feed into the primary rmail file. +; (defun rmail-convert-mailpath (string) +; (let (idx list) +; (while (setq idx (string-match "[%:]" string)) +; (let ((this (substring string 0 idx))) +; (setq string (substring string (1+ idx))) +; (setq list (cons (if (string-match "%" this) +; (substring this 0 (string-match "%" this)) +; this) +; list)))) +; list)) + +; I have checked that adding "-*- rmail -*-" to the BABYL OPTIONS line +; will not cause emacs 18.55 problems. + +(defun rmail-convert-file () + (let (convert) + (widen) + (goto-char (point-min)) + ;; If file doesn't start like a Babyl file, + ;; convert it to one, by adding a header and converting each message. + (cond ((looking-at "BABYL OPTIONS:")) + ((looking-at "Version: 5\n") + ;; Losing babyl file made by old version of Rmail. + ;; Just fix the babyl file header; don't make a new one, + ;; so we don't lose the Labels: file attribute, etc. + (let ((buffer-read-only nil)) + (insert "BABYL OPTIONS: -*- rmail -*-\n"))) + (t + (setq convert t) + (rmail-insert-rmail-file-header))) + ;; If file was not a Babyl file or if there are + ;; Unix format messages added at the end, + ;; convert file as necessary. + (if (or convert + (progn (goto-char (point-max)) + (search-backward "\^_") + (forward-char 1) + (looking-at "\n*From "))) + (let ((buffer-read-only nil)) + (message "Converting to Babyl format...") + (narrow-to-region (point) (point-max)) + (rmail-convert-to-babyl-format) + (message "Converting to Babyl format...done"))))) + +; I have checked that adding "-*- rmail -*-" to the BABYL OPTIONS line +; will not cause emacs 18.55 problems. + +(defun rmail-insert-rmail-file-header () + (let ((buffer-read-only nil)) + (insert "BABYL OPTIONS: -*- rmail -*- +Version: 5 +Labels: +Note: This is the header of an rmail file. +Note: If you are seeing it in rmail, +Note: it means the file has no messages in it.\n\^_"))) + +(if rmail-mode-map + nil + (setq rmail-mode-map (make-keymap)) + (suppress-keymap rmail-mode-map) + (define-key rmail-mode-map "." 'rmail-beginning-of-message) + (define-key rmail-mode-map " " 'scroll-up) + (define-key rmail-mode-map "\177" 'scroll-down) + (define-key rmail-mode-map "n" 'rmail-next-undeleted-message) + (define-key rmail-mode-map "p" 'rmail-previous-undeleted-message) + (define-key rmail-mode-map "\en" 'rmail-next-message) + (define-key rmail-mode-map "\ep" 'rmail-previous-message) + (define-key rmail-mode-map "\e\C-n" 'rmail-next-labeled-message) + (define-key rmail-mode-map "\e\C-p" 'rmail-previous-labeled-message) + (define-key rmail-mode-map "a" 'rmail-add-label) + (define-key rmail-mode-map "k" 'rmail-kill-label) + (define-key rmail-mode-map "d" 'rmail-delete-forward) + (define-key rmail-mode-map "u" 'rmail-undelete-previous-message) + (define-key rmail-mode-map "x" 'rmail-expunge) + (define-key rmail-mode-map "s" 'rmail-expunge-and-save) + (define-key rmail-mode-map "g" 'rmail-get-new-mail) + (define-key rmail-mode-map "h" 'rmail-summary) + (define-key rmail-mode-map "\e\C-h" 'rmail-summary) + (define-key rmail-mode-map "l" 'rmail-summary-by-labels) + (define-key rmail-mode-map "\e\C-l" 'rmail-summary-by-labels) + (define-key rmail-mode-map "\e\C-r" 'rmail-summary-by-recipients) + (define-key rmail-mode-map "\e\C-s" 'rmail-summary-by-regexp) + (define-key rmail-mode-map "t" 'rmail-toggle-header) + (define-key rmail-mode-map "m" 'rmail-mail) + (define-key rmail-mode-map "r" 'rmail-reply) + (define-key rmail-mode-map "\e\C-m" 'rmail-retry-failure) + (define-key rmail-mode-map "c" 'rmail-continue) + (define-key rmail-mode-map "f" 'rmail-forward) + (define-key rmail-mode-map "\es" 'rmail-search) + (define-key rmail-mode-map "<" 'rmail-first-message) + (define-key rmail-mode-map ">" 'rmail-last-message) + (define-key rmail-mode-map "j" 'rmail-show-message) + (define-key rmail-mode-map "o" 'rmail-output-to-rmail-file) + (define-key rmail-mode-map "\C-o" 'rmail-output) + (define-key rmail-mode-map "i" 'rmail-input) + (define-key rmail-mode-map "q" 'rmail-quit) + (define-key rmail-mode-map "?" 'describe-mode) + (define-key rmail-mode-map "w" 'rmail-edit-current-message) + (define-key rmail-mode-map "e" 'rmail-edit-current-message) + (define-key rmail-mode-map "\C-d" 'rmail-delete-backward)) + +;; Rmail mode is suitable only for specially formatted data. +(put 'rmail-mode 'mode-class 'special) + +(defun rmail-mode () + "Rmail Mode is used by \\<rmail-mode-map>\\[rmail] for editing Rmail files. +All normal editing commands are turned off. +Instead, these commands are available: + +\\[rmail-beginning-of-message] Move point to front of this message (same as \\[beginning-of-buffer]). +\\[scroll-up] Scroll to next screen of this message. +\\[scroll-down] Scroll to previous screen of this message. +\\[rmail-next-undeleted-message] Move to Next non-deleted message. +\\[rmail-previous-undeleted-message] Move to Previous non-deleted message. +\\[rmail-next-message] Move to Next message whether deleted or not. +\\[rmail-previous-message] Move to Previous message whether deleted or not. +\\[rmail-first-message] Move to the first message in Rmail file. +\\[rmail-last-message] Move to the last message in Rmail file. +\\[rmail-show-message] Jump to message specified by numeric position in file. +\\[rmail-search] Search for string and show message it is found in. +\\[rmail-delete-forward] Delete this message, move to next nondeleted. +\\[rmail-delete-backward] Delete this message, move to previous nondeleted. +\\[rmail-undelete-previous-message] Undelete message. Tries current message, then earlier messages + till a deleted message is found. +\\[rmail-expunge] Expunge deleted messages. +\\[rmail-expunge-and-save] Expunge and save the file. +\\[rmail-quit] Quit Rmail: expunge, save, then switch to another buffer. +\\[save-buffer] Save without expunging. +\\[rmail-get-new-mail] Move new mail from system spool directory or mbox into this file. +\\[rmail-mail] Mail a message (same as \\[mail-other-window]). +\\[rmail-continue] Continue composing outgoing message started before. +\\[rmail-reply] Reply to this message. Like m but initializes some fields. +\\[rmail-retry-failure] Send this message again. Used on a mailer failure message. +\\[rmail-forward] Forward this message to another user. +\\[rmail-output-to-rmail-file] Output this message to an Rmail file (append it). +\\[rmail-output] Output this message to a Unix-format mail file (append it). +\\[rmail-input] Input Rmail file. Run Rmail on that file. +\\[rmail-add-label] Add label to message. It will be displayed in the mode line. +\\[rmail-kill-label] Kill label. Remove a label from current message. +\\[rmail-next-labeled-message] Move to Next message with specified label + (label defaults to last one specified). + Standard labels: filed, unseen, answered, forwarded, deleted. + Any other label is present only if you add it with `a'. +\\[rmail-previous-labeled-message] Move to Previous message with specified label +\\[rmail-summary] Show headers buffer, with a one line summary of each message. +\\[rmail-summary-by-labels] Like h only just messages with particular label(s) are summarized. +\\[rmail-summary-by-recipients] Like h only just messages with particular recipient(s) are summarized. +\\[rmail-toggle-header] Toggle header, show Rmail header if unformatted or vice versa. +\\[rmail-edit-current-message] Edit the current message. \\[rmail-cease-edit] to return to Rmail." + (interactive) + (rmail-mode-2) + (rmail-set-message-counters) + (rmail-show-message)) + +(defun rmail-mode-2 () + (kill-all-local-variables) + (rmail-mode-1) + (rmail-variables) + (run-hooks 'rmail-mode-hook)) + +(defun rmail-mode-1 () + (setq major-mode 'rmail-mode) + (setq mode-name "RMAIL") + (setq buffer-read-only t) + ;; No need to auto save RMAIL files. + (setq buffer-auto-save-file-name nil) + (if (boundp 'mode-line-modified) + (setq mode-line-modified "--- ") + (setq mode-line-format + (cons "--- " (cdr (default-value 'mode-line-format))))) + (use-local-map rmail-mode-map) + (set-syntax-table text-mode-syntax-table) + (setq local-abbrev-table text-mode-abbrev-table)) + +(defun rmail-variables () + (make-local-variable 'revert-buffer-function) + (setq revert-buffer-function 'rmail-revert) + (make-local-variable 'rmail-last-label) + (make-local-variable 'rmail-deleted-vector) + (make-local-variable 'rmail-summary-buffer) + (make-local-variable 'rmail-summary-vector) + (make-local-variable 'rmail-current-message) + (make-local-variable 'rmail-total-messages) + (make-local-variable 'require-final-newline) + (setq require-final-newline nil) + (make-local-variable 'version-control) + (setq version-control 'never) + (make-local-variable 'file-precious-flag) + (setq file-precious-flag t) + (make-local-variable 'rmail-message-vector) + (make-local-variable 'rmail-last-file) + (make-local-variable 'rmail-inbox-list) + (setq rmail-inbox-list (rmail-parse-file-inboxes)) + (make-local-variable 'rmail-keywords) + ;; this gets generated as needed + (setq rmail-keywords nil) + (make-local-variable 'save-buffers-skip) + (setq save-buffers-skip t)) + +;; Handle M-x revert-buffer done in an rmail-mode buffer. +(defun rmail-revert (arg noconfirm) + (let (revert-buffer-function) + ;; Call our caller again, but this time it does the default thing. + (if (revert-buffer arg noconfirm) + ;; If the user said "yes", and we changed something, + ;; reparse the messages. + (progn + (rmail-convert-file) + (goto-char (point-max)) + (rmail-set-message-counters) + (rmail-show-message))))) + +;; Return a list of files from this buffer's Mail: option. +;; Does not assume that messages have been parsed. +;; Just returns nil if buffer does not look like Babyl format. +(defun rmail-parse-file-inboxes () + (save-excursion + (save-restriction + (widen) + (goto-char 1) + (cond ((looking-at "BABYL OPTIONS:") + (search-forward "\n\^_" nil 'move) + (narrow-to-region 1 (point)) + (goto-char 1) + (if (search-forward "\nMail:" nil t) + (progn + (narrow-to-region (point) (progn (end-of-line) (point))) + (goto-char (point-min)) + (mail-parse-comma-list)))))))) + +(defun rmail-expunge-and-save () + "Expunge and save RMAIL file." + (interactive) + (rmail-expunge) + (save-buffer)) + +(defun rmail-quit () + "Quit out of RMAIL." + (interactive) + (rmail-expunge-and-save) + ;; Don't switch to the summary buffer even if it was recently visible. + (if rmail-summary-buffer + (bury-buffer rmail-summary-buffer)) + (let ((obuf (current-buffer))) + (switch-to-buffer (other-buffer)) + (bury-buffer obuf))) + +;;;###autoload +(defun rmail-input (filename) + "Run RMAIL on file FILENAME." + (interactive "FRun rmail on RMAIL file: ") + (rmail filename)) + + +;;;; *** Rmail input *** + +;; RLK feature not added in this version: +;; argument specifies inbox file or files in various ways. + +(defun rmail-get-new-mail (&optional file-name) + "Move any new mail from this RMAIL file's inbox files. +The inbox files can be specified with the file's Mail: option. The +variable `rmail-primary-inbox-list' specifies the inboxes for your +primary RMAIL file if it has no Mail: option. These are normally your +~/mbox and your /usr/spool/mail/$USER. + +You can also specify the file to get new mail from. In this case, the +file of new mail is not changed or deleted. Noninteractively, you can +pass the inbox file name as an argument. Interactively, a prefix +argument causes us to read a file name and use that file as the inbox." + (interactive + (list (if current-prefix-arg + (read-file-name "Get new mail from file: ")))) + (or (verify-visited-file-modtime (current-buffer)) + (progn + (find-file (buffer-file-name)) + (if (verify-visited-file-modtime (current-buffer)) + (rmail-forget-messages)))) + (rmail-maybe-set-message-counters) + (widen) + ;; Get rid of all undo records for this buffer. + (or (eq buffer-undo-list t) + (setq buffer-undo-list nil)) + (unwind-protect + (let ((opoint (point)) + (new-messages 0) + (delete-files ()) + ;; If buffer has not changed yet, and has not been saved yet, + ;; don't replace the old backup file now. + (make-backup-files (and make-backup-files (buffer-modified-p))) + (buffer-read-only nil) + ;; Don't make undo records for what we do in getting mail. + (buffer-undo-list t)) + (goto-char (point-max)) + (skip-chars-backward " \t\n") ; just in case of brain damage + (delete-region (point) (point-max)) ; caused by require-final-newline + (save-excursion + (save-restriction + (narrow-to-region (point) (point)) + ;; Read in the contents of the inbox files, + ;; renaming them as necessary, + ;; and adding to the list of files to delete eventually. + (if file-name + (rmail-insert-inbox-text (list file-name) nil) + (setq delete-files (rmail-insert-inbox-text rmail-inbox-list t))) + ;; Scan the new text and convert each message to babyl format. + (goto-char (point-min)) + (save-excursion + (setq new-messages (rmail-convert-to-babyl-format))) + (or (zerop new-messages) + (let (success) + (widen) + (search-backward "\n\^_") + (narrow-to-region (point) (point-max)) + (goto-char (1+ (point-min))) + (rmail-count-new-messages) + (save-buffer))) + ;; Delete the old files, now that babyl file is saved. + (while delete-files + (condition-case () + (delete-file (car delete-files)) + (file-error nil)) + (setq delete-files (cdr delete-files))))) + (if (= new-messages 0) + (progn (goto-char opoint) + (if (or file-name rmail-inbox-list) + (message "(No new mail has arrived)"))) + (message "%d new message%s read" + new-messages (if (= 1 new-messages) "" "s")) + (and (boundp 'display-time-string) + (string-match " Mail" display-time-string) + (setq display-time-string + (concat + (substring display-time-string 0 (match-beginning 0)) + (substring display-time-string (match-end 0)))) + (force-mode-line-update 'all)))) + ;; Don't leave the buffer screwed up if we get a disk-full error. + (rmail-show-message))) + +(defun rmail-insert-inbox-text (files renamep) + (let (file tofile delete-files movemail) + (while files + (setq file (expand-file-name (substitute-in-file-name (car files))) + ;;>> un*x specific << + tofile (concat file "~")) + ;; If getting from mail spool directory, + ;; use movemail to move rather than just renaming, + ;; so as to interlock with the mailer. + (setq movemail (equal (file-name-directory file) rmail-spool-directory)) + (if movemail + (progn + (setq tofile (expand-file-name + ;; Generate name to move to from inbox name, + ;; in case of multiple inboxes that need moving. + (concat ".newmail-" (file-name-nondirectory file)) + (file-name-directory + (expand-file-name rmail-file-name)))) + ;; On some systems, /usr/spool/mail/foo is a directory + ;; and the actual inbox is /usr/spool/mail/foo/foo. + (if (file-directory-p file) + (setq file (expand-file-name (user-original-login-name) + file))))) + (if (or (file-exists-p tofile) (file-exists-p file)) + (message "Getting mail from %s..." file)) + ;; Set TOFILE if have not already done so, and + ;; rename or copy the file FILE to TOFILE if and as appropriate. + (cond ((not renamep) + (setq tofile file)) + ((or (file-exists-p tofile) (not (file-exists-p file))) + nil) + ((not movemail) + (rename-file file tofile nil)) + (t + (let ((errors nil)) + (unwind-protect + (save-excursion + (setq errors (generate-new-buffer " *rmail loss*")) + (buffer-disable-undo errors) + (call-process + (expand-file-name "movemail" exec-directory) + nil errors nil file tofile) + (if (not (buffer-modified-p errors)) + ;; No output => movemail won + nil + (set-buffer errors) + (subst-char-in-region (point-min) (point-max) + ?\n ?\ ) + (goto-char (point-max)) + (skip-chars-backward " \t") + (delete-region (point) (point-max)) + (goto-char (point-min)) + (if (looking-at "movemail: ") + (delete-region (point-min) (match-end 0))) + (beep t) + (message (concat "movemail: " + (buffer-substring (point-min) + (point-max)))) + (sit-for 3) + nil)) + (if errors (kill-buffer errors)))))) + ;; At this point, TOFILE contains the name to read: + ;; Either the alternate name (if we renamed) + ;; or the actual inbox (if not renaming). + (if (file-exists-p tofile) + (let (size) + (goto-char (point-max)) + (setq size (nth 1 (insert-file-contents tofile))) + (goto-char (point-max)) + (or (= (preceding-char) ?\n) + (zerop size) + (insert ?\n)) + (setq delete-files (cons tofile delete-files)))) + (message "") + (setq files (cdr files))) + delete-files)) + +;; the rmail-break-forwarded-messages feature is not implemented +(defun rmail-convert-to-babyl-format () + (let ((count 0) start + (case-fold-search nil)) + (goto-char (point-min)) + (save-restriction + (while (not (eobp)) + (cond ((looking-at "BABYL OPTIONS:");Babyl header + (search-forward "\n\^_") + (delete-region (point-min) (point))) + ;; Babyl format message + ((looking-at "\^L") + (or (search-forward "\n\^_" nil t) + (progn + (message "Invalid Babyl format in inbox!") + (sit-for 1) + (goto-char (point-max)))) + (setq count (1+ count)) + ;; Make sure there is no extra white space after the ^_ + ;; at the end of the message. + ;; Narrowing will make sure that whatever follows the junk + ;; will be treated properly. + (delete-region (point) + (save-excursion + (skip-chars-forward " \t\n") + (point))) + (narrow-to-region (point) (point-max))) + ;;*** MMDF format + ((let ((case-fold-search t)) + (looking-at mmdf-delim1)) + (let ((case-fold-search t)) + (replace-match "\^L\n0, unseen,,\n*** EOOH ***\n") + (setq start (point)) + (re-search-forward mmdf-delim2 nil t) + (replace-match "\^_")) + (save-excursion + (save-restriction + (narrow-to-region start (1- (point))) + (goto-char (point-min)) + (while (search-forward "\n\^_" nil t); single char "\^_" + (replace-match "\n^_")))); 2 chars: "^" and "_" + (narrow-to-region (point) (point-max)) + (setq count (1+ count))) + ;;*** Mail format + ((looking-at "^From ") + (setq start (point)) + (insert "\^L\n0, unseen,,\n*** EOOH ***\n") + (rmail-nuke-pinhead-header) + (if (re-search-forward + (concat "^[\^_]?\\(" + "From [^ \n]*\\(\\|\".*\"[^ \n]*\\) ?[^ \n]* [^ \n]* *" + "[0-9]* [0-9:]*\\( ?[A-Z]?[A-Z][A-Z]T\\| ?[-+]?[0-9][0-9][0-9][0-9]\\|\\) " ; EDT, -0500 + "19[0-9]* *\\(remote from [^\n]*\\)?$\\|" + mmdf-delim1 "\\|" + "^BABYL OPTIONS:\\|" + "\^L\n[01],\\)") nil t) + (goto-char (match-beginning 1)) + (goto-char (point-max))) + (setq count (1+ count)) + (save-excursion + (save-restriction + (narrow-to-region start (point)) + (goto-char (point-min)) + (while (search-forward "\n\^_" nil t); single char + (replace-match "\n^_")))); 2 chars: "^" and "_" + (insert ?\^_) + (narrow-to-region (point) (point-max))) + ;; + ;;This is a kludge, in case we're wrong about mmdf not + ;;allowing anything in between. If it loses, we'll have + ;;to look for something else + (t (error "Cannot convert to babyl format"))))) + count)) + +;; Delete the "From ..." line, creating various other headers with +;; information from it if they don't already exist. Now puts the +;; original line into a mail-from: header line for debugging. +(defun rmail-nuke-pinhead-header () + (save-excursion + (save-restriction + (let ((start (point)) + (end (progn + (condition-case () + (search-forward "\n\n") + (error + (goto-char (point-max)) + (insert "\n\n"))) + (point))) + has-from has-date) + (narrow-to-region start end) + (let ((case-fold-search t)) + (goto-char start) + (setq has-from (search-forward "\nFrom:" nil t)) + (goto-char start) + (setq has-date (and (search-forward "\nDate:" nil t) (point))) + (goto-char start)) + (let ((case-fold-search nil)) + (if (re-search-forward + "^From \\([^ ]*\\(\\|\".*\"[^ ]*\\)\\) ?\\([^ ]*\\) \\([^ ]*\\) *\\([0-9]*\\) \\([0-9:]*\\)\\( ?[A-Z]?[A-Z][A-Z]T\\| ?[-+]?[0-9][0-9][0-9][0-9]\\|\\) 19\\([0-9]*\\) *\\(remote from [^\n]*\\)?\n" nil t) + (replace-match + (concat + "Mail-from: \\&" + ;; Keep and reformat the date if we don't + ;; have a Date: field. + (if has-date + "" + ;; If no time zone specified, assume est. + (if (= (match-beginning 7) (match-end 7)) + "Date: \\3, \\5 \\4 \\8 \\6 EST\n" + "Date: \\3, \\5 \\4 \\8 \\6\\7\n")) + ;; Keep and reformat the sender if we don't + ;; have a From: field. + (if has-from + "" + "From: \\1\n"))))))))) + +;;;; *** Rmail Message Formatting and Header Manipulation *** + +(defun rmail-reformat-message (beg end) + (goto-char beg) + (forward-line 1) + (if (/= (following-char) ?0) + (error "Bad format in RMAIL file.")) + (let ((buffer-read-only nil) + (delta (- (buffer-size) end))) + (delete-char 1) + (insert ?1) + (forward-line 1) + (if (looking-at "Summary-line: ") + (forward-line 1)) + (if (looking-at "\\*\\*\\* EOOH \\*\\*\\*\n") + (delete-region (point) + (progn (forward-line 1) (point)))) + (let ((str (buffer-substring (point) + (save-excursion (search-forward "\n\n" end 'move) + (point))))) + (insert str "*** EOOH ***\n") + (narrow-to-region (point) (- (buffer-size) delta))) + (goto-char (point-min)) + (if rmail-ignored-headers (rmail-clear-headers)) + (if rmail-message-filter (funcall rmail-message-filter)))) + +(defun rmail-clear-headers () + (if (search-forward "\n\n" nil t) + (save-restriction + (narrow-to-region (point-min) (point)) + (let ((buffer-read-only nil)) + (while (let ((case-fold-search t)) + (goto-char (point-min)) + (re-search-forward rmail-ignored-headers nil t)) + (beginning-of-line) + (delete-region (point) + (progn (re-search-forward "\n[^ \t]") + (forward-char -1) + (point)))))))) + +(defun rmail-toggle-header () + "Show original message header if pruned header currently shown, or vice versa." + (interactive) + (rmail-maybe-set-message-counters) + (narrow-to-region (rmail-msgbeg rmail-current-message) (point-max)) + (let ((buffer-read-only nil)) + (goto-char (point-min)) + (forward-line 1) + (if (= (following-char) ?1) + (progn (delete-char 1) + (insert ?0) + (forward-line 1) + (if (looking-at "Summary-Line:") + (forward-line 1)) + (insert "*** EOOH ***\n") + (forward-char -1) + (search-forward "\n*** EOOH ***\n") + (forward-line -1) + (let ((temp (point))) + (and (search-forward "\n\n" nil t) + (delete-region temp (point)))) + (goto-char (point-min)) + (search-forward "\n*** EOOH ***\n") + (narrow-to-region (point) (point-max))) + (rmail-reformat-message (point-min) (point-max))))) + +;;;; *** Rmail Attributes and Keywords *** + +;; Make a string describing current message's attributes and keywords +;; and set it up as the name of a minor mode +;; so it will appear in the mode line. +(defun rmail-display-labels () + (let ((blurb "") (beg (point-min-marker)) (end (point-max-marker))) + (save-excursion + (unwind-protect + (progn + (widen) + (goto-char (rmail-msgbeg rmail-current-message)) + (forward-line 1) + (if (looking-at "[01],") + (progn + (narrow-to-region (point) (progn (end-of-line) (point))) + ;; Truly valid BABYL format requires a space before each + ;; attribute or keyword name. Put them in if missing. + (let (buffer-read-only) + (goto-char (point-min)) + (while (search-forward "," nil t) + (or (looking-at "[ ,]") (eobp) + (insert " ")))) + (goto-char (point-max)) + (if (search-backward ",," nil 'move) + (progn + (if (> (point) (1+ (point-min))) + (setq blurb (buffer-substring (+ 1 (point-min)) (point)))) + (if (> (- (point-max) (point)) 2) + (setq blurb + (concat blurb + ";" + (buffer-substring (+ (point) 3) + (1- (point-max))))))))))) + ;; Note: we don't use save-restriction because that does not work right + ;; if changes are made outside the saved restriction + ;; before that restriction is restored. + (narrow-to-region beg end) + (set-marker beg nil) + (set-marker end nil))) + (while (string-match " +," blurb) + (setq blurb (concat (substring blurb 0 (match-beginning 0)) "," + (substring blurb (match-end 0))))) + (while (string-match ", +" blurb) + (setq blurb (concat (substring blurb 0 (match-beginning 0)) "," + (substring blurb (match-end 0))))) + (setq mode-line-process + (concat " " rmail-current-message "/" rmail-total-messages + blurb)))) + +;; Turn an attribute of a message on or off according to STATE. +;; ATTR is the name of the attribute, as a string. +;; MSGNUM is message number to change; nil means current message. +(defun rmail-set-attribute (attr state &optional msgnum) + (let ((omax (point-max-marker)) + (omin (point-min-marker)) + (buffer-read-only nil)) + (or msgnum (setq msgnum rmail-current-message)) + (unwind-protect + (save-excursion + (widen) + (goto-char (+ 3 (rmail-msgbeg msgnum))) + (let ((curstate + (not + (null (search-backward (concat ", " attr ",") + (prog1 (point) (end-of-line)) t))))) + (or (eq curstate (not (not state))) + (if curstate + (delete-region (point) (1- (match-end 0))) + (beginning-of-line) + (forward-char 2) + (insert " " attr ",")))) + (if (string= attr "deleted") + (rmail-set-message-deleted-p msgnum state))) + ;; Note: we don't use save-restriction because that does not work right + ;; if changes are made outside the saved restriction + ;; before that restriction is restored. + (narrow-to-region omin omax) + (set-marker omin nil) + (set-marker omax nil) + (if (= msgnum rmail-current-message) + (rmail-display-labels))))) + +;; Return t if the attributes/keywords line of msg number MSG +;; contains a match for the regexp LABELS. +(defun rmail-message-labels-p (msg labels) + (save-excursion + (save-restriction + (widen) + (goto-char (rmail-msgbeg msg)) + (forward-char 3) + (re-search-backward labels (prog1 (point) (end-of-line)) t)))) + +;;;; *** Rmail Message Selection And Support *** + +(defun rmail-msgend (n) + (marker-position (aref rmail-message-vector (1+ n)))) + +(defun rmail-msgbeg (n) + (marker-position (aref rmail-message-vector n))) + +(defun rmail-widen-to-current-msgbeg (function) + "Call FUNCTION with point at start of internal data of current message. +Assumes that bounds were previously narrowed to display the message in Rmail. +The bounds are widened enough to move point where desired, then narrowed +again afterward. + +FUNCTION may not change the visible text of the message, but it may +change the invisible header text." + (save-excursion + (let ((obeg (- (point-max) (point-min))) + (unwind-protect + (progn + (narrow-to-region (rmail-msgbeg rmail-current-message) + (point-max)) + (goto-char (point-min)) + (funcall function)) + ;; Note: we don't use save-restriction because that does not work right + ;; if changes are made outside the saved restriction + ;; before that restriction is restored. + ;; Here we assume that changes made by FUNCTION + ;; occur before the visible region of the message. + (narrow-to-region (- (point-max) obeg) (point-max))))))) + +(defun rmail-forget-messages () + (unwind-protect + (if (vectorp rmail-message-vector) + (let* ((i 0) + (v rmail-message-vector) + (n (length v))) + (while (< i n) + (move-marker (aref v i) nil) + (setq i (1+ i))))) + (setq rmail-message-vector nil) + (setq rmail-deleted-vector nil))) + +(defun rmail-maybe-set-message-counters () + (if (not (and rmail-deleted-vector + rmail-message-vector + rmail-current-message + rmail-total-messages)) + (rmail-set-message-counters))) + +(defun rmail-count-new-messages (&optional nomsg) + (let* ((case-fold-search nil) + (total-messages 0) + (messages-head nil) + (deleted-head nil)) + (or nomsg (message "Counting new messages...")) + (goto-char (point-max)) + ;; Put at the end of messages-head + ;; the entry for message N+1, which marks + ;; the end of message N. (N = number of messages). + (search-backward "\n\^_") + (forward-char 1) + (setq messages-head (list (point-marker))) + (rmail-set-message-counters-counter (point-min)) + (setq rmail-current-message (1+ rmail-total-messages)) + (setq rmail-total-messages + (+ rmail-total-messages total-messages)) + (setq rmail-message-vector + (vconcat rmail-message-vector (cdr messages-head))) + (aset rmail-message-vector + rmail-current-message (car messages-head)) + (setq rmail-deleted-vector + (concat rmail-deleted-vector deleted-head)) + (setq rmail-summary-vector + (vconcat rmail-summary-vector (make-vector total-messages nil))) + (goto-char (point-min)) + (or nomsg (message "Counting new messages...done (%d)" total-messages)))) + +(defun rmail-set-message-counters () + (rmail-forget-messages) + (save-excursion + (save-restriction + (widen) + (let* ((point-save (point)) + (total-messages 0) + (messages-after-point) + (case-fold-search nil) + (messages-head nil) + (deleted-head nil)) + (message "Counting messages...") + (goto-char (point-max)) + ;; Put at the end of messages-head + ;; the entry for message N+1, which marks + ;; the end of message N. (N = number of messages). + (search-backward "\n\^_") + (forward-char 1) + (setq messages-head (list (point-marker))) + (rmail-set-message-counters-counter (min (point) point-save)) + (setq messages-after-point total-messages) + (rmail-set-message-counters-counter) + (setq rmail-total-messages total-messages) + (setq rmail-current-message + (min total-messages + (max 1 (- total-messages messages-after-point)))) + (setq rmail-message-vector + (apply 'vector (cons (point-min-marker) messages-head)) + rmail-deleted-vector (concat "D" deleted-head) + rmail-summary-vector (make-vector rmail-total-messages nil)) + (message "Counting messages...done"))))) + +(defun rmail-set-message-counters-counter (&optional stop) + (while (search-backward "\n\^_\^L\n" stop t) + (forward-char 1) + (setq messages-head (cons (point-marker) messages-head)) + (save-excursion + (setq deleted-head + (cons (if (search-backward ", deleted," + (prog1 (point) + (forward-line 2)) + t) + ?D ?\ ) + deleted-head))) + (if (zerop (% (setq total-messages (1+ total-messages)) 20)) + (message "Counting messages...%d" total-messages)))) + +(defun rmail-beginning-of-message () + "Show current message starting from the beginning." + (interactive) + (rmail-show-message rmail-current-message)) + +(defun rmail-show-message (&optional n) + "Show message number N (prefix argument), counting from start of file." + (interactive "p") + (rmail-maybe-set-message-counters) + (widen) + (if (zerop rmail-total-messages) + (progn (narrow-to-region (point-min) (1- (point-max))) + (goto-char (point-min)) + (setq mode-line-process nil)) + (let (blurb) + (if (not n) + (setq n rmail-current-message) + (cond ((<= n 0) + (setq n 1 + rmail-current-message 1 + blurb "No previous message")) + ((> n rmail-total-messages) + (setq n rmail-total-messages + rmail-current-message rmail-total-messages + blurb "No following message")) + (t + (setq rmail-current-message n)))) + (let ((beg (rmail-msgbeg n)) + (end (rmail-msgend n))) + (goto-char beg) + (forward-line 1) + (if (= (following-char) ?0) + (progn + (rmail-reformat-message beg end) + (rmail-set-attribute "unseen" nil)) + (search-forward "\n*** EOOH ***\n" end t) + (narrow-to-region (point) end)) + (goto-char (point-min)) + (rmail-display-labels) + (run-hooks 'rmail-show-message-hook) + (if blurb + (message blurb)))))) + +(defun rmail-next-message (n) + "Show following message whether deleted or not. +With prefix arg N, moves forward N messages, or backward if N is negative." + (interactive "p") + (rmail-maybe-set-message-counters) + (rmail-show-message (+ rmail-current-message n))) + +(defun rmail-previous-message (n) + "Show previous message whether deleted or not. +With prefix arg N, moves backward N messages, or forward if N is negative." + (interactive "p") + (rmail-next-message (- n))) + +(defun rmail-next-undeleted-message (n) + "Show following non-deleted message. +With prefix arg N, moves forward N non-deleted messages, +or backward if N is negative." + (interactive "p") + (rmail-maybe-set-message-counters) + (let ((lastwin rmail-current-message) + (current rmail-current-message)) + (while (and (> n 0) (< current rmail-total-messages)) + (setq current (1+ current)) + (if (not (rmail-message-deleted-p current)) + (setq lastwin current n (1- n)))) + (while (and (< n 0) (> current 1)) + (setq current (1- current)) + (if (not (rmail-message-deleted-p current)) + (setq lastwin current n (1+ n)))) + (if (/= lastwin rmail-current-message) + (rmail-show-message lastwin)) + (if (< n 0) + (error "No previous nondeleted message")) + (if (> n 0) + (error "No following nondeleted message")))) + +(defun rmail-previous-undeleted-message (n) + "Show previous non-deleted message. +With prefix argument N, moves backward N non-deleted messages, +or forward if N is negative." + (interactive "p") + (rmail-next-undeleted-message (- n))) + +(defun rmail-first-message () + "Show first message in file." + (interactive) + (rmail-maybe-set-message-counters) + (rmail-show-message 1)) + +(defun rmail-last-message () + "Show last message in file." + (interactive) + (rmail-maybe-set-message-counters) + (rmail-show-message rmail-total-messages)) + +(defun rmail-what-message () + (let ((where (point)) + (low 1) + (high rmail-total-messages) + (mid (/ rmail-total-messages 2))) + (while (> (- high low) 1) + (if (>= where (rmail-msgbeg mid)) + (setq low mid) + (setq high mid)) + (setq mid (+ low (/ (- high low) 2)))) + (if (>= where (rmail-msgbeg high)) high low))) + +(defvar rmail-search-last-regexp nil) +(defun rmail-search (regexp &optional reversep) + "Show message containing next match for REGEXP. +Search in reverse (earlier messages) with non-nil second arg REVERSEP. +Interactively, empty argument means use same regexp used last time, +and reverse search is specified by a negative numeric arg." + (interactive + (let* ((reversep (< (prefix-numeric-value current-prefix-arg) 0)) + (prompt + (concat (if reversep "Reverse " "") "Rmail search (regexp): ")) + regexp) + (if rmail-search-last-regexp + (setq prompt (concat prompt + "(default " + rmail-search-last-regexp + ") "))) + (setq regexp (read-string prompt)) + (cond ((not (equal regexp "")) + (setq rmail-search-last-regexp regexp)) + ((not rmail-search-last-regexp) + (error "No previous Rmail search string"))) + (list rmail-search-last-regexp reversep))) + (message "%sRmail search for %s..." + (if reversep "Reverse " "") + regexp) + (rmail-maybe-set-message-counters) + (let ((omin (point-min)) + (omax (point-max)) + (opoint (point)) + win + (msg rmail-current-message)) + (unwind-protect + (progn + (widen) + ;; Check messages one by one, advancing message number up or down + ;; but searching forward through each message. + (if reversep + (while (and (null win) (> msg 1)) + (goto-char (rmail-msgbeg (setq msg (1- msg)))) + (setq win (re-search-forward + regexp (rmail-msgend msg) t))) + (while (and (null win) (< msg rmail-total-messages)) + (goto-char (rmail-msgbeg (setq msg (1+ msg)))) + (setq win (re-search-forward regexp (rmail-msgend msg) t))))) + (if win + (progn + ;; If this is a reverse search and we found a message, + ;; search backward thru this message to position point. + (if reversep + (progn + (goto-char (rmail-msgend msg)) + (re-search-backward + regexp (rmail-msgbeg msg) t))) + (setq win (point)) + (rmail-show-message msg) + (message "%sRmail search for %s...done" + (if reversep "Reverse " "") + regexp) + (goto-char win)) + (goto-char opoint) + (narrow-to-region omin omax) + (ding) + (message "Search failed: %s" regexp))))) + +;; Show the first message which has the `unseen' attribute. +(defun rmail-first-unseen-message () + (let ((current 1) + found) + (save-restriction + (widen) + (while (and (not found) (< current rmail-total-messages)) + (setq current (1+ current)) + (if (rmail-message-labels-p current ", ?\\(unseen\\),") + (setq found current)))) + (if found + (rmail-show-message found)))) + +;;;; *** Rmail Message Deletion Commands *** + +(defun rmail-message-deleted-p (n) + (= (aref rmail-deleted-vector n) ?D)) + +(defun rmail-set-message-deleted-p (n state) + (aset rmail-deleted-vector n (if state ?D ?\ ))) + +(defun rmail-delete-message () + "Delete this message and stay on it." + (interactive) + (rmail-set-attribute "deleted" t)) + +(defun rmail-undelete-previous-message () + "Back up to deleted message, select it, and undelete it." + (interactive) + (let ((msg rmail-current-message)) + (while (and (> msg 0) + (not (rmail-message-deleted-p msg))) + (setq msg (1- msg))) + (if (= msg 0) + (error "No previous deleted message") + (if (/= msg rmail-current-message) + (rmail-show-message msg)) + (rmail-set-attribute "deleted" nil)))) + +(defun rmail-delete-forward (&optional backward) + "Delete this message and move to next nondeleted one. +Deleted messages stay in the file until the \\[rmail-expunge] command is given. +With prefix argument, delete and move backward. If there is no nondeleted +message to move to in the preferred or specified direction, move in the +other direction." + (interactive "P") + (rmail-set-attribute "deleted" t) + (condition-case () + (rmail-next-undeleted-message (if backward -1 1)) + (error + (condition-case () + (rmail-previous-undeleted-message (if backward -1 1)) + (error nil))))) + +(defun rmail-delete-backward () + "Delete this message and move to previous nondeleted one. +Deleted messages stay in the file until the \\[rmail-expunge] command is given." + (interactive) + (rmail-delete-forward t)) + +(defun rmail-expunge () + "Actually erase all deleted messages in the file." + (interactive) + (message "Expunging deleted messages...") + ;; Discard all undo records for this buffer. + (or (eq buffer-undo-list t) + (setq buffer-undo-list nil)) + (rmail-maybe-set-message-counters) + (let* ((omax (- (buffer-size) (point-max))) + (omin (- (buffer-size) (point-min))) + (opoint (if (and (> rmail-current-message 0) + (= ?D (aref rmail-deleted-vector rmail-current-message))) + 0 (- (point) (point-min)))) + (messages-head (cons (aref rmail-message-vector 0) nil)) + (messages-tail messages-head) + ;; Don't make any undo records for the expunging. + (buffer-undo-list t) + (win)) + (unwind-protect + (save-excursion + (widen) + (goto-char (point-min)) + (let ((counter 0) + (number 1) + (total rmail-total-messages) + (new-message-number rmail-current-message) + (new-summary nil) + (buffer-read-only nil) + (messages rmail-message-vector) + (deleted rmail-deleted-vector) + (summary rmail-summary-vector)) + (setq rmail-total-messages nil + rmail-current-message nil + rmail-message-vector nil + rmail-deleted-vector nil + rmail-summary-vector nil) + (while (<= number total) + (if (= (aref deleted number) ?D) + (progn + (delete-region + (marker-position (aref messages number)) + (marker-position (aref messages (1+ number)))) + (move-marker (aref messages number) nil) + (if (> new-message-number counter) + (setq new-message-number (1- new-message-number)))) + (setq counter (1+ counter)) + (setq messages-tail + (setcdr messages-tail + (cons (aref messages number) nil))) + (setq new-summary + (cons (if (= counter number) (aref summary (1- number))) + new-summary))) + (if (zerop (% (setq number (1+ number)) 20)) + (message "Expunging deleted messages...%d" number))) + (setq messages-tail + (setcdr messages-tail + (cons (aref messages number) nil))) + (setq rmail-current-message new-message-number + rmail-total-messages counter + rmail-message-vector (apply 'vector messages-head) + rmail-deleted-vector (make-string (1+ counter) ?\ ) + rmail-summary-vector (vconcat (nreverse new-summary)) + win t))) + (message "Expunging deleted messages...done") + (if (not win) + (narrow-to-region (- (buffer-size) omin) (- (buffer-size) omax))) + (rmail-show-message + (if (zerop rmail-current-message) 1 nil)) + (forward-char opoint)))) + +;;;; *** Rmail Mailing Commands *** + +(defun rmail-mail () + "Send mail in another window. While composing the message, use +\\[mail-yank-original] to yank the original message into it." + (interactive) + (mail-other-window nil nil nil nil nil (current-buffer))) + +(defun rmail-continue () + "Continue composing outgoing message previously being composed." + (interactive) + (mail-other-window t)) + +(defun rmail-reply (just-sender) + "Reply to the current message. +Normally include CC: to all other recipients of original message; +prefix argument means ignore them. While composing the reply, +use \\[mail-yank-original] to yank the original message into it." + (interactive "P") + (let (from reply-to cc subject date to message-id resent-reply-to) + (save-excursion + (save-restriction + (widen) + (goto-char (rmail-msgbeg rmail-current-message)) + (forward-line 1) + (if (= (following-char) ?0) + (narrow-to-region + (progn (forward-line 2) + (point)) + (progn (search-forward "\n\n" (rmail-msgend rmail-current-message) + 'move) + (point))) + (narrow-to-region (point) + (progn (search-forward "\n*** EOOH ***\n") + (beginning-of-line) (point)))) + (setq resent-reply-to (mail-fetch-field "resent-reply-to" t) + from (mail-fetch-field "from") + reply-to (or resent-reply-to + (mail-fetch-field "reply-to" nil t) + from) + cc (cond (just-sender nil) + (resent-reply-to (mail-fetch-field "resent-cc" t)) + (t (mail-fetch-field "cc" nil t))) + subject (or (and resent-reply-to + (mail-fetch-field "resent-subject" t)) + (mail-fetch-field "subject")) + date (cond (resent-reply-to + (mail-fetch-field "resent-date" t)) + ((mail-fetch-field "date"))) + to (cond (resent-reply-to + (mail-fetch-field "resent-to" t)) + ((mail-fetch-field "to" nil t)) + ;((mail-fetch-field "apparently-to")) ack gag barf + (t "")) + message-id (cond (resent-reply-to + (mail-fetch-field "resent-message-id" t)) + ((mail-fetch-field "message-id")))))) + (and subject + (string-match "\\`Re: " subject) + (setq subject (substring subject 4))) + (mail-other-window nil + (mail-strip-quoted-names reply-to) + subject + (rmail-make-in-reply-to-field from date message-id) + (if just-sender + nil + (let* ((cc-list (rmail-dont-reply-to + (mail-strip-quoted-names + (if (null cc) to (concat to ", " cc)))))) + (if (string= cc-list "") nil cc-list))) + (current-buffer) + (list (list '(lambda (buf msgnum) + (save-excursion + (set-buffer buf) + (rmail-set-attribute "answered" t msgnum))) + (current-buffer) rmail-current-message))))) + +(defun rmail-make-in-reply-to-field (from date message-id) + (cond ((not from) + (if message-id + message-id + nil)) + (mail-use-rfc822 + (require 'rfc822) + (let ((tem (car (rfc822-addresses from)))) + (if message-id + (if (string-match + (regexp-quote (if (string-match "@[^@]*\\'" tem) + (substring tem 0 (match-beginning 0)) + tem)) + message-id) + ;; Message-ID is sufficiently informative + message-id + (concat message-id " (" tem ")")) + ;; Use prin1 to fake RFC822 quoting + (let ((field (prin1-to-string tem))) + (if date + (concat field "'s message of " date) + field))))) + ((let* ((foo "[^][\000-\037\177-\377()<>@,;:\\\" ]+") + (bar "[^][\000-\037\177-\377()<>@,;:\\\"]+")) + ;; Can't use format because format loses on \000 (unix *^&%*^&%$!!) + (or (string-match (concat "\\`[ \t]*\\(" bar + "\\)\\(<" foo "@" foo ">\\)?[ \t]*\\'") + ;; "Unix Loser <Foo@bar.edu>" => "Unix Loser" + from) + (string-match (concat "\\`[ \t]*<" foo "@" foo ">[ \t]*(\\(" + bar "\\))[ \t]*\\'") + ;; "<Bugs@bar.edu>" (Losing Unix) => "Losing Unix" + from))) + (let ((start (match-beginning 1)) + (end (match-end 1))) + ;; Trim whitespace which above regexp match allows + (while (and (< start end) + (memq (aref from start) '(?\t ?\ ))) + (setq start (1+ start))) + (while (and (< start end) + (memq (aref from (1- end)) '(?\t ?\ ))) + (setq end (1- end))) + (let ((field (substring from start end))) + (if date (setq field (concat "message from " field " on " date))) + (if message-id + ;; "<AA259@bar.edu> (message from Unix Loser on 1-Apr-89)" + (concat message-id " (" field ")") + field)))) + (t + ;; If we can't kludge it simply, do it correctly + (let ((mail-use-rfc822 t)) + (rmail-make-in-reply-to-field from date message-id))))) + +(defun rmail-forward () + "Forward the current message to another user." + (interactive) + (let ((forward-buffer (current-buffer)) + (subject (concat "[" + (mail-strip-quoted-names (mail-fetch-field "From")) + ": " (or (mail-fetch-field "Subject") "") "]"))) + ;; If only one window, use it for the mail buffer. + ;; Otherwise, use another window for the mail buffer + ;; so that the Rmail buffer remains visible + ;; and sending the mail will get back to it. + (if (funcall (if (one-window-p t) + (function mail) + (function mail-other-window)) + nil nil subject nil nil nil + (list (list (function (lambda (buf msgnum) + (save-excursion + (set-buffer buf) + (rmail-set-attribute "forwarded" t msgnum)))) + (current-buffer) + rmail-current-message))) + (save-excursion + (goto-char (point-max)) + (forward-line 1) + (insert-buffer forward-buffer))))) + +(defun rmail-resend (address &optional from comment mail-alias-file) + "Resend current message to ADDRESSES. +ADDRESSES should be a single address, a a string consisting of several +addresses separated by commas, or a list of addresses. + +Optional FROM is the address to resend the message from, and +defaults to the username of the person redistributing the message. +Optional COMMENT is a string that will be inserted as a comment in the +resent message. +Optional ALIAS-FILE is alternate aliases file to be used by sendmail, +typically for purposes of moderating a list." + (interactive "sResend to: ") + (if (not from) (setq from (user-login-name))) + (let ((tembuf (generate-new-buffer " sendmail temp")) + (mail-header-separator "") + (case-fold-search nil) + (mailbuf (current-buffer))) + (unwind-protect + (save-excursion + ;;>> Copy message into temp buffer + (set-buffer tembuf) + (insert-buffer-substring mailbuf) + (goto-char (point-min)) + ;;>> Insert resent-from: + (insert "Resent-From: " from "\n") + (insert "Resent-Date: " (current-time-string) "\n") + ;;>> Insert resent-to: and bcc if need be. + (let ((before (point))) + (insert "Resent-To: " (if (stringp address) + address + (mapconcat 'identity address ",\n\t")) + "\n") + (expand-mail-aliases before (point))) + ;;>> Set up comment, if any. + (if (and (sequencep comment) (not (zerop (length comment)))) + (let ((before (point)) + after) + (insert comment) + (or (eolp) (insert "\n")) + (setq after (point)) + (goto-char before) + (while (< (point) after) + (insert "Resent-Comment: ") + (forward-line 1)))) + ;; Don't expand aliases in the destination fields + ;; of the original message. + (let (mail-aliases) + (sendmail-send-it))) + (kill-buffer tembuf)))) + +(defvar mail-unsent-separator "^ ----- Unsent message follows -----$") + +(defun rmail-retry-failure () + "Edit a mail message which is based on the contents of the current message. +For a message rejected by the mail system, extract the interesting headers and +the body of the original message; otherwise copy the current message." + (interactive) + (require 'mail-utils) + (let (to subj irp2 cc orig-message) + (save-excursion + ;; Narrow down to just the quoted original message + (rmail-beginning-of-message) + (or (re-search-forward mail-unsent-separator nil t) + (error "Cannot parse this as a failure message")) + (save-restriction + (narrow-to-region (point) (point-max)) + ;; Now mail-fetch-field will get from headers of the original message, + ;; not from the headers of the rejection. + (setq to (mail-fetch-field "To") + subj (mail-fetch-field "Subject") + irp2 (mail-fetch-field "In-reply-to") + cc (mail-fetch-field "Cc")) + ;; Get the entire text (not headers) of the original message. + (setq orig-message + (buffer-substring + (progn (search-forward "\n\n") (point)) + (point-max))))) + ;; Start sending a new message; default header fields from the original. + (if (mail-other-window nil to subj irp2 cc (current-buffer)) + ;; Insert original text as initial text of new draft message. + (progn + (goto-char (point-max)) + (insert orig-message) + (goto-char (point-min)) + (end-of-line))))) + +;;;; *** Rmail Specify Inbox Files *** + +(autoload 'set-rmail-inbox-list "rmailmsc" + "Set the inbox list of the current RMAIL file to FILE-NAME. +This may be a list of file names separated by commas. +If FILE-NAME is empty, remove any inbox list." + t) + +;;;; *** Rmail Commands for Labels *** + +(autoload 'rmail-add-label "rmailkwd" + "Add LABEL to labels associated with current RMAIL message. +Completion is performed over known labels when reading." + t) + +(autoload 'rmail-kill-label "rmailkwd" + "Remove LABEL from labels associated with current RMAIL message. +Completion is performed over known labels when reading." + t) + +(autoload 'rmail-next-labeled-message "rmailkwd" + "Show next message with LABEL. Defaults to last label used. +With prefix argument N moves forward N messages with this label." + t) + +(autoload 'rmail-previous-labeled-message "rmailkwd" + "Show previous message with LABEL. Defaults to last label used. +With prefix argument N moves backward N messages with this label." + t) + +;;;; *** Rmail Edit Mode *** + +(autoload 'rmail-edit-current-message "rmailedit" + "Edit the contents of the current message" + t) + +;;;; *** Rmail Summary Mode *** + +(autoload 'rmail-summary "rmailsum" + "Display a summary of all messages, one line per message." + t) + +(autoload 'rmail-summary-by-labels "rmailsum" + "Display a summary of all messages with one or more LABELS. +LABELS should be a string containing the desired labels, separated by commas." + t) + +(autoload 'rmail-summary-by-recipients "rmailsum" + "Display a summary of all messages with the given RECIPIENTS. +Normally checks the To, From and Cc fields of headers; but if PRIMARY-ONLY +is non-nil (prefix arg given), only look in the To and From fields. +RECIPIENTS is a string of names separated by commas." + t) + +;;;; *** Rmail output messages to files *** + +(autoload 'rmail-output-to-rmail-file "rmailout" + "Append the current message to an Rmail file named FILE-NAME. +If the file does not exist, ask if it should be created. +If file is being visited, the message is appended to the Emacs +buffer visiting that file." + t) + +(autoload 'rmail-output "rmailout" + "Append this message to Unix mail file named FILE-NAME." + t) + +;;;; *** Rmail undigestification *** + +(autoload 'undigestify-rmail-message "undigest" + "Break up a digest message into its constituent messages. +Leaves original message, deleted, before the undigestified messages." + t)