Gecko [ 122.154.134.11 ]

Name	Size	Permission
binhex.elc	9.01 KB	-rw-r--r--
blessmail.el	2.51 KB	-rw-r--r--
emacsbug.elc	7.55 KB	-rw-r--r--
feedmail.elc	79.59 KB	-rw-r--r--
footnote.elc	21.09 KB	-rw-r--r--
hashcash.elc	10.81 KB	-rw-r--r--
mail-extr.elc	33.9 KB	-rw-r--r--
mail-hist.elc	13.74 KB	-rw-r--r--
mail-utils.elc	9.55 KB	-rw-r--r--
mailabbrev.elc	13.96 KB	-rw-r--r--
mailalias.elc	13.52 KB	-rw-r--r--
mailclient.elc	3.56 KB	-rw-r--r--
mailheader.elc	5.92 KB	-rw-r--r--
mailpost.elc	2.3 KB	-rw-r--r--
metamail.elc	4.44 KB	-rw-r--r--
mspools.elc	7.25 KB	-rw-r--r--
reporter.elc	9.65 KB	-rw-r--r--
rfc2368.elc	2.46 KB	-rw-r--r--
rfc822.elc	5.71 KB	-rw-r--r--
rmail-spam-filter.elc	13.24 KB	-rw-r--r--
rmail.elc	113.93 KB	-rw-r--r--
rmailedit.elc	8.83 KB	-rw-r--r--
rmailkwd.elc	5.12 KB	-rw-r--r--
rmailmm.elc	11.05 KB	-rw-r--r--
rmailmsc.elc	1.56 KB	-rw-r--r--
rmailout.elc	15.73 KB	-rw-r--r--
rmailsort.elc	6.33 KB	-rw-r--r--
rmailsum.elc	52.51 KB	-rw-r--r--
sendmail.elc	51.72 KB	-rw-r--r--
smtpmail.elc	21.58 KB	-rw-r--r--
supercite.elc	58.99 KB	-rw-r--r--
uce.elc	7.66 KB	-rw-r--r--
undigest.elc	7.88 KB	-rw-r--r--
unrmail.elc	4.69 KB	-rw-r--r--
uudecode.elc	6.19 KB	-rw-r--r--

Code Editor : feedmail.elc

;ELC���
;;; Compiled by mockbuild@c6b8.bsys.dev.centos.org on Thu Feb 19 13:04:21 2015
;;; from file /builddir/build/BUILD/emacs-23.1/lisp/mail/feedmail.el
;;; in Emacs version 23.1.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.
(if (and (boundp 'emacs-version)
	 (< (aref emacs-version (1- (length emacs-version))) ?A)
	 (or (and (boundp 'epoch::version) epoch::version)
	     (string-lessp emacs-version "19.29")))
    (error "`feedmail.el' was compiled for Emacs 19.29 or later"))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(byte-code "\301B\302\303!\210\304\305\306\"\210\307\310\311\312\313\314\313\315\316\317&	\210\307\320\311\321\316\310%\210\307\322\311\323\316\310%\210\307\324\311\325\316\310%\207" [current-load-list feedmail-patch-level (lambda (#1=#:defconst-tmp-var) (defconst feedmail-patch-level #1#)) "8" autoload mail-do-fcc "sendmail" custom-declare-group feedmail nil "Assist other email packages to massage outgoing messages." :link (url-link "http://www.carpenter.org/feedmail/feedmail.html") (emacs-commentary-link "feedmail") :group mail feedmail-misc "Miscellaneous feedmail options that don't fit in other groups." feedmail-headers "Options related to manipulating specific headers or types of headers." feedmail-queue "Options related to queuing messages for later sending."] 10)
#@648 *If non-nil, give a y-or-n confirmation prompt before sending mail.
This is done after the message is completely prepped, and you'll be
looking at the top of the message in a buffer when you get the prompt.
If set to the symbol 'queued, give the confirmation prompt only while
running the queue (however, the prompt is always suppressed if you are
processing the queue via `feedmail-run-the-queue-no-prompts').  If set
to the symbol 'immediate, give the confirmation prompt only when
sending immediately.  For any other non-nil value, prompt in both
cases.  You can give a timeout for the prompt; see variable
`feedmail-confirm-outgoing-timeout'.
(custom-declare-variable 'feedmail-confirm-outgoing 'nil '(#$ . -1396) :group 'feedmail-misc :type 'boolean)
#@310 *If non-nil, a timeout in seconds at the send confirmation prompt.
If a positive number, it's a timeout before sending.  If a negative
number, it's a timeout before not sending.  This will not work if your
version of Emacs doesn't include the function `y-or-n-p-with-timeout'
(e.g., some versions of XEmacs).
(custom-declare-variable 'feedmail-confirm-outgoing-timeout 'nil '(#$ . -2159) :group 'feedmail-misc :type '(choice (const nil) integer))
#@227 *If non-nil remove Bcc: lines from the message headers.
In any case, the Bcc: lines do participate in the composed address
list.  You may want to leave them in if you're using sendmail
(see `feedmail-buffer-eating-function').
(custom-declare-variable 'feedmail-nuke-bcc 't '(#$ . -2613) :group 'feedmail-headers :type 'boolean)
#@241 *If non-nil remove Resent-Bcc: lines from the message headers.
In any case, the Resent-Bcc: lines do participate in the composed
address list.  You may want to leave them in if you're using sendmail
(see `feedmail-buffer-eating-function').
(custom-declare-variable 'feedmail-nuke-resent-bcc 't '(#$ . -2948) :group 'feedmail-headers :type 'boolean)
#@1233 *Where Bcc:/Resent-Bcc: addresses should appear in the envelope list.
Addresses for the message envelope are deduced by examining
appropriate address headers in the message.  Generally, they will show
up in the list of deduced addresses in the order that the headers
happen to appear (duplicate addresses are eliminated in any case).
This variable can be set to the symbol 'first, in which case the
Bcc:/Resent-Bcc: addresses will appear at the beginning in the list;
or, it can be set to the symbol 'last, in which case they will appear
at the end of the list.

Why should you care?  Well, maybe you don't, and certainly the same
things could be accomplished by affecting the order of message headers
in the outgoing message.  Some people use Bcc: as a way of getting
their own "come back" copy of each message they send.  If Bcc:
addresses are not handled first, there can be substantial delays in
seeing the message again.  Some configurations of sendmail, for example,
seem to try to deliver to each addressee at least once, immediately
and serially, so slow SMTP conversations can add up to a delay.  There
is an option for either 'first or 'last because you might have a
delivery agent that processes the addresses backwards.
(custom-declare-variable 'feedmail-deduce-bcc-where 'nil '(#$ . -3305) :group 'feedmail-headers :type 'boolean)
#@386 *If non-nil do smart filling of addressee header lines.
Smart filling means breaking long lines at appropriate points and
making continuation lines.  Despite the function name, it includes
To:, Cc:, Bcc: (and their Resent-* forms), as well as From: and
Reply-To: (though they seldom need it).  If nil, the lines are left
as-is.  The filling is done after mail address alias expansion.
(custom-declare-variable 'feedmail-fill-to-cc 't '(#$ . -4656) :group 'feedmail-headers :type 'boolean)
#@45 *Fill column used by `feedmail-fill-to-cc'.
(custom-declare-variable 'feedmail-fill-to-cc-fill-column 'default-fill-column '(#$ . -5151) :group 'feedmail-headers :type 'integer)
#@288 *If non-nil remove [Resent-]Bcc: lines in message copies saved via Fcc:.
This is independent of whether the Bcc: header lines are actually sent
with the message (see feedmail-nuke-bcc).  Though not implied in the name,
the same Fcc: treatment applies to both Bcc: and Resent-Bcc: lines.
(custom-declare-variable 'feedmail-nuke-bcc-in-fcc 'nil '(#$ . -5336) :group 'feedmail-headers :type 'boolean)
#@280 *If non-nil remove body of message in copies saved via Fcc:.
If a positive integer value, leave (up to) that many lines of the
beginning of the body intact.  The result is that the Fcc: copy will
consist only of the message headers, serving as a sort of an outgoing
message log.
(custom-declare-variable 'feedmail-nuke-body-in-fcc 'nil '(#$ . -5741) :group 'feedmail-headers :type '(choice (const nil) (const t) integer))
#@333 *If non-nil, force the calling of `expand-mail-aliases'.
Normally, feedmail tries to figure out if you're using mailalias or
mailabbrevs and only calls `expand-mail-aliases' if it thinks you're
using the mailalias package.  This user option can be used to force
the issue since there are configurations which fool the figuring
out.
(custom-declare-variable 'feedmail-force-expand-mail-aliases 'nil '(#$ . -6170) :group 'feedmail-headers :type 'boolean)
#@368 *If non-nil, remove header lines which have no contents.
A completely empty Subject: header is always removed, regardless of
the setting of this variable.  The only time you would want them left
in would be if you used some headers whose presence indicated
something rather than their contents.  This is rare in Internet email
but common in some proprietary systems.
(custom-declare-variable 'feedmail-nuke-empty-headers 't '(#$ . -6630) :group 'feedmail-headers :type 'boolean)
#@1218 *If non-nil and the email has no Sender: header, use this value.
May be nil, in which case nothing in particular is done with respect
to Sender: lines.  By design, will not replace an existing Sender:
line, but you can achieve that with a fiddle-plex 'replace action.
NB: it makes no sense to use the value t since there is no sensible
default for Sender:.

If not nil, it may be a string, a fiddle-plex, or a function which
returns either nil, t, a string, or a fiddle-plex (or, in fact,
another function, but let's not be ridiculous).  If a string, it
should be just the contents of the header, not the name of the header
itself nor the trailing newline.  If a function, it will be called
with no arguments.  For an explanation of fiddle-plexes, see the
documentation for the variable `feedmail-fiddle-plex-blurb'.  In all
cases the name element of the fiddle-plex is ignored and is hardwired
by feedmail to either "X-Sender" or "X-Resent-Sender".

You can probably leave this nil, but if you feel like using it, a good
value would be a string of a fully-qualified domain name form of your
address.  For example, "bill@bubblegum.net (WJCarpenter)".  The Sender:
header is fiddled after the From: header is fiddled.
(custom-declare-variable 'feedmail-sender-line 'nil '(#$ . -7117) :group 'feedmail-headers :type '(choice (const nil) string))
#@452 *If non-nil, force writing file as binary (this applies to queues and Fcc:).
On systems where there is a difference between binary and text files,
feedmail will temporarily manipulate the values of `buffer-file-type'
and/or `default-buffer-file-type' to make the writing as binary.  If
nil, writing will be in text mode.  On systems where there is no
distinction or where it is controlled by other variables or other
means, this option has no effect.
(custom-declare-variable 'feedmail-force-binary-write 't '(#$ . -8468) :group 'feedmail-misc :type 'boolean)
#@1418 *If non-nil and the email has no From: header, use this value.
May be t, in which case a default is computed (and you probably won't
be happy with it).  May be nil, in which case nothing in particular is
done with respect to From: lines.  By design, will not replace an
existing From: line, but you can achieve that with a fiddle-plex 'replace
action.

If neither nil nor t, it may be a string, a fiddle-plex, or a function
which returns either nil, t, a string, or a fiddle-plex (or, in fact,
another function, but let's not be ridiculous).  If a string, it
should be just the contents of the header, not the name of the header
itself nor the trailing newline.  If a function, it will be called
with no arguments.  For an explanation of fiddle-plexes, see the
documentation for the variable `feedmail-fiddle-plex-blurb'.  In all
cases the name element of the fiddle-plex is ignored and is hardwired
by feedmail to either "X-From" or "X-Resent-From".

A good value would be a string fully-qualified domain name form of
your address.  For example, "bill@bubblegum.net (WJCarpenter)".  The
default value of this variable uses the standard elisp variable
`user-mail-address' which should be set on every system but has a decent
chance of being wrong.  It also honors `mail-from-style'.  Better to set
this variable explicitly to the string you want or find some other way
to arrange for the message to get a From: line.
(custom-declare-variable 'feedmail-from-line 't '(#$ . -9036) :group 'feedmail-headers :type '(choice (const t) (const nil) string))
#@1348 *If non-nil, deduce message envelope "from" from header From: or Sender:.
In other words, if there is a Sender: header in the message, temporarily
change the value of `user-mail-address' to be the same while the message
is being sent.  If there is no Sender: header, use the From: header,
if any.  Address values are taken from the actual message just before
it is sent, and the process is independent of the values of
`feedmail-from-line' and/or `feedmail-sender-line'.

There are many and good reasons for having the message header
From:/Sender: be different from the message envelope "from"
information.  However, for most people and for most circumstances, it
is usual for them to be the same (this is probably especially true for
the case where the user doesn't understand the difference between the
two in the first place).

The idea behind this feature is that you can have everything set up
some normal way for yourself.  If for some reason you want to send a
message with another From: line, you can just type it at the top of
the message, and feedmail will take care of "fixing up" the envelope
"from".  This only works for mail senders which make use of
`user-mail-address' as the envelope "from" value.  For some mail
senders (e.g., feedmail-buffer-to-bin-mail), there is no simple way to
influence what they will use as the envelope.
(custom-declare-variable 'feedmail-deduce-envelope-from 't '(#$ . -10594) :group 'feedmail-headers :type 'boolean)
#@30 *See feedmail-x-mailer-line.
(custom-declare-variable 'feedmail-x-mailer-line-user-appendage 'nil '(#$ . -12062) :group 'feedmail-headers :type '(choice (const nil) (const t) string))
#@1339 *Control the form of an X-Mailer: header in an outgoing message.
Moderately useful for debugging, keeping track of your correspondents'
mailer preferences, or just wearing your MUA on your sleeve.  You
should probably know that some people are fairly emotional about the
presence of X-Mailer: lines in email.

If nil, nothing is done about X-Mailer:.

If t, an X-Mailer: header of a predetermined format is produced,
combining its efforts with any existing X-Mailer: header.  If you want
to take the default construct and just add a little blob of your own
at the end, define the variable feedmail-x-mailer-line-user-appendage
as that blob string.  A value of t is equivalent to using the function
feedmail-default-x-mailer-generator.

If nil, nothing is done about Message-Id:.

If t, a Message-Id: header of a predetermined format is produced, but
only if there is not already a Message-Id: in the message.  A value of
t is equivalent to using the function feedmail-default-message-id-generator.

If neither nil nor t, it may be a string, a fiddle-plex, or a function
which returns either nil, t, a string, or a fiddle-plex (or, in fact,
another function, but let's not be ridiculous).  If a string, it
should be just the contents of the header, not the name of the header
itself nor the trailing newline.  If a function, it will be called
with one argument: the possibly-nil name of the file associated with
the message buffer.  For an explanation of fiddle-plexes, see the
documentation for the variable `feedmail-fiddle-plex-blurb'.  In all
cases the name element of the fiddle-plex is ignored and is hardwired
by feedmail to either "Message-Id" or "Resent-Message-Id".

You should let feedmail generate a Message-Id: for you unless you are sure
that whatever you give your messages to will do it for you (e.g., most
configurations of sendmail).  Even if the latter case is true, it
probably won't hurt you to generate your own, and it will then show up
in the saved message if you use Fcc:.
(custom-declare-variable 'feedmail-message-id-generator 't '(#$ . -13747) :group 'feedmail-headers :type '(choice (const t) (const nil) function))
#@554 *If non-nil, used as a suffix for generating unique Message-Id: headers.
The function `feedmail-default-message-id-generator' creates its work based
on a formatted date-time string, a random number, and a domain-looking suffix.
You can control the suffix used by assigning a string value to this variable.
If you don't supply one, the value of the variable `user-mail-address' will be
used.  If the value of `feedmail-message-id-suffix' contains an "@" character,
the string will be used verbatim, else an "@" character will be prepended
automatically.
(custom-declare-variable 'feedmail-message-id-suffix 'nil '(#$ . -15218) :group 'feedmail-headers :type '(choice (const nil) string))
#@1444 *Specifies the creation of a Date: header field.

If nil, nothing is done about Date:.

If t, a Date: header of a predetermined format is produced, but only
if there is not already a Date: in the message.  A value of t is
equivalent to using the function `feedmail-default-date-generator'.

If neither nil nor t, it may be a string, a fiddle-plex, or a function
which returns either nil, t, a string, or a fiddle-plex (or, in fact,
another function, but let's not be ridiculous).  If a string, it
should be just the contents of the header, not the name of the header
itself nor the trailing newline.  If a function, it will be called
with one argument: the possibly-nil name of the file associated with
the message buffer.  For an explanation of fiddle-plexes, see the
documentation for the variable `feedmail-fiddle-plex-blurb'.  In all
cases the name element of the fiddle-plex is ignored and is hardwired
by feedmail to either "Date" or "Resent-Date".

If you decide to format your own date field, do us all a favor and know
what you're doing.  Study the relevant parts of RFC-822 and RFC-1123.
Don't make me come up there!

You should let feedmail generate a Date: for you unless you are sure
that whatever you give your messages to will do it for you (e.g., most
configurations of sendmail).  Even if the latter case is true, it
probably won't hurt you to generate your own, and it will then show up
in the saved message if you use Fcc:.
(custom-declare-variable 'feedmail-date-generator 't '(#$ . -15913) :group 'feedmail-headers :type '(choice (const t) (const nil) function))
#@352 *Non-nil means fiddled header fields should go at the top of the header.
nil means insert them at the bottom.  This is mostly a novelty issue since
the standards define the ordering of header fields to be immaterial and it's
fairly likely that some MTA along the way will have its own idea of what the
order should be, regardless of what you specify.
(custom-declare-variable 'feedmail-fiddle-headers-upwardly 't '(#$ . -17504) :group 'feedmail-headers :type 'boolean)
#@626 If non-nil, should be a list of one or more fiddle-plexes.
Each element of the list can also be a function which returns a
fiddle-plex.

feedmail will use this list of fiddle-plexes to manipulate user-specified
message header fields.  It does this after it has completed all normal
message header field manipulation and before calling `feedmail-last-chance-hook'.

For an explanation of fiddle-plexes, see the documentation for the
variable `feedmail-fiddle-plex-blurb'.  In contrast to some other fiddle-plex
manipulation functions, in this context, it makes no sense to have an element
which is nil, t, or a simple string.
(custom-declare-variable 'feedmail-fiddle-plex-user-list 'nil '(#$ . 17980) :group 'feedmail-headers :type '(repeat (choice function) sexp))
#@1077 If non-nil, transmit message separately to each addressee.
feedmail normally accumulates a list of addressees and passes the message
along with that list to a buffer-eating function which expects any number
of addressees.  If this variable is non-nil, however, feedmail will
repeatedly call the same buffer-eating function.  Each time, the list of
addressees will be just one item from the original list.  This only affects
the message envelope addresses and doesn't affect what appears in the
message headers except as noted.

Spray mode is usually pointless, and if you can't think of a good reason for
it, you should avoid it since it is inherently less efficient than normal
multiple delivery.  One reason to use it is to overcome mis-featured mail
transports which betray your trust by revealing Bcc: addressees in the
headers of a message.  Another use is to do a crude form of mailmerge, for
which see `feedmail-spray-address-fiddle-plex-list'.

If one of the calls to the buffer-eating function results in an error,
what happens next is carelessly defined, so beware.
(custom-declare-variable 'feedmail-enable-spray 'nil '(#$ . 18754) :group 'feedmail-spray :type 'boolean)
#@85 Do not set or change this variable.  See `feedmail-spray-address-fiddle-plex-list'.
(defvar feedmail-spray-this-address nil (#$ . 19942))
#@2241 User-supplied specification for a crude form of mailmerge capability.
When spraying is enabled, feedmail composes a list of envelope addresses.
In turn, `feedmail-spray-this-address' is temporarily set to each address
(stripped of any comments and angle brackets) and calls a function which
fiddles message headers according to this variable.  See the documentation for
`feedmail-fiddle-plex-blurb', for an overview of fiddle-plex data structures.

May be nil, in which case nothing in particular is done about message
headers for specific addresses.

May be t, in which case a "To:" header is added to the message with
the stripped address as the header contents.  The fiddle-plex operator
is 'supplement.

May be a string, in which case the string is assumed to be the name of
a message header field with the stripped address serving as the value.
The fiddle-plex operator is 'supplement.

May be a function, in which case it is called with no arguments and is
expected to return nil, t, a string, another function, or a fiddle-plex.
The result is used recursively.

May be a list of any combination of the foregoing and fiddle-plexes.  (A
value for this variable which consists of a single fiddle-plex must be
nested inside another list to avoid ambiguity.)  If a list, each item
is acted on in turn as described above.

For example,

(setq feedmail-spray-address-fiddle-plex-list 'my-address-embellisher)

The idea of the example is that, during spray mode, as each message is
about to be transmitted to an individual address, the function will be
called and will consult `feedmail-spray-this-address' to find the
stripped envelope email address (no comments or angle brackets).  The
function should return an embellished form of the address.

The recipe for sending form letters is:  (1) create a message with all
addressees on Bcc: headers; (2) tell feedmail to remove Bcc: headers
before sending the message; (3) create a function which will embellish
stripped addresses, if desired; (4) define `feedmail-spray-address-fiddle-plex-list'
appropriately; (5) send the message with `feedmail-enable-spray' set
non-nil; (6) stand back and watch co-workers wonder at how efficient
you are at accomplishing inherently inefficient things.
(custom-declare-variable 'feedmail-spray-address-fiddle-plex-list 'nil '(#$ . 20088) :group 'feedmail-spray :type 'sexp)
#@1235 *If non-nil, provide for stashing outgoing messages in a queue.
This is the master on/off switch for feedmail message queuing.
Queuing is quite handy for laptop-based users.  It's also handy if you
get a lot of mail and process it more or less sequentially.  For
example, you might change your mind about contents of a reply based on
a message you see a bit later.

There is a separate queue for draft messages, intended to prevent
you from accidentally sending incomplete messages.  The queues are
disk-based and intended for later transmission.  The messages are
queued in their raw state as they appear in the mail-mode buffer and
can be arbitrarily edited later, before sending, by visiting the
appropriate file in the queue directory (and setting the buffer to
mail-mode or whatever).  If you visit a file in the queue directory
and try to queue it again, it will just get saved in its existing file
name.  You can move a message from the draft to the main queue or vice
versa by pretending to send it and then selecting whichever queue
directory you want at the prompt.  The right thing will happen.

To transmit all the messages in the queue, invoke the command
`feedmail-run-the-queue' or `feedmail-run-the-queue-no-prompts'.
(custom-declare-variable 'feedmail-enable-queue 'nil '(#$ . -22457) :group 'feedmail-queue :type 'boolean)
#@283 *If non-nil, give a y-or-n confirmation prompt before running the queue.
Prompt even if the queue is about to be processed as a result of a call to
`feedmail-run-the-queue-no-prompts'.  This gives you a way to bail out
without having to answer no to the individual message prompts.
(custom-declare-variable 'feedmail-queue-runner-confirm-global 'nil '(#$ . -23805) :group 'feedmail-queue :type 'boolean)
#@172 *Name of a directory where messages will be queued.
Directory will be created if necessary.  Should be a string that
doesn't end with a slash.  Default is "$HOME/mail/q".
(custom-declare-variable 'feedmail-queue-directory '(concat (getenv "HOME") "/mail/q") '(#$ . -24216) :group 'feedmail-queue :type 'string)
#@182 *Name of a directory where draft messages will be queued.
Directory will be created if necessary.  Should be a string that
doesn't end with a slash.  Default is "$HOME/mail/draft".
(custom-declare-variable 'feedmail-queue-draft-directory '(concat (getenv "HOME") "/mail/draft") '(#$ . -24534) :group 'feedmail-queue :type 'string)
#@366 *If non-nil, feedmail will ask what you want to do with the message.
Default choices for the message action prompt will include sending it
immediately, putting it in the main queue, putting it in the draft
queue, or returning to the buffer to continue editing.  Only matters if
queuing is enabled.  If nil, the message is placed in the main queue
without a prompt.
(custom-declare-variable 'feedmail-ask-before-queue 't '(#$ . -24872) :group 'feedmail-queue :type 'boolean)
#@161 *A string which will be used for the message action prompt.
If it contains a "%s", that will be replaced with the value of
`feedmail-ask-before-queue-default'.
(custom-declare-variable 'feedmail-ask-before-queue-prompt '"FQM: Message action (q, i, d, e, ?)? [%s]: " '(#$ . -25353) :group 'feedmail-queue :type 'string)
#@166 *A string which will be used for repompting after invalid input.
If it contains a "%s", that will be replaced with the value of
`feedmail-ask-before-queue-default'.
(custom-declare-variable 'feedmail-ask-before-queue-reprompt '"FQM: Please type q, i, d, or e; or ? for help [%s]: " '(#$ . -25679) :group 'feedmail-queue :type 'string)
#@239 *Meaning if user hits return in response to the message action prompt.
Should be a character or a string; if a string, only the first
character is significant.  Useful values are those described in
the help for the message action prompt.
(custom-declare-variable 'feedmail-ask-before-queue-default '"queue" '(#$ . -26021) :group 'feedmail-queue :type '(choice string integer))
#@571 An alist of choices for the message action prompt.
All of the values are function names, except help, which is a special
symbol that calls up help for the prompt (the help describes the
actions from the standard alist).  To customize your own choices,
define a similar alist called `feedmail-prompt-before-queue-user-alist'.
The actual alist used for message action will be the standard alist
overlaid with the user-alist.  To neutralize an item in the standard
alist without providing a replacement, define an appropriate element
in the user alist with a value of nil.
(defvar feedmail-prompt-before-queue-standard-alist '((113 . feedmail-message-action-queue) (81 . feedmail-message-action-queue-strong) (100 . feedmail-message-action-draft) (114 . feedmail-message-action-draft) (68 . feedmail-message-action-draft-strong) (82 . feedmail-message-action-draft-strong) (101 . feedmail-message-action-edit) (69 . feedmail-message-action-edit) (7 . feedmail-message-action-edit) (110 . feedmail-message-action-edit) (78 . feedmail-message-action-edit) (105 . feedmail-message-action-send) (73 . feedmail-message-action-send-strong) (115 . feedmail-message-action-send) (83 . feedmail-message-action-send-strong) (42 . feedmail-message-action-toggle-spray) (22 . feedmail-message-action-help) (63 . feedmail-message-action-help)) (#$ . 26405))
#@52 See `feedmail-prompt-before-queue-standard-alist'.
(custom-declare-variable 'feedmail-prompt-before-queue-user-alist 'nil '(#$ . 27753) :group 'feedmail-queue :type '(repeat (cons character function)))
#@577 User-provided supplementary help string for the message action prompt.
When the message action prompt is shown, the user can as for verbose help,
at which point a buffer pops up describing the meaning of possible
responses to the prompt.  Through various customizations (see, for
example, `feedmail-prompt-before-queue-user-alist'), the available responses
and the prompt itself can be changed.  If this variable is set to a string
value, that string is written to the help buffer after the standard info.
It may contain embedded line breaks.  It will be printed via `princ'.
(custom-declare-variable 'feedmail-prompt-before-queue-help-supplement 'nil '(#$ . 27962) :group 'feedmail-queue :type '(choice (const nil) string))
#@32 See `feedmail-queue-reminder'.
(custom-declare-variable 'feedmail-queue-reminder-alist ''((after-immediate . feedmail-queue-reminder-brief) (after-queue . feedmail-queue-reminder-medium) (after-draft . feedmail-queue-reminder-medium) (after-run . feedmail-queue-reminder-brief) (on-demand . feedmail-run-the-queue-global-prompt)) '(#$ . 28693) :group 'feedmail-queue :type '(repeat (cons (choice :tag "Event" (const on-demand) (const after-immediate) (const after-queue) (const after-draft) (const after-run)) function)))
#@322 *If non-nil, blat a few status messages and such in the mini-buffer.
If nil, just do the work and don't pester people about what's going on.
In some cases, though, specific options inspire mini-buffer prompting.
That's not affected by this variable setting.  Also does not control
reporting of error/abnormal conditions.
(custom-declare-variable 'feedmail-queue-chatty 't '(#$ . -29222) :group 'feedmail-queue :type 'boolean)
#@200 *Duration of pause after most queue-related messages.
After some messages are divulged, it is prudent to pause before
something else obliterates them.  This value controls the duration of
the pause.
(custom-declare-variable 'feedmail-queue-chatty-sit-for '2 '(#$ . -29655) :group 'feedmail-queue :type 'integer)
#@504 *If non-nil, name a function which will sort the queued messages.
The function is called during a running of the queue for sending, and
takes one argument, a list of the files in the queue directory.  It
may contain the names of non-message files, and it's okay to leave
them in the list when reordering it; they get skipped over later.
When nil, the default action processes the messages in normal sort
order by queued file name, which will typically result in the order
they were placed in the queue.
(custom-declare-variable 'feedmail-queue-run-orderer 'nil '(#$ . -29974) :group 'feedmail-queue :type '(choice (const nil) function))
#@317 *If non-nil, use send time for the Date: header value.
This variable is used by the default date generating function,
feedmail-default-date-generator.  If nil, the default, the
last-modified timestamp of the queue file is used to create the
message Date: header; if there is no queue file, the current time is
used.
(custom-declare-variable 'feedmail-queue-use-send-time-for-date 'nil '(#$ . -30618) :group 'feedmail-queue :type 'boolean)
#@344 *If non-nil, use send time for the Message-Id: header value.
This variable is used by the default Message-Id: generating function,
`feedmail-default-message-id-generator'.  If nil, the default, the
last-modified timestamp of the queue file is used to create the
message Message-Id: header; if there is no queue file, the current time is
used.
(custom-declare-variable 'feedmail-queue-use-send-time-for-message-id 'nil '(#$ . -31064) :group 'feedmail-queue :type 'boolean)
#@705 *If non-nil, prompt user for part of the queue file name.
The file will automatically get the FQM suffix and an embedded
sequence number for uniqueness, so don't specify that.  feedmail will
get rid of all characters other than alphanumeric and hyphen in the
results.  If this variable is nil or if you just hit return in
response to the prompt, feedmail queuing will take care of things
properly.  At the prompt, completion is available if you want to see
what filenames are already in use, though, as noted, you will not be
typing a complete file name.  You probably don't want to be bothered
with this prompting since feedmail, by default, uses queue file names
based on the subjects of the messages.
(custom-declare-variable 'feedmail-ask-for-queue-slug 'nil '(#$ . -31543) :group 'feedmail-queue :type 'boolean)
#@406 *If non-nil, a function which creates part of the queued file name.
Takes a single argument giving the name of the directory into
which the message will be queued.  The returned string should be just
the non-directory filename part, without FQM suffix or uniquifying
sequence numbers.  The current buffer holds the raw message.  The
default function creates the slug based on the message subject, if
any.
(custom-declare-variable 'feedmail-queue-slug-maker ''feedmail-queue-subject-slug-maker '(#$ . -32367) :group 'feedmail-queue :type '(choice (const nil) function))
#@843 *Indicates what to use for subject-less messages when forming a file name.
When feedmail queues a message, it creates a unique file name.  By default,
the file name is based in part on the subject of the message being queued.
If there is no subject, consult this variable.  See documentation for the
function `feedmail-queue-subject-slug-maker'.

If t, an innocuous default is used.

If a string, it is used directly.

If a function, it is called with no arguments from the buffer containing the raw
text of the message.  It must return a string (which may be empty).

If the symbol 'ask, you will be prompted for a string in the mini-buffer.
Filename completion is available so that you can inspect what's already been
used, but feedmail will do further manipulation on the string you return, so
it's not expected to be a complete filename.
(custom-declare-variable 'feedmail-queue-default-file-slug 't '(#$ . -32943) :group 'feedmail-queue :type '(choice (const :tag "Default" t) string function (const ask)))
#@356 *The FQM suffix used to distinguish feedmail queued message files.
You probably want this to be a period followed by some letters and/or
digits.  The distinction is to be able to tell them from other random
files that happen to be in the `feedmail-queue-directory' or
`feedmail-queue-draft-directory'.  By the way, FQM stands for feedmail
queued message.
(custom-declare-variable 'feedmail-queue-fqm-suffix '".fqm" '(#$ . -33962) :group 'feedmail-queue :type 'string)
#@419 *If non-nil, silently kill the buffer after a message is queued.
You might like that since a side-effect of queueing the message is
that its buffer name gets changed to the filename.  That means that
the buffer won't be reused for the next message you compose.  If you
are using VM for creating messages, you probably want to leave this
nil, since VM has its own options for managing the recycling of
message buffers.
(custom-declare-variable 'feedmail-nuke-buffer-after-queue 'nil '(#$ . -34437) :group 'feedmail-queue :type 'boolean)
#@391 *If non-nil, automatically delete queue files when a message is sent.
Normally, feedmail will notice such files when you send a message in
immediate mode (i.e., not when you're running the queue) and will ask if
you want to delete them.  Since the answer is usually yes, setting this
variable to non-nil will tell feedmail to skip the prompt and just delete
the file without bothering you.
(custom-declare-variable 'feedmail-queue-auto-file-nuke 'nil '(#$ . -34980) :group 'feedmail-queue :type 'boolean)
(byte-code "\301B\302\301!\204�\303\301\304\"\210\305B\302\305!\204�\303\305\304\"\210\306B\302\306!\204-�\303\306\304\"\210\307B\302\307!\204<�\303\307\304\"\210\304\207" [current-load-list feedmail-error-buffer default-boundp set-default nil feedmail-prepped-text-buffer feedmail-raw-text-buffer feedmail-address-list] 3)
#@393 *Non-nil means we're inside the logic of the queue-running loop.
That is, iterating over all messages in the queue to send them.  In
that case, the value is the name of the queued message file currently
being processed.  This can be used for differentiating customized code
for different scenarios.  Users shouldn't set or change this
variable, but may depend on its value as described here.
(defvar feedmail-queue-runner-is-active nil (#$ . -35826))
#@877 Facilitate dividing `mail-send-hook' things into queued and immediate cases.
If you have `mail-send-hook' functions that should only be called for sending/
queueing messages or only be called for the sending of queued messages, this is
for you.  Add this function to `mail-send-hook' with something like this:

(add-hook 'mail-send-hook 'feedmail-mail-send-hook-splitter)

Then add the functions you want called to either `feedmail-mail-send-hook-queued'
or `feedmail-mail-send-hook', as apprpriate.  The distinction is that
`feedmail-mail-send-hook' will be called when you send mail from a composition
buffer (typically by typing C-c C-c), whether the message is sent immediately
or placed in the queue or drafts directory.  `feedmail-mail-send-hook-queued' is
called when messages are being sent from the queue directory, typically via a
call to `feedmail-run-the-queue'.
(defalias 'feedmail-mail-send-hook-splitter #[nil "\203�\301\302!\207\301\303!\207" [feedmail-queue-runner-is-active run-hooks feedmail-mail-send-hook-queued feedmail-mail-send-hook] 2 (#$ . 36284)])
#@60 *See documentation for `feedmail-mail-send-hook-splitter'.
(defvar feedmail-mail-send-hook nil (#$ . -37368))
#@60 *See documentation for `feedmail-mail-send-hook-splitter'.
(defvar feedmail-mail-send-hook-queued nil (#$ . -37484))
#@186 An example of a `feedmail-last-chance-hook'.
It shows the simple addresses and gets a confirmation.  Use as:
 (setq feedmail-last-chance-hook 'feedmail-confirm-addresses-hook-example).
(defalias 'feedmail-confirm-addresses-hook-example #[nil "\300\213\207" [((byte-code "\301\302\303!q!\210\304 \210\305\306\307#c\210\310\311!?\205�\312\313!\207" [feedmail-address-list display-buffer get-buffer-create " F-C-A-H-E" erase-buffer mapconcat identity " " y-or-n-p "How do you like them apples? " error "FQM: Sending...gave up in last chance hook"] 4))] 1 (#$ . 37608)])
#@797 *User's last opportunity to modify the message on its way out.
It has already had all the header prepping from the standard package.
The next step after running the hook will be to push the buffer into a
subprocess that mails the mail.  The hook might be interested in
these: (1) `feedmail-prepped-text-buffer' contains the header and body
of the message, ready to go; (2) `feedmail-address-list' contains a list
of simplified recipients of addresses which are to be given to the
subprocess (the hook may change the list); (3) `feedmail-error-buffer'
is an empty buffer intended to soak up errors for display to the user.
If the hook allows interactive activity, the user should not send more
mail while in the hook since some of the internal buffers will be
reused and things will get confused.
(custom-declare-variable 'feedmail-last-chance-hook 'nil '(#$ . -38184) :group 'feedmail-misc :type 'hook)
#@741 *User's last opportunity to modify the message before Fcc action.
It has already had all the header prepping from the standard package.
The next step after running the hook will be to save the message via
Fcc: processing. The hook might be interested in these: (1)
`feedmail-prepped-text-buffer' contains the header and body of the
message, ready to go; (2) `feedmail-address-list' contains a list of
simplified recipients of addressees to whom the message was sent (3)
`feedmail-error-buffer' is an empty buffer intended to soak up errors
for display to the user.  If the hook allows interactive activity, the
user should not send more mail while in the hook since some of the
internal buffers will be reused and things will get confused.
(custom-declare-variable 'feedmail-before-fcc-hook 'nil '(#$ . -39094) :group 'feedmail-misc :type 'hook)
#@499 *A function to set the proper mode of a message file.
Called when the message is read back out of the queue directory with a single
argument, the optional argument used in the call to
`feedmail-run-the-queue' or `feedmail-run-the-queue-no-prompts'.

Most people want `mail-mode', so the default value is an anonymous
function which is just a wrapper to ignore the supplied argument when
calling it, but here's your chance to have something different.
Called with funcall, not `call-interactively'.
(custom-declare-variable 'feedmail-queue-runner-mode-setter ''(lambda (&optional arg) (mail-mode)) '(#$ . -39947) :group 'feedmail-queue :type 'function)
#@632 *Alternative header demarcation for queued messages.
If you sometimes get alternative values for `mail-header-separator' in
queued messages, set the value of this variable to whatever it is.
For example, `rmail-resend' uses a `mail-header-separator' value of empty
string ("") when you send/queue a message.

When trying to send a queued message, if the value of this variable is
non-nil, feedmail will first try to send the message using the value
of `mail-header-separator'.  If it can't find that, it will temporarily
set `mail-header-separator' to the value of
`feedmail-queue-alternative-mail-header-separator' and try again.
(custom-declare-variable 'feedmail-queue-alternative-mail-header-separator 'nil '(#$ . -40606) :group 'feedmail-queue :type '(choice (const nil) string))
#@471 *Function to initiate sending a message file.
Called for each message read back out of the queue directory with a
single argument, the optional argument used in the call to
`feedmail-run-the-queue' or `feedmail-run-the-queue-no-prompts'.
Interactively, that argument will be the prefix argument.  Most people
want `mail-send-and-exit' (bound to C-c C-c in mail-mode), but here's
your chance to have something different.  Called with `funcall', not
`call-interactively'.
(custom-declare-variable 'feedmail-queue-runner-message-sender ''mail-send-and-exit '(#$ . -41398) :group 'feedmail-queue :type 'function)
#@797 *Function that will be called after a message has been sent.
Not called in the case of errors.  This function is called with two
arguments: the name of the message queue file for the message just sent,
and the optional argument used in the call to `feedmail-run-the-queue'
or `feedmail-run-the-queue-no-prompts' (prefix arg if interactive).
In any case, the affiliated buffer is killed elsewhere, so don't do that
inside this function.  Return value is ignored.

The default action is an anonymous function which gets rid of the file
from the queue directory.  With a non-nil second argument, a brief
message is give for each file deleted.  You could replace this
function, for example, to archive all of your sent messages someplace
(though there are better ways to get that particular result).
(custom-declare-variable 'feedmail-queue-runner-cleaner-upper ''(lambda (fqm-file &optional arg) (delete-file fqm-file) (if (and arg feedmail-queue-chatty) (message "FQM: Nuked %s" fqm-file))) '(#$ . -42014) :group 'feedmail-queue :type 'function)
#@337 *Non-nil means the message is a Resend (in the RFC-822 sense).
This affects the composition of certain headers.  feedmail sets this
variable as soon as it starts prepping the message text buffer, so any
user-supplied functions can rely on it.  Users shouldn't set or change this
variable, but may depend on its value as described here.
(defvar feedmail-is-a-resend nil (#$ . -43065))
#@594 *Function used to send the prepped buffer to a subprocess.
The function's three (mandatory) arguments are: (1) the buffer
containing the prepped message; (2) a buffer where errors should be
directed; and (3) a list containing the addresses individually as
strings.  Three popular choices for this are
`feedmail-buffer-to-binmail', `feedmail-buffer-to-smtpmail', and
`feedmail-buffer-to-sendmail'.  If you use the sendmail form, you
probably want to set `feedmail-nuke-bcc' and/or `feedmail-nuke-resent-bcc'
to nil.  If you use the binmail form, check the value of
`feedmail-binmail-template'.
(custom-declare-variable 'feedmail-buffer-eating-function ''feedmail-buffer-to-binmail '(#$ . -43456) :group 'feedmail-misc :type 'function)
#@711 *Command template for the subprocess which will get rid of the mail.
It can result in any command understandable by /bin/sh.  Might not
work at all in non-Unix environments.  The single '%s', if present,
gets replaced by the space-separated, simplified list of addressees.
Used in `feedmail-buffer-to-binmail' to form the shell command which
will receive the contents of the prepped buffer as stdin.  If you'd
like your errors to come back as mail instead of immediately in a
buffer, try /bin/rmail instead of /bin/mail (this can be accomplished
by keeping the default nil setting of `mail-interactive').  You might
also like to consult local mail experts for any other interesting
command line possibilities.
(custom-declare-variable 'feedmail-binmail-template '(if mail-interactive "/bin/mail %s" "/bin/rmail %s") '(#$ . -44197) :group 'feedmail-misc :type 'string)
#@82 Function which actually calls /bin/mail as a subprocess.
Feeds the buffer to it.
(defalias 'feedmail-buffer-to-binmail #[(prepped errors-to addr-listoid) "q\210\304\305\306ed\307\310	\310\311\312\n\313\314\315#\"\257!\"\207" [prepped errors-to feedmail-binmail-template addr-listoid apply call-process-region append "/bin/sh" nil "-c" format mapconcat identity " "] 16 (#$ . 45071)])
#@148 Function which actually calls sendmail as a subprocess.
Feeds the buffer to it.  Probably has some flaws for Resent-* and other
complicated cases.
(defalias 'feedmail-buffer-to-sendmail #[(prepped errors-to addr-listoid) "q\210\305\306\307ed\310\301!\203�	\2021�\311\312!\203�\312\2021�\311\313!\203&�\313\2021�\311\314!\2030�\314\2021�\315\316\n\316\317\320\257\321D\f?\205A�\322#\"\207" [prepped sendmail-program errors-to user-mail-address mail-interactive apply call-process-region append boundp file-exists-p "/usr/sbin/sendmail" "/usr/lib/sendmail" "/usr/ucblib/sendmail" "fakemail" nil "-oi" "-t" "-f" ("-oem" "-odb")] 11 (#$ . 45465)])
#@77 Function which actually calls `smtpmail-via-smtp' to send buffer as e-mail.
(defalias 'feedmail-buffer-to-smtpmail #[(prepped errors-to addr-listoid) "\306\307!\210\310	\"?\205#�\nq\210\311c\210\312c\210\313\314\315!P\316\317\320 \"*\207" [addr-listoid prepped errors-to smtpmail-smtp-server tracer case-fold-search require smtpmail smtpmail-via-smtp "Send via smtpmail failed.  Probable SMTP protocol error.\n" "Look for details below or in the *Messages* buffer.\n\n" t "trace.*smtp.*" regexp-quote mapcar #[(buffy) "\302\303	!\"\205�\304\303	!\305\261\210\306	!\210\307c\207" [tracer buffy string-match buffer-name "SMTP Trace from " "\n---------------" insert-buffer-substring "\n\n"] 4] buffer-list] 4 (#$ . 46120)])
#@2729 A fiddle-plex is a concise way of specifying header field fiddling.
It is a list of up to 4 elements: NAME, VALUE, ACTION, FOLDING.  The element
VALUE can also be a list sometimes.

NAME is the name of the header field to be fiddled with.  Although case
doesn't matter in looking for headers, case of NAME is preserved when a header
is inserted via fiddling.  It shouldn't include the trailing colon.

VALUE is either nil, a simple string, a function returning nil or a string, or,
as described below for ACTION `combine', a list of up to three values.

ACTION describes the nature of the fiddling to be done.  Possibilities
for ACTION (default is `supplement'):

`supplement'  Leave other like fields as-is, insert this one.

`replace'     Delete other like fields, if any, and insert this one.

`create'      Insert this one only if no like field exists.

`combine'     Combine aggregate values of like fields with this one.
                In this case, VALUE has a special form.  It is a list
                of three items: VAL-PRE, VAL-LIKE, and VAL-POST.
                VAL-PRE and VAL-POST are strings or nil.  VAL-LIKE may
                be either a string or a function (it may also be nil,
                but there's not much point to that).

Values of like header fields are aggregated, leading and
                trailing whitespace is removed, and embedded
                whitespace is left as-is.  If there are no like
                fields, or the aggregate value is an empty string,
                VAL-LIKE is not used.  Else, if VAL-LIKE is a function,
                it is called with two arguments: NAME and the
                aggregate like values.  Else, if VAL-LIKE is a string, it is
                used as a format string where a single %s will be
                replaced by the aggregate values of like fields.

VAL-PRE, the results of using VAL-LIKE, and VAL-POST
                are concatenated, and the result, if not nil and not
                an empty string, is used as the new value for the
                field.  Although this description sounds a bit
                complicated, the idea is to provide a mechanism for
                combining the old value with a new value in a flexible
                way.  For example, if you wanted to add a new value to
                an existing header field by adding a semi-colon and
                then starting the new value on a continuation line,
                you might specify this:

(nil "%s;\n\t" "This is my new value")

FOLDING can be nil, in which case VALUE is used as-is.  If FOLDING is
non-nil, feedmail "smart filling" is done on VALUE just before
insertion.
(defconst feedmail-fiddle-plex-blurb nil (#$ . 46857))
#@199 Send the current mail buffer using the Feedmail package.
This is a suitable value for `send-mail-function'.  It can be used
with various lower-level mechanisms to provide features such as queueing.
(defalias 'feedmail-send-it #[nil "\203�\304!	\203�\304	!\n\204�\305 \207\203�\306  \207\307\310\"\207" [feedmail-queue-directory feedmail-queue-draft-directory feedmail-enable-queue feedmail-ask-before-queue expand-file-name feedmail-send-it-immediately feedmail-queue-send-edit-prompt feedmail-dump-message-to-queue after-queue] 3 (#$ . 49647)])
(defalias 'feedmail-message-action-send #[nil "\300\301!\210\302 \207" [message "FQM: Immediate send..." feedmail-send-it-immediately] 2])
#@73 *Send message directly to the queue, with a minimum of fuss and bother.
(defalias 'feedmail-queue-express-to-queue #[nil "\304\305\211\306\307 ,\207" [feedmail-queue-chatty-sit-for feedmail-queue-reminder-alist feedmail-ask-before-queue feedmail-enable-queue t nil 0 feedmail-send-it] 4 (#$ . -50348) nil])
#@79 *Send message directly to the draft queue, with a minimum of fuss and bother.
(defalias 'feedmail-queue-express-to-draft #[nil "\302 )\207" [feedmail-queue-draft-directory feedmail-queue-directory feedmail-queue-express-to-queue] 1 (#$ . -50665) nil])
(defalias 'feedmail-message-action-send-strong #[nil "\301\302 )\207" [feedmail-confirm-outgoing nil feedmail-message-action-send] 1])
(defalias 'feedmail-message-action-edit #[nil "\300\301!\207" [error "FQM: Message not queued; returning to edit"] 2])
(defalias 'feedmail-message-action-draft #[nil "\301\302\"\207" [feedmail-queue-draft-directory feedmail-dump-message-to-queue after-draft] 3])
(defalias 'feedmail-message-action-draft-strong #[nil "\301\302 )\207" [buffer-file-name nil feedmail-message-action-draft] 1])
(defalias 'feedmail-message-action-queue #[nil "\301\302\"\207" [feedmail-queue-directory feedmail-dump-message-to-queue after-queue] 3])
(defalias 'feedmail-message-action-queue-strong #[nil "\301\302 )\207" [buffer-file-name nil feedmail-message-action-queue] 1])
(defalias 'feedmail-message-action-toggle-spray #[nil "?\211\203�\301\302!\210\202�\301\303!\210\304\305!\210\306 )\207" [feedmail-enable-spray message "FQM: For this message, spray toggled ON" "FQM: For this message, spray toggled OFF" sit-for 3 feedmail-send-it] 3])
(defalias 'feedmail-message-action-help #[nil "\302	;\203\f�	\202�\303	!\304!\210\305 )\207" [d-string feedmail-ask-before-queue-default " " char-to-string feedmail-queue-send-edit-prompt-help feedmail-send-it] 2])
#@67 Like `feedmail-run-the-queue', but suppress confirmation prompts.
(defalias 'feedmail-run-the-queue-no-prompts #[(&optional arg) "\302\303	!)\207" [feedmail-confirm-outgoing arg nil feedmail-run-the-queue] 2 (#$ . 52215) "p"])
#@212 Like `feedmail-run-the-queue', but with a global confirmation prompt.
This is generally most useful if run non-interactively, since you can
bail out with an appropriate answer to the global confirmation prompt.
(defalias 'feedmail-run-the-queue-global-prompt #[(&optional arg) "\302\303	!)\207" [feedmail-queue-runner-confirm-global arg t feedmail-run-the-queue] 2 (#$ . 52450) "p"])
#@251 Visit each message in the feedmail queue directory and send it out.
Return value is a list of three things: number of messages sent, number of
messages skipped, and number of non-message things in the queue (commonly
backup file names and the like).
(defalias 'feedmail-run-the-queue #[(&optional arg) "\203�\306!	\203�\306	!\307\310!\310	!@A@\f@\fA@\311\211\307\211\307\312\307 
\311V\203p�!\203p�\313\314!\203b�\314\315\316
%\317\307#\202n�\320\315\316
%!\204{�
\202~�\321\213\210\"\203\233�\322\323$\210\324#!\210\325\326!\210\324#!\210E.\207" [feedmail-queue-directory feedmail-queue-draft-directory maybe-file qlist dlist q-cnt expand-file-name nil feedmail-look-at-queue-directory 0 t fboundp y-or-n-p-with-timeout format "FQM: Draft: %dm+%d,  Queue: %dm+%d; run the queue? " 5 y-or-n-p ((byte-code "\303\304\"\n\203
�\n	!\305\306	\"\207" [feedmail-queue-directory list-of-possible-fqms feedmail-queue-run-orderer directory-files t mapc #[(blobby) "\306	\"\307\n!\203
�\310\207\311!\205\262�\312\313P!\314\315!\203%�\315\n!\202(�\316\n!\211\2036�\317\f!\2036�\320\213\210q\210\310\321!\210\322\n!\210\323\324!\204g�\203Y�\323\324!)\204g�\310\211 !\325 \210\326\n!\210*\323\324!\204\204�\203\204�\323\324!)\203\204�\"\202\210�\"#$!\210\310\327\330\217\210\331!\210%\205\262�\332\333\334&'(#'()%\210\335*!\207" [blobby feedmail-queue-directory maybe-file blobby-buffer already-buffer buffer-offer-save expand-file-name file-directory-p nil feedmail-fqm-p generate-new-buffer "FQM " fboundp find-buffer-visiting get-file-buffer buffer-modified-p ((byte-code "\302q!\210\303\304!\203�\304\305\306	\"\307\310#\203(�\311 \210\202(�\312\305\306	\"!\203(�\311 \210\302\207" [already-buffer blobby display-buffer fboundp y-or-n-p-with-timeout format "FQM: Visiting %s; save before send? " 10 t save-buffer y-or-n-p] 4)) buffer-disable-undo insert-file-contents-literally feedmail-find-eoh t erase-buffer insert-file-contents (byte-code "\306	
	!\210\nq\210\307 \203�T\202<�\fT\f
		\"\210\203<�\310	!\204<�\212q\210\306)+\306\207" [this-mhsep maybe-file feedmail-queue-runner-is-active mail-header-separator feedmail-enable-queue feedmail-queue-runner-message-sender nil buffer-modified-p file-exists-p arg blobby-buffer messages-skipped messages-sent feedmail-queue-runner-cleaner-upper already-buffer buffer-file-name] 3) ((error (byte-code "T\301\207" [messages-skipped nil] 1))) kill-buffer message "FQM: %d to go, %d sent, %d skipped (%d other files ignored)" - sit-for feedmail-queue-alternative-mail-header-separator mail-header-separator default-buffer-file-type file-name-buffer-file-type-alist this-mhsep feedmail-queue-runner-mode-setter arg feedmail-queue-chatty q-cnt messages-sent messages-skipped q-oth feedmail-queue-chatty-sit-for] 7]] 3)) message "FQM: %d sent, %d skipped (%d other files ignored)" sit-for feedmail-queue-reminder after-run q-oth d-cnt d-oth messages-sent messages-skipped blobby-buffer already-buffer this-mhsep do-the-run list-of-possible-fqms feedmail-queue-runner-confirm-global feedmail-queue-chatty feedmail-queue-chatty-sit-for] 8 (#$ . 52842) "p"])
#@1063 Perform some kind of reminder activity about queued and draft messages.
Called with an optional symbol argument which says what kind of event
is triggering the reminder activity.  The default is 'on-demand, which
is what you typically would use if you were putting this in your Emacs start-up
or mail hook code.  Other recognized values for WHAT-EVENT (these are passed
internally by feedmail):

after-immediate      (a message has just been sent in immediate mode)
   after-queue          (a message has just been queued)
   after-draft          (a message has just been placed in the draft directory)
   after-run            (the queue has just been run, possibly sending messages)

WHAT-EVENT is used as a key into the table `feedmail-queue-reminder-alist'.  If
the associated value is a function, it is called without arguments and is expected
to perform the reminder activity.  You can supply your own reminder functions
by redefining `feedmail-queue-reminder-alist'.  If you don't want any reminders,
you can set `feedmail-queue-reminder-alist' to nil.
(defalias 'feedmail-queue-reminder #[(&optional what-event) "\203
�9\203
�\202�\305\306\211\307\f\"\211A\310	!\205#�	 +\207" [what-event reminder entry key feedmail-queue-reminder-alist on-demand nil assoc fboundp] 4 (#$ . 56073) "p"])
#@63 Brief display of draft and queued message counts in modeline.
(defalias 'feedmail-queue-reminder-brief #[nil "\306\211\211\211\307\f!\307
!	@@\310V\204\"�\n\310V\205'�\311\312\n#,\207" [d-lis q-lis d-cnt q-cnt feedmail-queue-directory feedmail-queue-draft-directory nil feedmail-look-at-queue-directory 0 message "FQM: [D: %d,  Q: %d]"] 4 (#$ . 57387) nil])
#@65 Verbose display of draft and queued message counts in modeline.
(defalias 'feedmail-queue-reminder-medium #[nil "\306\211\211\211\211\211\307\f!\307
!	@@	A@A@
\310V\2040�\f\310V\205@�\311\312\f\n\313
!
\313\f!&.\207" [d-lis q-lis d-oth q-oth d-cnt q-cnt nil feedmail-look-at-queue-directory 0 message "FQM: Draft: %dm+%d in \"%s\",  Queue: %dm+%d in \"%s\"" file-name-nondirectory feedmail-queue-directory feedmail-queue-draft-directory] 9 (#$ . 57762) nil])
#@73 Ask whether to queue, send immediately, or return to editing a message.
(defalias 'feedmail-queue-send-edit-prompt #[nil "\300 \210\301\213\207" [discard-input ((byte-code "\306\211\307;\203�\310!\202�\311!\n\204\240�\312\f\"\210\313\211\314\315 +\211U\203<�\316\202\234�\317=\204Q�\320=\204Q�\321=\203T�	\322\"\206\205�\323\324!\203n�\322\324!\"\206\205�\322\"\206\205�\323\324!\205\205�\322\324!\"\211\203\217�\nA\204\234�\325 \210\312\"\210\326\327!\210)\202�\nA+\207" [d-string d-char answer feedmail-ask-before-queue-default feedmail-ask-before-queue-prompt echo-keystrokes nil " " string-to-char char-to-string message t 0 read-char-exclusive (^ . feedmail-message-action-help) 13 10 121 assoc fboundp char-to-int beep sit-for 3 cursor-in-echo-area inhibit-quit user-sez help-char feedmail-prompt-before-queue-user-alist feedmail-prompt-before-queue-standard-alist feedmail-ask-before-queue-reprompt] 4))] 1 (#$ . 58248)])
(byte-code "\301B\302\303!\207" [current-load-list feedmail-p-h-b-n (lambda (#1=#:defconst-tmp-var) (defconst feedmail-p-h-b-n #1#)) "*FQM Help*"] 2)
(defalias 'feedmail-queue-send-edit-prompt-help #[(d-string) "\303!\211\203�\304	\305\"\203�\306	\n\"\202�\307\n!)\207" [feedmail-p-h-b-n fqm-help d-string get-buffer get-buffer-window visible feedmail-queue-send-edit-prompt-help-later feedmail-queue-send-edit-prompt-help-first] 4])
(defalias 'feedmail-queue-send-edit-prompt-help-later #[(fqm-help d-string) "\306 \307\310\311 \"r\312\216\313\314\n!\315!\210\316d\"\203#�\317
!\202&�\320\313!.\207" [save-selected-window-alist save-selected-window-window fqm-help fqm-window signal-error-on-buffer-boundary d-string selected-window mapcar #[(frame) "\301!B\207" [frame frame-selected-window] 3] frame-list ((byte-code "\304\211\203(�\n@\305	@!\203!�\306	A!\203!�\307	@	A\310#\210\nA\211\204�*\306!\2034�\311\310\"\210\304\207" [save-selected-window-alist elt --dolist-tail-- save-selected-window-window nil frame-live-p window-live-p set-frame-selected-window norecord select-window] 5)) nil display-buffer select-window pos-visible-in-window-p feedmail-queue-send-edit-prompt-help-first scroll-up] 4])
(defalias 'feedmail-queue-send-edit-prompt-help-first #[(d-string) "\220\304\305!\210\304	!\210\304\306!\210\n;\203�\304\n!\210\212q\210\307\310!\205#�\310 )\221\207" [feedmail-p-h-b-n d-string feedmail-prompt-before-queue-help-supplement standard-output princ "You're dispatching a message and feedmail queuing is enabled.\nTyping ? or C-v will normally scroll this help buffer.\n\nChoices:\n   q  QUEUE        for later sending (via feedmail-run-the-queue)\n   Q  QUEUE!       like \"q\", but always make a new file\n   i  IMMEDIATELY  send this (but not the other queued messages)\n   I  IMMEDIATELY! like \"i\", but skip following confirmation prompt\n   d  DRAFT        queue in the draft directory\n   D  DRAFT!       like \"d\", but always make a new file\n   e  EDIT         return to the message edit buffer (don't send or queue)\n   *  SPRAY        toggle spray mode (individual message transmissions)\n\nSynonyms:\n   s  SEND         immediately (same as \"i\")\n   S  SEND!        immediately (same as \"I\")\n   r  ROUGH        draft (same as \"d\")\n   R  ROUGH!       draft (same as \"D\")\n   n  NOPE         didn't mean it (same as \"e\")\n   y  YUP          do the default behavior (same as \"C-m\")\n\nThe user-configurable default is currently \"" "\".  For other possibilities,\nsee the variable feedmail-prompt-before-queue-user-alist.\n" fboundp help-mode] 3])
#@260 Find out some things about a queue directory.
Result is a list containing a count of queued messages in the
directory, a count of other files in the directory, and a high water
mark for prefix sequence numbers.  Subdirectories are not included in
the counts.
(defalias 'feedmail-look-at-queue-directory #[(queue-directory) "\305\211\211\306\307\f!\203�\310\311\312\f\313\"\"\210\n	E,\207" [blobbet high-water q-oth q-cnt queue-directory 0 nil file-directory-p mapc #[(blobby) "\306!\203�\307\207\310!\2030�\311!\312\313	\"\203+�\307\314	\315\316O!\211V\203*�\n)\fT\211\207
T\211\207" [blobby blobbet water-mark high-water q-cnt q-oth file-directory-p nil feedmail-fqm-p file-name-nondirectory string-match "^[0-9][0-9][0-9]-" string-to-number 0 3] 5] directory-files t] 5 (#$ . 61854)])
#@69 Utility for mapping out suspect characters in a potential filename.
(defalias 'feedmail-tidy-up-slug #[(slug) "\204�\301\302\303\"\203�\304\305\306\211$\202�\302\307\"\203(�\304\305\306\211$\202�\302\310\"\2036�\304\301\306\211$\302\311\"\203D�\304\301\306\211$\207" [slug "" string-match "[^a-z0-9-]+" replace-match "-" nil "--+" "^-*" "-*$"] 5 (#$ . 62664)])
#@345 Create a name for storing the message in the queue.
Optional argument QUEUE-DIRECTORY specifies into which directory the
file will be placed.  The name is based on the Subject: header (if
there is one).  If there is no subject,
`feedmail-queue-default-file-slug' is consulted.  Special characters are
mapped to mostly alphanumerics for safety.
(defalias 'feedmail-queue-subject-slug-maker #[(&optional queue-directory) "\306\307\310\306\311 eb\210\312\313\307#\203�`\306\210`{\314	!\315	G!\203V�\f;\2033�\f\202U�\316\f!\203@�\212\f )\202U�\f\317=\203T�\320\321\322\323
!	\306	%!\202U�\324\314	!,\207" [s-point subject case-fold-search eoh-marker feedmail-queue-default-file-slug queue-directory nil t "" feedmail-find-eoh re-search-forward "^Subject:" feedmail-tidy-up-slug zerop fboundp ask file-name-nondirectory read-file-name "FQM: Message filename slug? " file-name-as-directory "no subject"] 7 (#$ . 63051)])
(defalias 'feedmail-create-queue-filename #[(queue-directory) "\305	\203�\212	\n!)\202\"�\203\"�\306\307\310\311Q\312\n!\313%!\314!\315\316\317\320\n!8T#\321\n\"\fP)\207" [slug feedmail-queue-slug-maker queue-directory feedmail-ask-for-queue-slug feedmail-queue-fqm-suffix "wjc" file-name-nondirectory read-file-name "FQM: Message filename slug? [" "]? " file-name-as-directory nil feedmail-tidy-up-slug format "%03d-%s" 2 feedmail-look-at-queue-directory expand-file-name] 7])
(defalias 'feedmail-dump-message-to-queue #[(queue-directory what-event) "\306!\204�\307\310\"\210\306!\204�\311\312\"\210\313\211\211		\2032�\314	!\315!\315\316\317	!!!\230\f\203?�\203?�	\202C�\320!\321
!\210)\n\203e�\f\203X�\204e�\322\323\324\n\"!\203e�\325\n!\210\203\206� !\326p!\203\205�\"\203\205�\327!!\203\205�\325!!\210)#\203\227�\330\331\332
P\"\210\333$!\210#\205\245�\334%!\210\333$!,\207" [queue-directory buffer-file-name previous-buffer-file-name is-in-this-dir is-fqm filename file-accessible-directory-p make-directory t error "FQM: Message not queued; trouble with directory %s" nil feedmail-fqm-p directory-file-name expand-file-name file-name-directory feedmail-create-queue-filename write-file y-or-n-p format "FQM: Was previously %s; delete that? " delete-file kill-buffer file-exists-p message "%s" "FQM: Queued in " sit-for feedmail-queue-reminder feedmail-force-binary-write buffer-file-type feedmail-nuke-buffer-after-queue buffer-auto-save-file-name a-s-file-name delete-auto-save-files feedmail-queue-chatty feedmail-queue-chatty-sit-for what-event] 5])
(defalias 'feedmail-rfc822-time-zone #[(time) "\303!@\206�\304\305	!\306\245\307\310	\304W\203�\311\202�\312\n\306\245\n\306\246$*\207" [time sec absmin current-time-zone 0 abs 60 format "%c%02d%02d" 45 43] 6])
(defalias 'feedmail-rfc822-date #[(arg-time) "\203�\202\n�\302 \303\304	\"\305	!P)\207" [arg-time time current-time format-time-string "%a, %e %b %Y %T " feedmail-rfc822-time-zone] 3])
#@57 Handle immediate sending, including during a queue run.
(defalias 'feedmail-send-it-immediately #[nil "\306\307!\306\310!p\311\211\311\211@\312A\313B\314C\315D\316E\317FGG\320\216\212q\210\321 \210	q\210\321 \210\322\n!\210db\210h\323U\204H�\323c\210\311H\324 \325\326!\210\327G)I\204f�\330\331!\203k�J\203k�\331e\f\"\210K\203t�\332\f!\210eb\210\333\334\f\335#\203\214�`\fW\203\214�\325\326!\210\202w�\335\311LHeb\210\333\336\f\335#MN\337=\203\274�M\203\257�CL\202\263�FL\340	e\fL%N\337=\204\312�N\341=\203\346�M\203\326�BL\202\332�EL\340	e\fL%\202\377�M\203\362�AL\202\366�DL\340	e\fL%N\341=\203M\203CL\202FL\340	e\fL%\204'\342\343!\210\237\344\f\317\"\344\f\314\"@
\203DO\204Deb\210
c\210@\203UP\204Ueb\210@c\210eb\210\345 \210\346 \210\347 \210\350Q\206j\351\n!!\210\352Q\206u\351\n!!\210\353R!\210eb\210S\203\223\333\354\f\335#\203\223\325\327!\210\202\204*\355\356!\210\344\f\357\"\311T\360=\203\252Q?\202\270T\361=\203\266Q\202\270TUVWU\203\311\362	!\203M\363\f!X\364 \210Q\204\351\n!\211V\203\365V!VY\204\364\366\367\370V\"!\203\212\371V!\210\nq\210\311\211Z))eb\210W\203I[\\Wc\210]\204)
\203 
c\210@\203)@c\210\355\372!\210^\203D\fb\210\373^!\203@^y\210`d|\210\374\f!\210))\202Q\342\375!\210._\205hQ?\205h\376\377!\210\201a�`!\207" [feedmail-error-buffer feedmail-prepped-text-buffer feedmail-raw-text-buffer feedmail-address-list eoh-marker bcc-holder get-buffer-create " *FQM Outgoing Email Errors*" " *FQM Outgoing Email Text*" nil "^Resent-\$To\\|Cc\\|Bcc\$:" "^Resent-\$To\\|Cc\$:" "^Resent-Bcc:" "^\$To\\|Cc\\|Bcc\$:" "^\$To\\|Cc\$:" "^Bcc:" ((byte-code "\305!\210	q\210\306\307 !\203�\305	!\210\2021�\310	!\210\n\203-�\203-�\311\312!\210\313\314!\210\315\316!\210\317\312!\210\fq\207" [feedmail-prepped-text-buffer feedmail-error-buffer feedmail-queue-runner-is-active feedmail-queue-chatty feedmail-raw-text-buffer kill-buffer zerop buffer-size display-buffer message "FQM: Sending...failed" ding t sit-for 3 error] 2)) erase-buffer insert-buffer-substring 10 feedmail-find-eoh replace-match "\n" "" fboundp expand-mail-aliases feedmail-fill-to-cc-function re-search-forward "\n\n\n*" t "^\$Resent-To:\\|Resent-Cc:\\|Resent-Bcc:\$\\s-*\\S-+.*$" first feedmail-deduce-address-list last error "FQM: Sending...abandoned, no addressees" feedmail-accume-n-nuke-header feedmail-fiddle-from feedmail-fiddle-sender feedmail-fiddle-x-mailer feedmail-fiddle-message-id buffer-file-name feedmail-fiddle-date feedmail-fiddle-list-of-fiddle-plexes "^[A-Za-z0-9-]+:[ 	]*\n" run-hooks feedmail-last-chance-hook "^Fcc:" immediate queued feedmail-one-last-look feedmail-envelope-deducer feedmail-give-it-to-buffer-eater expand-file-name y-or-n-p format "FQM: Delete message file %s? " delete-file feedmail-before-fcc-hook natnump mail-do-fcc "FQM: Sending...abandoned" feedmail-queue-reminder after-immediate resent-bcc-holder a-re-rtcb a-re-rtc a-re-rb a-re-dtcb a-re-dtc a-re-db mail-header-separator case-fold-search feedmail-force-expand-mail-aliases mail-aliases feedmail-fill-to-cc addr-regexp feedmail-is-a-resend feedmail-deduce-bcc-where feedmail-nuke-bcc feedmail-nuke-resent-bcc feedmail-queue-runner-is-active feedmail-fiddle-plex-user-list feedmail-nuke-empty-headers feedmail-confirm-outgoing confirm also-file fcc user-mail-address feedmail-queue-auto-file-nuke buffer-offer-save feedmail-force-binary-write default-buffer-file-type feedmail-nuke-bcc-in-fcc feedmail-nuke-body-in-fcc feedmail-queue-chatty feedmail-queue-chatty-sit-for sit-for] 7 (#$ . 65998)])
#@222 Internal feedmail function for jamming fields into message header.
NAME, VALUE, ACTION, and FOLDING are the four elements of a
fiddle-plex, as described in the documentation for the variable
`feedmail-fiddle-plex-blurb'.
(defalias 'feedmail-fiddle-header #[(name value &optional action folding) "\306\307!\310P\311\211\211\211\211\211!\"#\312\"P!\313 eb\210\314!
\306#$\2042�\315$$\315=\203\205�\316\317%\"\203I�%\320\225\311O%\316\321%\"\203Y�%\320\211\224O%%G\320V\205D&\203l�eb\210\202o�
b\210`\322%\323\261\210'\205D\324	`\"\202D$\325=\203\241�\f\203\226�\326
!\"\210\327%\315'$\202D$\330=\203\270�\f?\205D\327%\315'$\202D$\331=\205D%A@\326
!\"\206\315�\332\316!\333P\"\203\337�\334\332\306\211$\316\323\"\333Q\"\203\364�\334\335\306\211$\202\337�\316\317\"\203\320\225\311O\316\321\"\203\320\211\224OG\320V\2035\n9\203'\336\n!\203'\n\"\2024\n;\2033\337\n\"\2024\311\327%@\340%8Q\315'$.\207" [name that-point val-like ag-like has-like eoh-marker t regexp-quote ":" nil "^" feedmail-find-eoh re-search-forward supplement string-match "\\`[ 	\n]+" 0 "[ 	\n]+\\'" ": " "\n" feedmail-fill-this-one replace feedmail-accume-n-nuke-header feedmail-fiddle-header create combine "" "[ 	\n]+" replace-match "\n	" fboundp format 2 header-regexp header-colon case-fold-search action value feedmail-fiddle-headers-upwardly folding] 8 (#$ . 69639)])
(defalias 'feedmail-give-it-to-buffer-eater #[nil "\212\203\f�\305\306	\"\202�\n\f	#)\207" [feedmail-enable-spray feedmail-address-list feedmail-buffer-eating-function feedmail-prepped-text-buffer feedmail-error-buffer mapcar #[(feedmail-spray-this-address) "\306\307!\212q\210\310 \210\311	!\210\312\n!\210	\f
C#\210*\313!)\207" [spray-buffer feedmail-prepped-text-buffer feedmail-spray-address-fiddle-plex-list feedmail-buffer-eating-function feedmail-error-buffer feedmail-spray-this-address get-buffer-create " *FQM Outgoing Email Spray*" erase-buffer insert-buffer-substring feedmail-fiddle-list-of-spray-fiddle-plexes kill-buffer] 4]] 4])
#@150 If `feedmail-deduce-envelope-from' is false, simply return `user-mail-address'.
Else, look for Sender: or From: (or Resent-*) and
return that value.
(defalias 'feedmail-envelope-deducer #[(eoh-marker) "\204�	\207\305\306pe\f\203�\307\202�\310\n%\211\204,�\306pe\f\203(�\311\202)�\312\n%\n\203:�\n@\203:�\n@\202;�	)\207" [feedmail-deduce-envelope-from user-mail-address from-list eoh-marker feedmail-is-a-resend nil feedmail-deduce-address-list "^Resent-Sender:" "^Sender:" "^Resent-From:" "^From:"] 7 (#$ . 71726)])
#@15 Fiddle From:.
(defalias 'feedmail-fiddle-from #[nil "\305=\203�\305\207\306=\203J�	\203�	\202�\307 \310\311 Q\305=\203'�\n\202D�\312=\2036�\n\313\314 \315R\202D�\316=\205D�\317\314 \320\n\321\260)\322 )\207;\203X�\323\324E\322 )\2079\203j�\325!\203j� \322 )\207<\205\203�\326\f\203x�\327\202y�\330A@\3318\3328$\207" [feedmail-from-line user-mail-address at-stuff mail-from-style feedmail-is-a-resend nil t user-login-name "@" system-name parens " (" user-full-name ")" angles "\"" "\" <" ">" feedmail-fiddle-from "ignored" create fboundp feedmail-fiddle-header "Resent-From" "From" 2 3] 6 (#$ . 72257)])
#@17 Fiddle Sender:.
(defalias 'feedmail-fiddle-sender #[nil "\302=\203�\302\207\303=\203�\302\207;\203�\304\305E\306 )\2079\2030�\307!\2030� \306 )\207<\205I�\310	\203>�\311\202?�\312A@\3138\3148$\207" [feedmail-sender-line feedmail-is-a-resend nil t "ignored" create feedmail-fiddle-sender fboundp feedmail-fiddle-header "Resent-Sender" "Sender" 2 3] 6 (#$ . 72889)])
#@56 Default function for generating Date: header contents.
(defalias 'feedmail-default-date-generator #[(maybe-file) "\303	\204�\n\203�\304\305\n!8\306!)\207" [date-time feedmail-queue-use-send-time-for-date maybe-file nil 5 file-attributes feedmail-rfc822-date] 3 (#$ . 73276)])
#@64 Fiddle Date:.  See documentation of `feedmail-date-generator'.
(defalias 'feedmail-fiddle-date #[(maybe-file) "\303=\203�\303\207\304=\203�\305	!\306	!)\207;\203&�\307\310E\306	!)\2079\203:�\311!\203:�	!\306	!)\207<\205S�\312\n\203H�\313\202I�\314A@\3158\3168$\207" [feedmail-date-generator maybe-file feedmail-is-a-resend nil t feedmail-default-date-generator feedmail-fiddle-date "ignored" create fboundp feedmail-fiddle-header "Resent-Date" "Date" 2 3] 6 (#$ . 73563)])
#@220 Default function for generating Message-Id: header contents.
Based on a date and a sort of random number for tie breaking.  Unless
`feedmail-message-id-suffix' is defined, uses `user-mail-address', so be
sure it's set.
(defalias 'feedmail-default-message-id-generator #[(maybe-file) "\306\203	�\202\n�	\307\310\n\"\203&�\311\224\311\225\232\203�\312\202 �\313\nP\202*�\314\nP\f\2048�
\2038�\315\316
!8\317\320\321\322 \323\"\324\325\"\326!\n%*\207" [feedmail-message-id-suffix user-mail-address end-stuff date-time feedmail-queue-use-send-time-for-message-id maybe-file nil string-match "^\$.*\$@" 1 "" "-" "@" 5 file-attributes format "<%d-%s%s%s>" mod random 10000 format-time-string "%a%d%b%Y%H%M%S" feedmail-rfc822-time-zone] 6 (#$ . 74059)])
#@76 Fiddle Message-Id:.  See documentation of `feedmail-message-id-generator'.
(defalias 'feedmail-fiddle-message-id #[(maybe-file) "\303=\203�\303\207\304=\203�\305	!\306	!)\207;\203&�\307\310E\306	!)\2079\203:�\311!\203:�	!\306	!)\207<\205S�\312\n\203H�\313\202I�\314A@\3158\3168$\207" [feedmail-message-id-generator maybe-file feedmail-is-a-resend nil t feedmail-default-message-id-generator feedmail-fiddle-message-id "ignored" create fboundp feedmail-fiddle-header "Resent-Message-Id" "Message-Id" 2 3] 6 (#$ . 74824)])
#@60 Default function for generating X-Mailer: header contents.
(defalias 'feedmail-default-x-mailer-generator #[nil "\306\307\310	\"\203
�\311\202�\312)	\313\n\203�\314\202�\315\f\203#�\316\202$�\311
\203,�\317\202-�\320
\260\207" [case-fold-search emacs-version feedmail-patch-level feedmail-queue-runner-is-active feedmail-enable-spray feedmail-x-mailer-line-user-appendage t string-match "emacs" "" "emacs " " (via feedmail " " Q" " I" "S" ") " ")"] 8 (#$ . 75367)])
#@67 Fiddle X-Mailer:.  See documentation of `feedmail-x-mailer-line'.
(defalias 'feedmail-fiddle-x-mailer #[nil "\302=\203
�\303 \304 )\207;\203�\305\306D\307E\304 )\2079\203/�\310!\203/� \304 )\207<\205H�\311	\203=�\312\202>�\313A@\3148\3158$\207" [feedmail-x-mailer-line feedmail-is-a-resend t feedmail-default-x-mailer-generator feedmail-fiddle-x-mailer "ignored" ";\n	%s" combine fboundp feedmail-fiddle-header "X-Resent-Mailer" "X-Mailer" 2 3] 6 (#$ . 75845)])
#@78 Fiddle header for single spray address.  Uses `feedmail-spray-this-address'.
(defalias 'feedmail-fiddle-spray-address #[(addy-plex) "\302=\203�\302\207\303=\203�\304	D\305!)\207;\203%�	D\305!)\2079\2038�\306!\2038� \305!)\207<\205J�\307@A@\3108\3118$\207" [addy-plex feedmail-spray-this-address nil t "To" feedmail-fiddle-spray-address fboundp feedmail-fiddle-header 2 3] 6 (#$ . 76327)])
#@57 Fiddling based on a list of fiddle-plexes for spraying.
(defalias 'feedmail-fiddle-list-of-spray-fiddle-plexes #[(list-of-fiddle-plexes) "\303\211<\203�\n\205�\n@\nA\304	!\210\202	�\304\n!*\207" [list-of-fiddle-plexes fp lofp nil feedmail-fiddle-spray-address] 3 (#$ . 76742)])
#@86 Fiddling based on a list of fiddle-plexes.  Values t, nil, and string are pointless.
(defalias 'feedmail-fiddle-list-of-fiddle-plexes #[(list-of-fiddle-plexes) "\303\n\205;�\n@\nA	9\203%�\304	!\203%�	 C\305\n!\210)\202�	<\203�\306	@	A@\307	8\310	8$\210\202�*\207" [list-of-fiddle-plexes fp lofp nil fboundp feedmail-fiddle-list-of-fiddle-plexes feedmail-fiddle-header 2 3] 6 (#$ . 77033)])
#@237 Delete headers matching a regexp and their continuation lines.
There may be multiple such lines, and each may have arbitrarily
many continuation lines.  Return an accumulation of the deleted
headers, including the intervening newlines.
(defalias 'feedmail-accume-n-nuke-header #[(header-end header-regexp) "\304\305\212eb\210\306\n\304#\203<�\307y\210\310\224`{P\310\224`|\210\311\312!\203�`W\203�\307y\210\310\224`{P\313\314!\210\202�)*\207" [dropout case-fold-search header-regexp header-end t nil re-search-forward 1 0 looking-at "^[ 	].*\n" replace-match ""] 4 (#$ . 77439)])
#@308 Smart filling of address headers (don't be fooled by the name).
The filling tries to avoid splitting lines except at commas.  This
avoids, in particular, splitting within parenthesized comments in
addresses.  Headers filled include From:, Reply-To:, To:, Cc:, Bcc:,
Resent-To:, Resent-Cc:, and Resent-Bcc:.
(defalias 'feedmail-fill-to-cc-function #[(header-end) "\304\305\211\212eb\210\306\307\304#\205A�\310\224\311\312!\203�\313\314!\210\315y\210\311\316!\2034�`W\2034�\315y\210\202\"�\317 \212\320	\"\210)\202\n�,\207" [this-line-end this-line case-fold-search header-end t nil re-search-forward "^\$From:\\|Reply-To:\\|To:\\|Cc:\\|Bcc:\\|Resent-To:\\|Resent-Cc:\\|Resent-Bcc:\$" 0 looking-at "[ 	]*" replace-match " " 1 "[ 	]+" point-marker feedmail-fill-this-one] 4 (#$ . 78038)])
#@68 In-place smart filling of the region bounded by the two arguments.
(defalias 'feedmail-fill-this-one #[(this-line this-line-end) "\305b\210\306\307\fS\310#\203�\311\312!\210\202�\313\f\314\315\310%\210\313\f\316\314\310%\210\317\f\"\210\313\f\314\316\310%\210\313\f\315\314\310%\210b\210\306\320\f\310#\205N�\311\321!\210\202?�*\207" [feedmail-fill-to-cc-fill-column fill-column fill-prefix this-line this-line-end "	" re-search-forward "\\s-+" t replace-match " " subst-char-in-region 32 2 44 fill-region-as-paragraph "\$[^,]\$\n	[ ]*" "\\1,\n	"] 6 (#$ . 78841)])
(require 'mail-utils)
#@223 Get address list with all comments and other excitement trimmed.
Addresses are collected only from headers whose names match the fourth
argument.  Returns a list of strings.  Duplicate addresses will have
been weeded out.
(defalias 'feedmail-deduce-address-list #[(message-buffer header-start header-end addr-regexp address-list) "\306\211\211\211\306\216\212\307\310!q\210\311 \210\312\f
#\210eb\210\313\314d\313#\203r�\315\316!\210\317\224\320y\210\321\322!\203E�`dW\203E�\320y\210\2023�\323 \324	{!\325\326\n\"\203 �\n\327\224\327\225O\315\316\313\211\n$\235\204N�\330\331\"\210\202N�)\332\306!\210*,\207" [this-line-end this-line address-blob simple-address message-buffer header-start nil get-buffer-create " *FQM scratch*" erase-buffer insert-buffer-substring t re-search-forward replace-match "" 0 1 looking-at "^[ 	]+" point-marker mail-strip-quoted-names string-match "\$[, 	\n
]*\$\$[^, 	\n
]+\$" 2 add-to-list address-list kill-buffer header-end case-fold-search addr-regexp] 5 (#$ . 79449)])
#@47 Offer the user one last chance to give it up.
(defalias 'feedmail-one-last-look #[(feedmail-prepped-text-buffer) "\212\300\213)\207" [((byte-code "\302!\210\303\304!\203�	\247\203�\304\305\306	!	\307V#\207\310\305!\207" [feedmail-prepped-text-buffer feedmail-confirm-outgoing-timeout switch-to-buffer fboundp y-or-n-p-with-timeout "FQM: Send this email? " abs 0 y-or-n-p] 5))] 1 (#$ . 80485)])
#@46 Internal; does filename end with FQM suffix?
(defalias 'feedmail-fqm-p #[(might-be) "\302\303!\304P	\"\207" [feedmail-queue-fqm-suffix might-be string-match regexp-quote "$"] 3 (#$ . 80888)])
#@79 Internal; finds the end of message header fields, returns mark just before it
(defalias 'feedmail-find-eoh #[(&optional noerror) "\212eb\210\303\304\305!\306Q\307	#\204\"�\n\205'�\303\304\305\n!\306Q\307	#\205'�\310y\210\311 )\207" [mail-header-separator noerror feedmail-queue-alternative-mail-header-separator re-search-forward "^" regexp-quote "\n" nil -1 point-marker] 4 (#$ . 81087)])
(provide 'feedmail)

${this.title}

Code Editor : feedmail.elc