+Tue Jul 6 10:59:24 1999 Lars Magne Ingebrigtsen <larsi@menja.ifi.uio.no>
+
+ * gnus.el: Pterodactyl Gnus v0.92 is released.
+
+1999-07-06 12:30:59 Johannes Weinert <Johannes.Weinert@Informatik.Uni-Oldenburg.DE>
+
+ * gnus-sum.el (gnus-summary-catchup-and-exit): Doc fix.
+
+1999-07-06 07:41:07 Lars Magne Ingebrigtsen <larsi@gnus.org>
+
+ * nntp.el (nntp-retrieve-groups): Don't do anything when not
+ connected.
+
+ * gnus-start.el (gnus-active-to-gnus-format): Only save active
+ when plugged.
+
+ * mm-view.el (mm-inline-message): Ignore remove-spec.
+
+ * gnus-agent.el (gnus-agent-write-active): Check whether orig sym
+ is bound.
+
+ * gnus-msg.el (gnus-summary-mail-forward): Rename From_ lines.
+
+ * nndoc.el (nndoc-guess-type): Remove blank lines at the start.
+
+ * nnfolder.el (nnfolder-read-folder): Remove blank lines at the
+ start.
+
+ * message.el (message-fill-yanked-message): Remove `t' arg.
+
+ * gnus-group.el (gnus-group-kill-group): Message killing of
+ groups.
+
+ * mm-util.el (mm-preferred-coding-system): New function.
+ (mm-mime-charset): Use it.
+
+ * mml.el (mml-generate-mime-1): Charset-encode message parts.
+
+1999-07-06 07:03:31 Alexandre Oliva <oliva@dcc.unicamp.br>
+
+ * gnus-mlsplt.el: New file.
+
+1999-07-06 05:47:57 Lars Magne Ingebrigtsen <larsi@gnus.org>
+
+ * mm-decode.el (mm-inline-Media-tests): Changed from forms to
+ functions.
+ (mm-attachment-override-p): Take a handle instead of a type.
+ (mm-inlined-p): Ditto.
+ (mm-automatic-display-p): Ditto,
+ (mm-inlinable-p): Ditto.
+
+ * nndraft.el (nndraft-request-expire-articles): Delete backup
+ files.
+
+ * mailcap.el (mailcap-parse-mailcap): Regexp-quote stuff.
+
+ * gnus-sum.el (gnus-summary-limit-to-extra): Typo.
+
+1999-07-06 05:37:46 Alexandre Oliva <oliva@dcc.unicamp.br>
+
+ * nnmail.el (nnmail-split-it): Allow .*.
+
+1999-07-05 05:04:57 Lars Magne Ingebrigtsen <larsi@gnus.org>
+
+ * mm-decode.el (mm-inline-large-images-p): Renamed.
+
+ * gnus-art.el (article-date-ut): Always look in the current buffer
+ for the Date header.
+
+ * mml.el (mml-validate): New command.
+
+ * mailcap.el (mailcap-possible-viewers): Revert to string-match
+ since we are dealing with regexps.
+
Sun Jul 4 06:31:01 1999 Lars Magne Ingebrigtsen <larsi@menja.ifi.uio.no>
* gnus.el: Pterodactyl Gnus v0.91 is released.
warn:
rm -f *.elc ; $(EMACS) $(FLAGS) --eval '(dgnushack-compile t)' 2>&1 | egrep -v "variable G|inhibit-point-motion-hooks|coding-system|temp-results|variable gnus|variable nn|scroll-in-place|deactivate-mark|filladapt-mode|byte-code-function-p|print-quoted|ps-right-header|ps-left-header|article-inhibit|print-escape|ssl-program-arguments|message-log-max"
+# The "clever" rule is unsafe, since redefined macros are loaded from
+# .elc files, and not the .el file.
clever some:
$(EMACS) $(FLAGS) -f dgnushack-compile
(defun gnus-agent-write-active (file new)
(let ((orig (gnus-make-hashtable (count-lines (point-min) (point-max))))
(file (gnus-agent-lib-file "active"))
- elem)
+ elem osym)
(when (file-exists-p file)
(with-temp-buffer
(insert-file-contents file)
(mapatoms
(lambda (sym)
(when (and sym (boundp sym))
- (if (setq elem (symbol-value (intern (symbol-name sym) orig)))
+ (if (and (boundp (setq osym (intern (symbol-name sym) orig)))
+ (setq elem (symbol-value osym)))
(setcdr elem (cdr (symbol-value sym)))
(set (intern (symbol-name sym) orig) (symbol-value sym)))))
new))
("\221" "`")
("\222" "'")
("\223" "``")
- ("\224" "''")
+ ("\224" "\"")
("\225" "*")
- ("\226" "-")
+ ("\226" "---")
("\227" "-")
("\231" "(TM)")
("\233" ">")
should replace the \"Date:\" one, or should be added below it."
(interactive (list 'ut t))
(let* ((header (or header
- (mail-header-date (save-excursion
- (set-buffer gnus-summary-buffer)
- gnus-current-headers))
(message-fetch-field "date")
""))
(tdate-regexp "^Date:[ \t]\\|^X-Sent:[ \t]")
(mm-pipe-part data)))
(defun gnus-mime-view-part ()
- "Interactively choose a view method for the MIME part under point."
+ "Interactively choose a viewing method for the MIME part under point."
(interactive)
(gnus-article-check-buffer)
(let ((data (get-text-property (point) 'gnus-data)))
(gnus-article-check-buffer)
(let* ((handle (or handle (get-text-property (point) 'gnus-data)))
(mm-user-display-methods nil)
- (mm-all-images-fit t)
+ (mm-inline-large-images nil)
(mail-parse-charset gnus-newsgroup-charset)
(mail-parse-ignored-charsets
(save-excursion (set-buffer gnus-summary-buffer)
(gnus-article-check-buffer)
(let* ((handle (or handle (get-text-property (point) 'gnus-data)))
(mm-user-display-methods '((".*" . inline)))
- (mm-all-images-fit t)
+ (mm-inline-large-images t)
(mail-parse-charset gnus-newsgroup-charset)
(mail-parse-ignored-charsets
(save-excursion (set-buffer gnus-summary-buffer)
(or (not (mm-handle-disposition handle))
(equal (car (mm-handle-disposition handle))
"inline")
- (mm-attachment-override-p type)))
- (mm-automatic-display-p type)
- (or (mm-inlined-p type)
+ (mm-attachment-override-p handle)))
+ (mm-automatic-display-p handle)
+ (or (mm-inlined-p handle)
(mm-automatic-external-display-p type)))
(setq display t)
(when (equal (car (split-string type "/"))
(push (cons (car entry) (nth 2 entry))
gnus-list-of-killed-groups))
(gnus-group-change-level
- (if entry entry group) gnus-level-killed (if entry nil level)))
+ (if entry entry group) gnus-level-killed (if entry nil level))
+ (message "Killed group %s" group))
;; If there are lots and lots of groups to be killed, we use
;; this thing instead.
(let (entry)
--- /dev/null
+;;; gnus-mlsplt.el --- a group params-based mail splitting mechanism
+;; Copyright (C) 1998,1999 Free Software Foundation, Inc.
+
+;; Author: Alexandre Oliva <oliva@dcc.unicamp.br>
+;; Keywords: news, mail
+
+;; This program 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 2, or (at your option)
+;; any later version.
+
+;; This program 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 this program; see the file COPYING. If not, write to
+;; the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+(require 'gnus)
+(require 'gnus-sum)
+(require 'gnus-group)
+(require 'nnmail)
+
+(defvar gnus-mlsplt-updated-hook nil
+ "Hook called just after nnmail-split-fancy is updated by
+gnus-mlsplt-update")
+
+(defvar gnus-mlsplt-default-catch-all-group "mail.misc"
+ "Group used by gnus-mlsplt and
+gnus-mlsplt-update as default catch-all group")
+
+(defun gnus-mlsplt-setup (&optional auto-update catch-all)
+ "Sets things up so that nnmail-split-fancy is used for mail splitting,
+and defines the variable nnmail-split-fancy according with group parameters.
+
+if AUTO-UPDATE is non-nil (prefix argument accepted, if called interactive),
+makes sure nnmail-split-fancy is re-computed before getting new mail,
+by adding gnus-mlsplt-update to nnmail-pre-get-new-mail-hook."
+ (interactive "P")
+ (setq nnmail-split-methods 'nnmail-split-fancy)
+ (when catch-all
+ (setq gnus-mlsplt-default-catch-all-group catch-all))
+ (gnus-mlsplt-update)
+ (when auto-update
+ (add-hook 'nnmail-pre-get-new-mail-hook 'gnus-mlsplt-update)))
+
+(defun gnus-mlsplt-update (&optional catch-all)
+ "Computes nnmail-split-fancy from group params, by calling
+\(gnus-mlsplt-fancy nil nil DEFAULTGROUP)"
+ (interactive)
+ (setq nnmail-split-fancy
+ (gnus-mlsplt-fancy
+ nil nil (or catch-all gnus-mlsplt-default-catch-all-group)))
+ (run-hooks 'gnus-mlsplt-updated-hook)
+ )
+
+(defun gnus-mlsplt ()
+ "Uses information from group parameters in order to split mail.
+See gnus-mlsplt-fancy for more information.
+
+If no group is defined as catch-all, the value of
+gnus-mlsplt-default-catch-all-group is used.
+
+gnus-mlsplt is a valid value for nnmail-split-methods."
+ (let (nnmail-split-fancy)
+ (gnus-mlsplt-update
+ gnus-mlsplt-default-catch-all-group)
+ (nnmail-split-fancy)))
+
+(defun gnus-mlsplt-fancy
+ (&optional groups no-crosspost catch-all)
+ "Uses information from group parameters in order to split mail.
+It can be embedded into nnmail-split-fancy lists with the SPLIT
+
+\(: gnus-mlsplt-fancy GROUPS NO-CROSSPOST CATCH-ALL\)
+
+GROUPS may be a regular expression or a list of group names, that will
+be used to select candidate groups. If it is ommited or nil, all
+existing groups are considered.
+
+if NO-CROSSPOST is ommitted or nil, a & split will be returned,
+otherwise, a | split, that does not allow crossposting, will be
+returned.
+
+if CATCH-ALL is not nil, and there is no selected group whose
+split-regexp matches the empty string, nor is there a selected group
+whose SPLIT-SPEC is 'catch-all, this group name will be appended to
+the returned SPLIT list, as the last element in a '| SPLIT.
+
+For each selected group, a SPLIT is composed like this: if split-spec
+is specified, this split is returned as-is (unless it is nil: in this
+case, the group is ignored). Otherwise, if TO-ADDRESS, TO-LIST and/or
+EXTRA-ALIASES are specified, a regexp that matches any of them is
+constructed (extra-aliases may be a list). Additionally, if
+SPLIT-REGEXP is specified, the regexp will be extended so that it
+matches this regexp too, and if SPLIT-EXCLUDE is specified, RESTRICT
+clauses will be generated.
+
+For example, given the following group parameters:
+
+nnml:mail.bar:
+\((to-address . \"bar@femail.com\")
+ (split-regexp . \".*@femail\\\\.com\"))
+nnml:mail.foo:
+\((to-list . \"foo@nowhere.gov\")
+ (extra-aliases \"foo@localhost\" \"foo-redist@home\")
+ (split-exclude \"bugs-foo\" \"rambling-foo\")
+ (admin-address . \"foo-request@nowhere.gov\"))
+nnml:mail.others:
+\((split-spec . catch-all))
+
+Calling (gnus-mlsplt-fancy nil nil \"mail.misc\") returns:
+
+\(| (& (any \"\\\\(bar@femail\\\\.com\\\\|.*@femail\\\\.com\\\\)\"
+ \"nnml:mail.bar\")
+ (any \"\\\\(foo@nowhere\\\\.gov\\\\|foo@localhost\\\\|foo-redist@home\\\\)\"
+ - \"bugs-foo\" - \"rambling-foo\" \"nnml:mail.foo\"))
+ \"nnml:mail.others\")"
+ (let* ((newsrc (cdr gnus-newsrc-alist))
+ split)
+ (dolist (info newsrc)
+ (let ((group (gnus-info-group info))
+ (params (gnus-info-params info)))
+ ;; For all GROUPs that match the specified GROUPS
+ (when (or (not groups)
+ (and (listp groups)
+ (memq group groups))
+ (and (stringp groups)
+ (string-match groups group)))
+ (let ((split-spec (cdr (assoc 'split-spec params))) group-clean)
+ ;; Remove backend from group name
+ (setq group-clean (string-match ":" group))
+ (setq group-clean
+ (if group-clean
+ (substring group (1+ group-clean))
+ group))
+ (if split-spec
+ (if (eq split-spec 'catch-all)
+ ;; Emit catch-all only when requested
+ (when catch-all
+ (setq catch-all group-clean))
+ ;; Append split-spec to the main split
+ (push split-spec split))
+ ;; Let's deduce split-spec from other params
+ (let ((to-address (cdr (assoc 'to-address params)))
+ (to-list (cdr (assoc 'to-list params)))
+ (extra-aliases (cdr (assoc 'extra-aliases params)))
+ (split-regexp (cdr (assoc 'split-regexp params)))
+ (split-exclude (cdr (assoc 'split-exclude params))))
+ (when (or to-address to-list extra-aliases split-regexp)
+ ;; regexp-quote to-address, to-list and extra-aliases
+ ;; and add them all to split-regexp
+ (setq split-regexp
+ (concat
+ "\\("
+ (mapconcat
+ 'identity
+ (append
+ (and to-address (list (regexp-quote to-address)))
+ (and to-list (list (regexp-quote to-list)))
+ (and extra-aliases
+ (if (listp extra-aliases)
+ (mapcar 'regexp-quote extra-aliases)
+ (list extra-aliases)))
+ (and split-regexp (list split-regexp)))
+ "\\|")
+ "\\)"))
+ ;; Now create the new SPLIT
+ (push (append
+ (list 'any split-regexp)
+ ;; Generate RESTRICTs for SPLIT-EXCLUDEs.
+ (if (listp split-exclude)
+ (mapcon (lambda (arg) (cons '- arg))
+ split-exclude)
+ (list '- split-exclude))
+ (list group-clean))
+ split)
+ ;; If it matches the empty string, it is a catch-all
+ (when (string-match split-regexp "")
+ (setq catch-all nil)))))))))
+ ;; Add catch-all if not crossposting
+ (if (and catch-all no-crosspost)
+ (push split catch-all))
+ ;; Move it to the tail, while arranging that SPLITs appear in the
+ ;; same order as groups.
+ (setq split (reverse split))
+ ;; Decide whether to accept cross-postings or not.
+ (push (if no-crosspost '| '&) split)
+ ;; Even if we can cross-post, catch-all should not get
+ ;; cross-posts.
+ (if (and catch-all (not no-crosspost))
+ (setq split (list '| split catch-all)))
+ split))
+
+(provide 'gnus-mlsplt)
(generate-new-buffer-name " *Gnus forward*")))
(erase-buffer)
(insert text)
+ (goto-char (point-min))
+ (when (looking-at "From ")
+ (replace-match "X-From-Line: ") )
(run-hooks 'gnus-article-decode-hook)
(message-forward post))))
(insert ?\\))
;; Let the Gnus agent save the active file.
- (when (and gnus-agent real-active)
+ (when (and gnus-agent real-active gnus-plugged)
(gnus-agent-save-active method))
;; If these are groups from a foreign select method, we insert the
"r" gnus-summary-caesar-message
"t" gnus-article-hide-headers
"v" gnus-summary-verbose-headers
- "h" gnus-article-treat-html
"H" gnus-article-strip-headers-in-body
"d" gnus-article-treat-dumbquotes)
["CR" gnus-article-remove-cr t]
["Show X-Face" gnus-article-display-x-face t]
["Quoted-Printable" gnus-article-de-quoted-unreadable t]
- ["UnHTMLize" gnus-article-treat-html t]
["Rot 13" gnus-summary-caesar-message t]
["Unix pipe" gnus-summary-pipe-message t]
["Add buttons" gnus-article-add-buttons t]
(intern
(gnus-completing-read
(symbol-name (car gnus-extra-headers))
- "Score extra header:"
+ "Limit extra header:"
(mapcar (lambda (x)
(cons (symbol-name x) x))
gnus-extra-headers)
(goto-char (point-min))
(or (search-forward "\n\n" nil t) (point)))
(goto-char (point-min))
- (delete-matching-lines "^\\(Path\\):\\|^From ")
+ (delete-matching-lines "^Path:\\|^From ")
(widen))
(unwind-protect
(if (let ((gnus-newsgroup-ephemeral-charset gnus-newsgroup-charset)
(gnus-summary-catchup t quietly))
(defun gnus-summary-catchup-and-exit (&optional all quietly)
- "Mark all articles not marked as unread in this newsgroup as read, then exit.
+ "Mark all unread articles in this group as read, then exit.
If prefix argument ALL is non-nil, all articles are marked as read."
(interactive "P")
(when (gnus-summary-catchup all quietly nil 'fast)
(with-temp-file file
(mapatoms
(lambda (sym)
- (when (and sym (boundp sym))
+ (when (and sym
+ (boundp sym)
+ (symbol-value sym))
(insert (format "%s %d %d y\n"
(symbol-name sym) (cdr (symbol-value sym))
(car (symbol-value sym))))))
[gnus-group-unsubscribe gnus-group-unsubscribe t "Unsubscribe group"]
[gnus-group-subscribe gnus-group-subscribe t "Subscribe group"]
[gnus-group-kill-group gnus-group-kill-group t "Kill group"]
- [gnus-group-exit gnus-group-exit t "Exit Gnus"]
- )
+ [gnus-group-exit gnus-group-exit t "Exit Gnus"])
"The group buffer toolbar.")
(defvar gnus-summary-toolbar
:link '(custom-manual "(gnus)Exiting Gnus")
:group 'gnus)
-(defconst gnus-version-number "0.91"
+(defconst gnus-version-number "0.92"
"Version number for this version of Gnus.")
(defconst gnus-version (format "Pterodactyl Gnus v%s" gnus-version-number)
(cond
((eq ?* (or (char-after save-pos) 0)) ".*")
((= (point) save-pos) ".*")
- (t (buffer-substring save-pos (point)))))
+ (t (regexp-quote (buffer-substring save-pos (point))))))
(skip-chars-forward "; \t\n")
;;; Got the major/minor chunks, now for the viewers/etc
;;; The first item _must_ be a viewer, according to the
(cond
((equal (car (car major)) minor)
(setq exact (cons (cdr (car major)) exact)))
- ((and minor (string= (car (car major)) minor))
+ ((and minor (string-match (car (car major)) minor))
(setq wildcard (cons (cdr (car major)) wildcard))))
(setq major (cdr major)))
(nconc (nreverse exact) (nreverse wildcard))))
Checks include subject-cmsg multiple-headers sendsys message-id from
long-lines control-chars size new-text redirected-followup signature
approved sender empty empty-headers message-id from subject
-shorten-followup-to existing-newsgroups buffer-file-name unchanged."
+shorten-followup-to existing-newsgroups buffer-file-name unchanged
+newsgroups."
:group 'message-news)
(defcustom message-required-news-headers
(goto-char (point-min))
(search-forward (concat "\n" mail-header-separator "\n") nil t)
(let ((fill-prefix message-yank-prefix))
- (fill-individual-paragraphs (point) (point-max) justifyp t))))
+ (fill-individual-paragraphs (point) (point-max) justifyp))))
(defun message-indent-citation ()
"Modify text just inserted from a message to be cited.
(car elem))))
(setq success (funcall (caddr elem) arg)))))
(setq sent t)))
+ (unless sent
+ (error "No methods specified to send by"))
(when (and success sent)
(message-do-fcc)
;;(when (fboundp 'mail-hist-put-headers-into-history)
(defun message-check-news-header-syntax ()
(and
+ ;; Check Newsgroups header.
+ (message-check 'newsgroyps
+ (let ((group (message-fetch-field "newsgroups")))
+ (or
+ (and group
+ (not (string-match "\\`[ \t]*\\'" group)))
+ (ignore
+ (message
+ "The newsgroups field is empty or missing. Posting is denied.")))))
;; Check the Subject header.
(message-check 'subject
(let* ((case-fold-search t)
,disposition ,description ,cache ,id))
(defvar mm-inline-media-tests
- '(("image/jpeg" mm-inline-image (mm-valid-and-fit-image-p 'jpeg handle))
- ("image/png" mm-inline-image (mm-valid-and-fit-image-p 'png handle))
- ("image/gif" mm-inline-image (mm-valid-and-fit-image-p 'gif handle))
- ("image/tiff" mm-inline-image (mm-valid-and-fit-image-p 'tiff handle))
- ("image/xbm" mm-inline-image (mm-valid-and-fit-image-p 'xbm handle))
- ("image/x-xbitmap" mm-inline-image (mm-valid-and-fit-image-p 'xbm handle))
- ("image/xpm" mm-inline-image (mm-valid-and-fit-image-p 'xpm handle))
- ("image/x-pixmap" mm-inline-image (mm-valid-and-fit-image-p 'xpm handle))
- ("image/bmp" mm-inline-image (mm-valid-and-fit-image-p 'bmp handle))
- ("text/plain" mm-inline-text t)
- ("text/enriched" mm-inline-text t)
- ("text/richtext" mm-inline-text t)
- ("text/html" mm-inline-text (locate-library "w3"))
- ("text/x-vcard" mm-inline-text (locate-library "vcard"))
- ("message/delivery-status" mm-inline-text t)
- ("message/rfc822" mm-inline-message t)
- ("text/.*" mm-inline-text t)
+ '(("image/jpeg"
+ mm-inline-image
+ (lambda (handle)
+ (mm-valid-and-fit-image-p 'jpeg handle)))
+ ("image/png"
+ mm-inline-image
+ (lambda (handle)
+ (mm-valid-and-fit-image-p 'png handle)))
+ ("image/gif"
+ mm-inline-image
+ (lambda (handle)
+ (mm-valid-and-fit-image-p 'gif handle)))
+ ("image/tiff"
+ mm-inline-image
+ (lambda (handle)
+ (mm-valid-and-fit-image-p 'tiff handle)) )
+ ("image/xbm"
+ mm-inline-image
+ (lambda (handle)
+ (mm-valid-and-fit-image-p 'xbm handle)))
+ ("image/x-xbitmap"
+ mm-inline-image
+ (lambda (handle)
+ (mm-valid-and-fit-image-p 'xbm handle)))
+ ("image/xpm"
+ mm-inline-image
+ (lambda (handle)
+ (mm-valid-and-fit-image-p 'xpm handle)))
+ ("image/x-pixmap"
+ mm-inline-image
+ (lambda (handle)
+ (mm-valid-and-fit-image-p 'xpm handle)))
+ ("image/bmp"
+ mm-inline-image
+ (lambda (handle)
+ (mm-valid-and-fit-image-p 'bmp handle)))
+ ("text/plain" mm-inline-text identity)
+ ("text/enriched" mm-inline-text identity)
+ ("text/richtext" mm-inline-text identity)
+ ("text/html"
+ mm-inline-text
+ (lambda (handle)
+ (locate-library "w3")))
+ ("text/x-vcard"
+ mm-inline-text
+ (lambda (handle)
+ (locate-library "vcard")))
+ ("message/delivery-status" mm-inline-text identity)
+ ("message/rfc822" mm-inline-message identity)
+ ("text/.*" mm-inline-text identity)
("audio/wav" mm-inline-audio
- (and (or (featurep 'nas-sound) (featurep 'native-sound))
- (device-sound-enabled-p)))
- ("audio/au" mm-inline-audio
- (and (or (featurep 'nas-sound) (featurep 'native-sound))
- (device-sound-enabled-p)))
- ("multipart/alternative" ignore t)
- ("multipart/mixed" ignore t)
- ("multipart/related" ignore t))
+ (lambda (handle)
+ (and (or (featurep 'nas-sound) (featurep 'native-sound))
+ (device-sound-enabled-p))))
+ ("audio/au"
+ mm-inline-audio
+ (lambda (handle)
+ (and (or (featurep 'nas-sound) (featurep 'native-sound))
+ (device-sound-enabled-p))))
+ ("multipart/alternative" ignore identity)
+ ("multipart/mixed" ignore identity)
+ ("multipart/related" ignore identity))
"Alist of media types/test that say whether the media types can be displayed inline.")
(defvar mm-inlined-types
("/tmp/"))
"Where mm will store its temporary files.")
-(defvar mm-all-images-fit nil
+(defvar mm-inline-large-images nil
"If non-nil, then all images fit in the buffer.")
;;; Internal variables.
(mm-remove-part handle)
(let* ((type (car (mm-handle-type handle)))
(method (mailcap-mime-info type)))
- (if (mm-inlined-p type)
+ (if (mm-inlined-p handle)
(progn
(forward-line 1)
(mm-display-inline handle)
(funcall function handle)
(goto-char (point-min))))
-(defun mm-inlinable-p (type)
- "Say whether TYPE can be displayed inline."
+(defun mm-inlinable-p (handle)
+ "Say whether HANDLE can be displayed inline."
(let ((alist mm-inline-media-tests)
+ (type (car (mm-handle-type handle)))
test)
(while alist
(when (equal type (caar alist))
(setq test (caddar alist)
alist nil)
- (setq test (eval test)))
+ (setq test (funcall test handle)))
(pop alist))
test))
-(defun mm-automatic-display-p (type)
- "Say whether the user wants TYPE to be displayed automatically."
+(defun mm-automatic-display-p (handle)
+ "Say whether the user wants HANDLE to be displayed automatically."
(let ((methods mm-automatic-display)
+ (type (car (mm-handle-type handle)))
method result)
(while (setq method (pop methods))
(when (and (string-match method type)
- (mm-inlinable-p type))
+ (mm-inlinable-p handle))
(setq result t
methods nil)))
result))
-(defun mm-inlined-p (type)
- "Say whether the user wants TYPE to be displayed automatically."
+(defun mm-inlined-p (handle)
+ "Say whether the user wants HANDLE to be displayed automatically."
(let ((methods mm-inlined-types)
+ (type (car (mm-handle-type handle)))
method result)
(while (setq method (pop methods))
(when (and (string-match method type)
- (mm-inlinable-p type))
+ (mm-inlinable-p handle))
(setq result t
methods nil)))
result))
-(defun mm-attachment-override-p (type)
- "Say whether TYPE should have attachment behavior overridden."
+(defun mm-attachment-override-p (handle)
+ "Say whether HANDLE should have attachment behavior overridden."
(let ((types mm-attachment-override-types)
+ (type (car (mm-handle-type handle)))
ty)
(catch 'found
(while (setq ty (pop types))
(when (and (string-match ty type)
- (mm-inlinable-p type))
+ (mm-inlinable-p handle))
(throw 'found t))))))
(defun mm-automatic-external-display-p (type)
(car (mm-handle-type (car h)))))
(setq handle (car h))
(when (and (equal p type)
- (mm-automatic-display-p type)
+ (mm-automatic-display-p (car h))
(or (stringp (caar h))
(not (mm-handle-disposition (car h)))
(equal (car (mm-handle-disposition (car h)))
(defun mm-image-fit-p (handle)
"Say whether the image in HANDLE will fit the current window."
(let ((image (mm-get-image handle)))
- (or mm-all-images-fit
+ (or mm-inline-large-images
(and (< (glyph-width image) (window-pixel-width))
(< (glyph-height image) (window-pixel-height))))))
(when (fboundp 'set-buffer-multibyte)
(set-buffer-multibyte nil)))
+(defun mm-preferred-coding-system (charset)
+ ;; A typo in some Emacs versions.
+ (or (get-charset-property charset 'prefered-coding-system)
+ (get-charset-property charset 'preffered-coding-system)))
+
(defun mm-mime-charset (charset)
"Return the MIME charset corresponding to the MULE CHARSET."
(if (fboundp 'coding-system-get)
;; This exists in Emacs 20.
(or
- (and (get-charset-property charset 'prefered-coding-system)
+ (and (mm-preferred-coding-system charset)
(coding-system-get
- (get-charset-property charset 'prefered-coding-system)
- 'mime-charset))
+ (mm-preferred-coding-system charset) 'mime-charset))
(and (eq charset 'ascii)
'us-ascii)
- (get-charset-property charset 'prefered-coding-system)
+ (mm-preferred-coding-system charset)
(mm-mule-charset-to-mime-charset charset))
;; This is for XEmacs.
(mm-mule-charset-to-mime-charset charset)))
(condition-case var
(w3-region (point-min) (point-max))
(error)))))
-;;; (narrow-to-region (1+ (point-min)) (point-max))
(mm-handle-set-undisplayer
handle
`(lambda ()
(goto-char (point-min)))
(defun mm-inline-message (handle)
- (let ((b (point)) gnus-displaying-mime handles)
+ (let ((b (point))
+ gnus-displaying-mime handles)
(save-excursion
(save-restriction
(narrow-to-region b b)
(run-hooks 'gnus-article-decode-hook)
(gnus-article-prepare-display)
(setq handles gnus-article-mime-handles))
- (if handles
- (setq gnus-article-mime-handles
- (append gnus-article-mime-handles handles)))
+ (when handles
+ (setq gnus-article-mime-handles
+ (append gnus-article-mime-handles handles)))
(mm-handle-set-undisplayer
handle
`(lambda ()
(let (buffer-read-only)
- (mapc (lambda (prop)
- (remove-specifier
- (face-property 'default prop) (current-buffer)))
- '(background background-pixmap foreground))
+ (ignore-errors
+ ;; This is only valid on XEmacs.
+ (mapc (lambda (prop)
+ (remove-specifier
+ (face-property 'default prop) (current-buffer)))
+ '(background background-pixmap foreground)))
(delete-region ,(point-min-marker) ,(point-max-marker)))))))))
(provide 'mm-view)
((eq (car cont) 'part)
(let (coded encoding charset filename type)
(setq type (or (cdr (assq 'type cont)) "text/plain"))
- (if (equal (car (split-string type "/")) "text")
+ (if (member (car (split-string type "/")) '("text" "message"))
(with-temp-buffer
(cond
((cdr (assq 'buffer cont))
["Multipart" mml-insert-multipart t]
["Part" mml-insert-part t])
["Quote" mml-quote-region t]
- ["Validate" mml-validate t]))
+ ["Validate" mml-validate t]
+ ["Preview" mml-preview t]))
(defvar mml-mode nil
"Minor mode for editing MML.")
(fundamental-mode)
(setq buffer-read-only t)
(goto-char (point-min))))
-
+
+(defun mml-validate ()
+ "Validate the current MML document."
+ (interactive)
+ (mml-parse))
+
(provide 'mml)
;;; mml.el ends here
(setq entry (pop alist)))
(when (memq subtype (or (cdr (assq 'subtype entry)) '(guess)))
(goto-char (point-min))
+ ;; Remove blank lines.
+ (while (eq (following-char) ?\n)
+ (delete-char 1))
(when (numberp (setq result (funcall (intern
(format "nndoc-%s-type-p"
(car entry))))))
(save-excursion
(set-buffer nndoc-current-buffer)
(goto-char (point-min))
+ ;; Remove blank lines.
+ (while (eq (following-char) ?\n)
+ (delete-char 1))
;; Find the beginning of the file.
(when nndoc-file-begin
(nndoc-search nndoc-file-begin))
(let ((auto (nndraft-auto-save-file-name
(nndraft-article-filename article))))
(when (file-exists-p auto)
- (funcall nnmail-delete-file-function auto)))))
+ (funcall nnmail-delete-file-function auto)))
+ (dolist (backup
+ (let ((kept-new-versions 1)
+ (kept-old-versions 0))
+ (cdr (find-backup-file-name
+ (nndraft-article-filename article)))))
+ (when (file-exists-p backup)
+ (funcall nnmail-delete-file-function backup)))))
res))
(deffoo nndraft-request-accept-article (group &optional server last noinsert)
(save-buffer))
;; Parse the damn thing.
(save-excursion
+ (goto-char (point-min))
+ ;; Remove any blank lines at the start.
+ (while (eq (following-char) ?\n)
+ (delete-char 1))
(nnmail-activate 'nnfolder)
;; Read in the file.
(let ((delim "^From ")
GROUP: Mail will be stored in GROUP (a string).
-\(FIELD VALUE SPLIT): If the message field FIELD (a regexp) contains
- VALUE (a regexp), store the messages as specified by SPLIT.
+\(FIELD VALUE [- RESTRICT [- RESTRICT [...]]] SPLIT): If the message
+ field FIELD (a regexp) contains VALUE (a regexp), store the messages
+ as specified by SPLIT. If RESTRICT (a regexp) matches some string
+ after FIELD and before the end of the matched VALUE, return NIL,
+ otherwise process SPLIT. Multiple RESTRICTs add up, further
+ restricting the possibility of processing SPLIT.
\(| SPLIT...): Process each SPLIT expression until one of them matches.
A SPLIT expression is said to match if it will cause the mail
the buffer containing the message headers. The return value FUNCTION
should be a split, which is then recursively processed.
+\(! FUNCTION SPLIT): Call FUNCTION with the result of SPLIT. The
+ return value FUNCTION should be a split, which is then recursively
+ processed.
+
FIELD must match a complete field name. VALUE must match a complete
word according to the `nnmail-split-fancy-syntax-table' syntax table.
You can use \".*\" in the regexps to match partial field names or words.
;; Other mailing lists...
(any \"procmail@informatik\\\\.rwth-aachen\\\\.de\" \"procmail.list\")
(any \"SmartList@informatik\\\\.rwth-aachen\\\\.de\" \"SmartList.list\")
+ ;; Both lists below have the same suffix, so prevent
+ ;; cross-posting to mkpkg.list of messages posted only to
+ ;; the bugs- list, but allow cross-posting when the
+ ;; message was really cross-posted.
+ (any \"bugs-mypackage@somewhere\" \"mypkg.bugs\")
+ (any \"mypackage@somewhere\" - \"bugs-mypackage\" \"mypkg.list\")
+ ;;
;; People...
(any \"larsi@ifi\\\\.uio\\\\.no\" \"people.Lars Magne Ingebrigtsen\"))
;; Unmatched mail goes to the catch all group.
;; Check the cache for the regexp for this split.
((setq cached-pair (assq split nnmail-split-cache))
- (goto-char (point-max))
- ;; FIX FIX FIX problem with re-search-backward is that if you have
- ;; a split: (from "foo-\\(bar\\|baz\\)@gnus.org "mail.foo.\\1")
- ;; and someone mails a message with 'To: foo-bar@gnus.org' and
- ;; 'CC: foo-baz@gnus.org', we'll pick 'mail.foo.baz' as the group
- ;; if the cc line is a later header, even though the other choice
- ;; is probably better. Also, this routine won't do a crosspost
- ;; when there are two different matches.
- ;; I guess you could just make this more determined, and it could
- ;; look for still more matches prior to this one, and recurse
- ;; on each of the multiple matches hit. Of course, then you'd
- ;; want to make sure that nnmail-article-group or nnmail-split-fancy
- ;; removed duplicates, since there might be more of those.
- ;; I guess we could also remove duplicates in the & split case, since
- ;; that's the only thing that can introduce them.
- (when (re-search-backward (cdr cached-pair) nil t)
+ (let (split-result
+ (end-point (point-max))
+ (value (nth 1 split)))
+ (if (symbolp value)
+ (setq value (cdr (assq value nnmail-split-abbrev-alist))))
+ (while (and (goto-char end-point)
+ (re-search-backward (cdr cached-pair) nil t))
(when nnmail-split-tracing
(push (cdr cached-pair) nnmail-split-trace))
- ;; Someone might want to do a \N sub on this match, so get the
- ;; correct match positions.
- (goto-char (match-end 0))
- (let ((value (nth 1 split)))
- (re-search-backward (if (symbolp value)
- (cdr (assq value nnmail-split-abbrev-alist))
- value)
- (match-end 1)))
- (nnmail-split-it (nth 2 split))))
+ (let ((split-rest (cddr split))
+ (end (match-end 0))
+ ;; The searched regexp is \(\(FIELD\).*\)\(VALUE\). So,
+ ;; start-of-value is the the point just before the
+ ;; beginning of the value, whereas after-header-name is
+ ;; the point just after the field name.
+ (start-of-value (match-end 1))
+ (after-header-name (match-end 2)))
+ ;; Start the next search just before the beginning of the
+ ;; VALUE match.
+ (setq end-point (1- start-of-value))
+ ;; Handle - RESTRICTs
+ (while (eq (car split-rest) '-)
+ ;; RESTRICT must start after-header-name and
+ ;; end after start-of-value, so that, for
+ ;; (any "foo" - "x-foo" "foo.list")
+ ;; we do not exclude foo.list just because
+ ;; the header is: ``To: x-foo, foo''
+ (goto-char end)
+ (if (and (re-search-backward (cadr split-rest)
+ after-header-name t)
+ (> (match-end 0) start-of-value))
+ (setq split-rest nil)
+ (setq split-rest (cddr split-rest))))
+ (when split-rest
+ (goto-char end)
+ (let ((value (nth 1 split)))
+ (if (symbolp value)
+ (setq value (cdr (assq value nnmail-split-abbrev-alist))))
+ ;; Someone might want to do a \N sub on this match, so get the
+ ;; correct match positions.
+ (re-search-backward value start-of-value))
+ (dolist (sp (nnmail-split-it (car split-rest)))
+ (unless (memq sp split-result)
+ (push sp split-result))))))
+ split-result))
;; Not in cache, compute a regexp for the field/value pair.
(t
(let* ((field (nth 0 split))
(value (nth 1 split))
- (regexp (concat "^\\(\\("
+ partial regexp)
+ (if (symbolp value)
+ (setq value (cdr (assq value nnmail-split-abbrev-alist))))
+ (if (string= ".*" (substring value 0 2))
+ (setq value (substring value 2)
+ partial ""))
+ (setq regexp (concat "^\\(\\("
(if (symbolp field)
(cdr (assq field nnmail-split-abbrev-alist))
field)
- "\\):.*\\)\\<\\("
- (if (symbolp value)
- (cdr (assq value nnmail-split-abbrev-alist))
- value)
- "\\)\\>")))
+ "\\):.*\\)"
+ (or partial "\\<")
+ "\\("
+ value
+ "\\)\\>"))
(push (cons split regexp) nnmail-split-cache)
;; Now that it's in the cache, just call nnmail-split-it again
;; on the same split, which will find it immediately in the cache.
(deffoo nntp-retrieve-groups (groups &optional server)
"Retrieve group info on GROUPS."
(nntp-possibly-change-group nil server)
- (save-excursion
- (set-buffer (nntp-find-connection-buffer nntp-server-buffer))
- ;; The first time this is run, this variable is `try'. So we
- ;; try.
- (when (eq nntp-server-list-active-group 'try)
- (nntp-try-list-active (car groups)))
- (erase-buffer)
- (let ((count 0)
- (received 0)
- (last-point (point-min))
- (nntp-inhibit-erase t)
- (command (if nntp-server-list-active-group "LIST ACTIVE" "GROUP")))
- (while groups
- ;; Send the command to the server.
- (nntp-send-command nil command (pop groups))
- (incf count)
- ;; Every 400 requests we have to read the stream in
- ;; order to avoid deadlocks.
- (when (or (null groups) ;All requests have been sent.
- (zerop (% count nntp-maximum-request)))
- (nntp-accept-response)
- (while (progn
- (goto-char last-point)
- ;; Count replies.
- (while (re-search-forward "^[0-9]" nil t)
- (incf received))
- (setq last-point (point))
- (< received count))
- (nntp-accept-response))))
+ (when (nntp-find-connection-buffer nntp-server-buffer)
+ (save-excursion
+ (set-buffer (nntp-find-connection-buffer nntp-server-buffer))
+ ;; The first time this is run, this variable is `try'. So we
+ ;; try.
+ (when (eq nntp-server-list-active-group 'try)
+ (nntp-try-list-active (car groups)))
+ (erase-buffer)
+ (let ((count 0)
+ (received 0)
+ (last-point (point-min))
+ (nntp-inhibit-erase t)
+ (command (if nntp-server-list-active-group "LIST ACTIVE" "GROUP")))
+ (while groups
+ ;; Send the command to the server.
+ (nntp-send-command nil command (pop groups))
+ (incf count)
+ ;; Every 400 requests we have to read the stream in
+ ;; order to avoid deadlocks.
+ (when (or (null groups) ;All requests have been sent.
+ (zerop (% count nntp-maximum-request)))
+ (nntp-accept-response)
+ (while (progn
+ (goto-char last-point)
+ ;; Count replies.
+ (while (re-search-forward "^[0-9]" nil t)
+ (incf received))
+ (setq last-point (point))
+ (< received count))
+ (nntp-accept-response))))
- ;; Wait for the reply from the final command.
- (goto-char (point-max))
- (re-search-backward "^[0-9]" nil t)
- (when (looking-at "^[23]")
- (while (progn
- (goto-char (point-max))
- (if (not nntp-server-list-active-group)
- (not (re-search-backward "\r?\n" (- (point) 3) t))
- (not (re-search-backward "^\\.\r?\n" (- (point) 4) t))))
- (nntp-accept-response)))
-
- ;; Now all replies are received. We remove CRs.
- (goto-char (point-min))
- (while (search-forward "\r" nil t)
- (replace-match "" t t))
+ ;; Wait for the reply from the final command.
+ (goto-char (point-max))
+ (re-search-backward "^[0-9]" nil t)
+ (when (looking-at "^[23]")
+ (while (progn
+ (goto-char (point-max))
+ (if (not nntp-server-list-active-group)
+ (not (re-search-backward "\r?\n" (- (point) 3) t))
+ (not (re-search-backward "^\\.\r?\n" (- (point) 4) t))))
+ (nntp-accept-response)))
- (if (not nntp-server-list-active-group)
- (progn
- (copy-to-buffer nntp-server-buffer (point-min) (point-max))
- 'group)
- ;; We have read active entries, so we just delete the
- ;; superfluous gunk.
+ ;; Now all replies are received. We remove CRs.
(goto-char (point-min))
- (while (re-search-forward "^[.2-5]" nil t)
- (delete-region (match-beginning 0)
- (progn (forward-line 1) (point))))
- (copy-to-buffer nntp-server-buffer (point-min) (point-max))
- 'active))))
+ (while (search-forward "\r" nil t)
+ (replace-match "" t t))
+
+ (if (not nntp-server-list-active-group)
+ (progn
+ (copy-to-buffer nntp-server-buffer (point-min) (point-max))
+ 'group)
+ ;; We have read active entries, so we just delete the
+ ;; superfluous gunk.
+ (goto-char (point-min))
+ (while (re-search-forward "^[.2-5]" nil t)
+ (delete-region (match-beginning 0)
+ (progn (forward-line 1) (point))))
+ (copy-to-buffer nntp-server-buffer (point-min) (point-max))
+ 'active)))))
(deffoo nntp-retrieve-articles (articles &optional group server)
(nntp-possibly-change-group group server)
+1999-07-06 11:41:59 Lars Magne Ingebrigtsen <larsi@gnus.org>
+
+ * gnus.texi (Mail Source Specifiers): Fix.
+ (Mail Source Customization): Deleted obsolete vars.
+
+1999-07-05 05:16:55 Laura Conrad <lconrad@world.std.com>
+
+ * gnus.texi (Mail in a Newsreader): Rewrite.
+
1999-07-04 04:33:50 Lars Magne Ingebrigtsen <larsi@gnus.org>
* gnus.texi (Posting Styles): Fix.
and, if so, how to do it. It does not say whether parts are
@emph{actually} displayed inline.
-@item mm-inlines-types
+@item mm-inlined-types
This, on the other hand, says what types are to be displayed inline, if
they satisfy the conditions set by the variable above. It's a list of
@sc{mime} media types.
@item mm-automatic-display
This is a list of types that are to be displayed ``automatically'', but
-only if the above variable allows it. That is, only inlinable parts are
-usually displayed automatically, but in the end, this is up to the
-display agent that's using the @sc{mime} library.
+only if the above variable allows it. That is, only inlinable parts can
+be displayed automatically.
@item mm-attachment-override-types
Some @sc{mime} agents create parts that have a content-disposition of
@samp{attachment}. This variable allows overriding that disposition and
-displaying the part inline.
+displaying the part inline. (Note that the disposition is only
+overridden if we are able to, and want to, display the part inline.)
@item mm-discouraged-alternatives
List of @sc{mime} types that are discouraged when viewing
("text/html" "text/richtext")
@end lisp
-@item mm-all-images-fit
-If non-@code{nil}, all images will be deemed to fit into the buffer,
-even when they don't.
+@item mm-inline-large-images-p
+When displaying inline images that are larger than the window, XEmacs
+does not enable scrolling, which means that you cannot see the whole
+image. To prevent this, the library tries to determine the image size
+before displaying it inline, and if it doesn't fit the window, the
+library will display it externally (e.g. with @samp{ImageMagick} or
+@samp{xv}). Setting this variable to @code{t} disables this check and
+makes the library display all inline images as inline, regardless of
+their size.
+
@end table
@c \input texinfo @c -*-texinfo-*-
@setfilename gnus
-@settitle Pterodactyl Gnus 0.91 Manual
+@settitle Pterodactyl Gnus 0.92 Manual
@synindex fn cp
@synindex vr cp
@synindex pg cp
@tex
@titlepage
-@title Pterodactyl Gnus 0.91 Manual
+@title Pterodactyl Gnus 0.92 Manual
@author by Lars Magne Ingebrigtsen
@page
spool or your mbox file. All at the same time, if you want to push your
luck.
-This manual corresponds to Pterodactyl Gnus 0.91.
+This manual corresponds to Pterodactyl Gnus 0.92.
@end ifinfo
Gnus does not behave like traditional mail readers. If you want to make
it behave that way, you can, but it's an uphill battle.
-Gnus, by default, handles all its group using the same approach. This
+Gnus, by default, handles all its groups using the same approach. This
approach is very newsreaderly---you enter a group, see the new/unread
messages, and when you read the messages, they get marked as read, and
you don't see them any more. (Unless you explicitly ask for them.)
Mail}.
What many Gnus users find, after using it a while for both news and
-mail, is that the transport becomes more and more irrelevant. What
-becomes important is the size of the receiving audience.
+mail, is that the transport mechanism has very little to do with how
+they want to treat a message.
Many people subscribe to several mailing lists. These are transported
-via SMTP, and are therefore mail. Some people have local news groups
-which have only a handful of readers. These are transported via NNTP,
-and are therefore news.
+via SMTP, and are therefore mail. But we might go for weeks without
+answering, or even reading these messages very carefully. We may not
+need to save them because if we should need to read one again, they are
+archived somewhere else.
+
+Some people have local news groups which have only a handful of readers.
+These are transported via NNTP, and are therefore news. But we may need
+to read and answer a large fraction of the messages very carefully in
+order to do our work. And there may not be an archive, so we may need
+to save the interesting messages the same way we would personal mail.
The important distinction turns out to be not the transport mechanism,
-but whether the messages are @dfn{personal} or @dfn{public}. Many users
-then subtly alter the behavior of Gnus according to these two
-categories.
+but other factors such as how interested we are in the subject matter,
+or how easy it is to retrieve the message if we need to read it again.
+
+Gnus provides many options for sorting mail into ``groups'' which behave
+like newsgroups, and for treating each group (whether mail or news)
+differently.
Some users never get comfortable using the Gnus (ahem) paradigm and wish
that Gnus should grow up and be a male, er, mail reader. It is possible
@cindex mail spool
@cindex mail source
-You tell Gnus how to fetch mail by creating a @dfn{mail source
-specifier}.
+You tell Gnus how to fetch mail by setting @code{mail-sources}
+(@pxref{Fetching Mail}) to a @dfn{mail source specifier}.
Here's an example:
variables.
@table @code
-@item mail-source-movemail-program
-@vindex mail-source-movemail-program
-A command to be executed to move mail from the inbox. The default is
-@samp{movemail}.
-
-This can also be a function. In that case, the function will be
-called with two parameters -- the name of the INBOX file, and the file
-to be moved to.
-
-@item mail-source-movemail-args
-@vindex mail-source-movemail-args
-Extra arguments to give to the command described above.
-
@item mail-source-crash-box
@vindex mail-source-crash-box
File where mail will be stored while processing it. The default is
;; Other mailing lists...
(any "procmail@@informatik\\.rwth-aachen\\.de" "procmail.list")
(any "SmartList@@informatik\\.rwth-aachen\\.de" "SmartList.list")
+ ;; Both lists below have the same suffix, so prevent
+ ;; cross-posting to mkpkg.list of messages posted only to
+ ;; the bugs- list, but allow cross-posting when the
+ ;; message was really cross-posted.
+ (any "bugs-mypackage@@somewhere" "mypkg.bugs")
+ (any "mypackage@@somewhere\" - "bugs-mypackage" "mypkg.list")
;; People...
(any "larsi@@ifi\\.uio\\.no" "people.Lars_Magne_Ingebrigtsen"))
;; Unmatched mail goes to the catch all group.
examples.
@item
-@var{(FIELD VALUE SPLIT)}: If the split is a list, the first element of
-which is a string, then store the message as specified by SPLIT, if
-header FIELD (a regexp) contains VALUE (also a regexp).
+@var{(FIELD VALUE [- RESTRICT [- RESTRICT [...]]] SPLIT)}: If the split
+is a list, the first element of which is a string, then store the
+message as specified by SPLIT, if header FIELD (a regexp) contains VALUE
+(also a regexp). If RESTRICT (yet another regexp) matches some string
+after FIELD and before the end of the matched VALUE, the SPLIT is
+ignored. If none of the RESTRICT clauses match, SPLIT is processed.
@item
@var{(| SPLIT...)}: If the split is a list, and the first element is
Matt Armstrong,
Marc Auslander,
Miles Bader,
+Alexei V. Barantsev,
Frank Bennett,
Robert Bihlmeyer,
Chris Bone,
Mark Borges,
Mark Boyns,
Lance A. Brown,
+Rob Browning,
Kees de Bruin,
Martin Buchholz,
Joe Buehler,
David Charlap,
Dan Christensen,
Kevin Christian,
+Jae-you Chung, @c ?
+James H. Cloos, Jr.,
+Laura Conrad,
Michael R. Cook,
Glenn Coombs,
+Andrew J. Cosgriff,
+Neil Crellin,
Frank D. Cringle,
Geoffrey T. Dairiki,
Andre Deparade,
Michael Welsh Duggan,
Dave Edmondson,
Paul Eggert,
+Mark W. Eichin,
Karl Eichwalder,
Enami Tsugutomo, @c Enami
Michael Ernst,
Sam Falkner,
Nelson Jose dos Santos Ferreira,
Sigbjorn Finne,
+Sven Fischer,
Paul Fisher,
Decklin Foster,
Gary D. Foster,
Yoshiki Hayashi, @c ?
P. E. Jareth Hein,
Hisashige Kenji, @c Hisashige
+Scott Hofmann,
Marc Horowitz,
Gunnar Horrigmo,
Richard Hoskins,
Brad Howes,
+Miguel de Icaza,
François Felix Ingrand,
+Tatsuya Ichikawa, @c ?
Ishikawa Ichiro, @c Ishikawa
Lee Iverson,
Iwamuro Motonori, @c Iwamuro
Rajappa Iyer,
Andreas Jaeger,
+Adam P. Jenkins,
Randell Jesup,
Fred Johansen,
Gareth Jones,
Simon Josefsson,
Greg Klanderman,
Karl Kleinpaste,
+Michael Klingbeil,
Peter Skov Knudsen,
Shuhei Kobayashi, @c Kobayashi
+Petr Konecny,
Koseki Yoshinori, @c Koseki
Thor Kristoffersen,
Jens Lautenbacher,
Ken Olstad,
Masaharu Onishi, @c Onishi
Hideki Ono, @c Ono
+Ettore Perazzoli,
William Perry,
Stephen Peters,
Jens-Ulrik Holger Petersen,
Richard Stallman,
Greg Stark,
Sam Steingold,
+Paul Stevenson,
Jonas Steverud,
Paul Stodghill,
+Kiyokazu Suto, @c Suto
Kurt Swanson,
Samuel Tardieu,
Teddy,
Chuck Thompson,
+Tozawa Akihiko, @c Tozawa
Philippe Troin,
James Troup,
Trung Tran-Duc,
+Jack Twilley,
Aaron M. Ucko,
Aki Vehtari,
Didier Verna,
+Vladimir Volovich,
Jan Vroonhof,
Stefan Waldherr,
Pete Ware,
Allow "orphan" scores in the Agent scoring.
@item
+@example
+ - Edit article's summary line.
+ - End edit
+ - Sort lines in buffer by subject
+
+ --> the old subject line appears in Summary buffer, not the one that was
+ just changed to.
+@end example
+
+@item
Solve the halting problem.
@c TODO
\input texinfo @c -*-texinfo-*-
@setfilename message
-@settitle Pterodactyl Message 0.91 Manual
+@settitle Pterodactyl Message 0.92 Manual
@synindex fn cp
@synindex vr cp
@synindex pg cp
@tex
@titlepage
-@title Pterodactyl Message 0.91 Manual
+@title Pterodactyl Message 0.92 Manual
@author by Lars Magne Ingebrigtsen
@page
* Key Index:: List of Message mode keys.
@end menu
-This manual corresponds to Pterodactyl Message 0.91. Message is
+This manual corresponds to Pterodactyl Message 0.92. Message is
distributed with the Gnus distribution bearing the same version number
as this manual.
projects / elisp / gnus.git- / commitdiff