(Fwrite_region): Use `visiting' rather than `visit'

[emacs.git] / lisp / superyank.el

;;; superyank.el --- smart message-yanking code for GNUS

;; Copyright (C) 1992 Free Software Foundation, Inc.

;; Author: Barry A. Warsaw <warsaw@cme.nist.gov>
;; Version: 1.1
;; Adapted-By: ESR
;; Keywords: news

;; This file is part of GNU Emacs.

;; GNU Emacs is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.

;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING.  If not, write to
;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.

;;; Commentary:

;; Inserts the message being replied to with various user controlled
;; citation styles.
;;

;; This file is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY.  No author or distributor
;; accepts responsibility to anyone for the consequences of using it
;; or for whether it serves any particular purpose or works at all,
;; unless he says so in writing.  Refer to the GNU Emacs General Public
;; License for full details.

;; Everyone is granted permission to copy, modify and redistribute
;; this file, but only under the conditions described in the
;; GNU Emacs General Public License.   A copy of this license is
;; supposed to have been given to you along with GNU Emacs so you
;; can know your rights and responsibilities.  It should be in a
;; file named COPYING.  Among other things, the copyright notice
;; and this notice must be preserved on all copies.

;; NAME: Barry A. Warsaw                USMAIL: National Institute of Standards
;; TELE: (301) 975-3460                         and Technology (formerly NBS)
;; UUCP: {...}!uunet!cme-durer!warsaw           Rm. B-124, Bldg. 220
;; ARPA: warsaw@cme.nist.gov                    Gaithersburg, MD 20899

;; Modification history:
;;
;; modified: 14-Jun-1989 baw (better keymap set procedure, rewrite-headers)
;; modified: 12-Jun-1989 baw (added defvar for sy-use-only-preference-p)
;; modified:  6-Jun-1989 baw (better sy-rewrite-headers, no kill/yank)
;; modified:  5-Jun-1989 baw (requires rnewspost.el)
;; modified:  1-Jun-1989 baw (persistent attribution, sy-open-line)
;; modified: 31-May-1989 baw (fixed some gnus problems, id'd another)
;; modified: 22-May-1989 baw (documentation)
;; modified:  8-May-1989 baw (auto filling of regions)
;; modified:  1-May-1989 baw (documentation)
;; modified: 27-Apr-1989 baw (new preference scheme)
;; modified: 24-Apr-1989 baw (remove gnus headers, attrib scheme, cite lines)
;; modified: 19-Apr-1989 baw (cite key, fill p, yank region, naming scheme)
;; modified: 12-Apr-1989 baw (incorp other mail yank features seen on net)
;; created : 16-Feb-1989 baw (mod vanilla fn indent-rigidly mail-yank-original)

;; Though I wrote this package basically from scratch, as an Emacs Lisp
;; learning exercise, it was inspired by postings of similar packages to
;; the gnu.emacs newsgroup over the past month or so.
;;
;; Here's a brief history of how this package developed:
;;
;; I as well as others on the net were pretty unhappy about the way emacs
;; cited replies with the tab or 4 spaces.  It looked ugly and made it hard
;; to distinguish between original and cited lines.  I hacked on the function
;; yank-original to at least give the user the ability to define the citation
;; character.  I posted this simple hack, and others did as well.  The main
;; difference between mine and others was that a space was put after the
;; citation string on on new citations, but not after previously cited lines:
;;
;; >> John wrote this originally
;; > Jane replied to that
;;
;; Then Martin Neitzel posted some code that he developed, derived in part
;; from code that Ashwin Ram posted previous to that.  In Martin's
;; posting, he introduced a new, and (IMHO) superior, citation style,
;; eliminating nested citations.  Yes, I wanted to join the Small-But-
;; Growing-Help-Stamp-Out-Nested-Citation-Movement! You should too.
;;
;; But Martin's code simply asks the user for the citation string (here
;; after called the `attribution' string), and I got to thinking, it wouldn't
;; be that difficult to automate that part.  So I started hacking this out.
;; It proved to be not as simple as I first thought.  But anyway here it
;; is.  See the wish list below for future plans (if I have time).
;;
;; Type "C-h f mail-yank-original" after this package is loaded to get a
;; description of what it does and the variables that control it.
;;
;; ======================================================================
;;
;; Changes wish list
;;
;; 1) C-x C-s yanks a region from the RMAIL buffer instead of the
;;    whole buffer
;;
;; 2) reparse nested citations to try to recast as non-nested citations
;;    perhaps by checking the References: line
;;

;;; Code:

;; ======================================================================
;;
;; require and provide features
;;
(require 'sendmail)
;;
;; ======================================================================
;;
;; don't need rnewspost.el to rewrite the header.  This only works
;; with diffs to rnewspost.el that I posted with the original
;; superyank code.
;;
(setq news-reply-header-hook nil)

;; **********************************************************************
;; start of user defined variables
;; **********************************************************************
;;
;; this section defines variables that control the operation of
;; super-mail-yank.  Most of these are described in the comment section
;; as well as the DOCSTRING.
;;

;;
;; ----------------------------------------------------------------------
;;
;; this variable holds the default author's name for citations
;;
(defvar sy-default-attribution "Anon"
  "String that describes attribution to unknown person. This string
should not contain the citation string.")

;;
;; ----------------------------------------------------------------------
;;
;; string used as an end delimiter for both nested and non-nested citations
;;
(defvar sy-citation-string ">"
  "String to use as an end-delimiter for citations.  This string is
used in both nested and non-nested citations.  For best results, use a
single character with no trailing space.  Most commonly used string
is: \">\.")

;;
;; ----------------------------------------------------------------------
;;
;; variable controlling citation type, nested or non-nested
;;
(defvar sy-nested-citation-p nil
  "Non-nil uses nested citations, nil uses non-nested citations.
Nested citations are of the style:

I wrote this
> He wrote this
>> She replied to something he wrote

Non-nested citations are of the style:

I wrote this
John> He wrote this
Jane> She originally wrote this")


;;
;; ----------------------------------------------------------------------
;;
;; regular expression that matches existing citations
;;
(defvar sy-cite-regexp "[a-zA-Z0-9]*>"
  "Regular expression that describes how an already cited line in an
article begins.  The regexp is only used at the beginning of a line,
so it doesn't need to begin with a '^'.")

;;
;; ----------------------------------------------------------------------
;;
;; regular expression that delimits names from titles in the field that
;; looks like:   (John X. Doe -- Computer Hacker Extraordinaire)
;;
(defvar sy-titlecue-regexp "\\s +-+\\s +"
  
  "Regular expression that delineates names from titles in the name
field.  Often, people will set up their name field to look like this:

(John Xavier Doe -- Computer Hacker Extraordinaire)

Set to nil to treat entire field as a name.")

;;
;; ----------------------------------------------------------------------
;;
;;
(defvar sy-preferred-attribution 2
  
  "This is an integer indicating what the user's preference is in
attribution style, based on the following key:

0: email address name is preferred
1: initials are preferred
2: first name is preferred
3: last name is preferred

The value of this variable may also be greater than 3, which would
allow you to prefer the 2nd through nth - 1 name.  If the preferred
attribution is nil or the empty string, then the secondary preferrence
will be the first name.  After that, the entire name alist is search
until a non-empty, non-nil name is found.  If no such name is found,
then the user is either queried or the default attribution string is
used depending on the value of sy-confirm-always-p.

Examples:

assume the from: line looks like this:

from: doe@computer.some.where.com (John Xavier Doe)

The following preferences would return these strings:

0: \"doe\"
1: \"JXD\"
2: \"John\"
3: \"Doe\"
4: \"Xavier\"

anything else would return \"John\".")

;;
;; ----------------------------------------------------------------------
;;
(defvar sy-confirm-always-p t
  "If t, always confirm attribution string before inserting into
buffer.")


;;
;; ----------------------------------------------------------------------
;;
;; informative header hook
;;
(defvar sy-rewrite-header-hook 'sy-header-on-said
  "Hook for inserting informative header at the top of the yanked
message. Set to nil for no header.  Here is a list of predefined
header styles; you can use these as a model to write you own:

sy-header-on-said [default]:   On 14-Jun-1989 GMT,
                               John Xavier Doe said:

sy-header-inarticle-writes:    In article <123456789> John Xavier Doe writes:

sy-header-regarding-writes:    Regarding RE: superyank; John Xavier Doe adds:

sy-header-verbose:             On 14-Jun-1989 GMT, John Xavier Doe
                               from the organization Great Company
                               has this to say about article <123456789>
                               in newsgroups misc.misc
                               concerning RE: superyank
                               referring to previous articles <987654321>

You can use the following variables as information strings in your header:

sy-reply-yank-date:         the date field              [ex: 14-Jun-1989 GMT]
sy-reply-yank-from:         the from field              [ex: John Xavier Doe]
sy-reply-yank-message-id:   the message id              [ex: <123456789>]
sy-reply-yank-subject:      the subject line            [ex: RE: superyank]
sy-reply-yank-newsgroup:    the newsgroup name for GNUS [ex: misc.misc]
sy-reply-yank-references:   the article references      [ex: <987654321>]
sy-reply-yank-organization: the author's organization   [ex: Great Company]

If a field can't be found, because it doesn't exist or is not being
shown, perhaps because of toggle-headers, the corresponding field
variable will contain the string \"mumble mumble\".")

;;
;; ----------------------------------------------------------------------
;;
;; non-nil means downcase the author's name string
;;
(defvar sy-downcase-p nil
  "Non-nil means downcase the author's name string.")

;;
;; ----------------------------------------------------------------------
;;
;; controls removal of leading white spaces
;;
(defvar sy-left-justify-p nil
  "If non-nil, delete all leading white space before citing.")

;;
;; ----------------------------------------------------------------------
;;
;; controls auto filling of region
;;
(defvar sy-auto-fill-region-p nil
  "If non-nil, automatically fill each paragraph that is cited.  If
nil, do not auto fill each paragraph.")


;;
;; ----------------------------------------------------------------------
;;
;; controls use of preferred attribution only, or use of attribution search
;; scheme if the preferred attrib can't be found.
;;
(defvar sy-use-only-preference-p nil
  
  "If non-nil, then only the preferred attribution string will be
used.  If the preferred attribution string can not be found, then the
sy-default-attribution will be used.  If nil, and the preferred
attribution string is not found, then some secondary scheme will be
employed to find a suitable attribution string.")

;; **********************************************************************
;; end of user defined variables
;; **********************************************************************

;;
;; ----------------------------------------------------------------------
;;
;; The new citation style means we can clean out other headers in addition
;; to those previously cleaned out.  Anyway, we create our own headers.
;; Also, we want to clean out any headers that gnus puts in.  Add to this
;; for other mail or news readers you may be using.
;;
(setq mail-yank-ignored-headers "^via:\\|^origin:\\|^status:\\|^re\\(mail\\|ceiv\\)ed\\|^[a-z-]*message-id:\\|^\\(summary-\\)?line[s]?:\\|^cc:\\|^subject:\\|^\\(\\(in-\\)?reply-\\)?to:\\|^\\(\\(return\\|reply\\)-\\)?path:\\|^\\(posted-\\)?date:\\|^\\(mail-\\)?from:\\|^newsgroup[s]?:\\|^organization:\\|^keywords:\\|^distribution:\\|^references:")

;;
;; ----------------------------------------------------------------------
;;
;; global variables, not user accessable
;;
(setq sy-persist-attribution (concat sy-default-attribution "> "))
(setq sy-reply-yank-date "")
(setq sy-reply-yank-from "")
(setq sy-reply-yank-message-id "")
(setq sy-reply-yank-subject "")
(setq sy-reply-yank-newsgroups "")
(setq sy-reply-yank-references "")
(setq sy-reply-yank-organization "")

;;
;; ======================================================================
;;
;; This section contains primitive functions used in the schemes.  They
;; extract name fields from various parts of the "from:" field based on
;; the control variables described above.
;;
;; Some will use recursion to pick out the correct namefield in the namestring
;; or the list of initials.  These functions all scan a string that contains
;; the name, ie:  "John Xavier Doe".  There is no limit on the number of names
;; in the string.  Also note that all white spaces are basically ignored and
;; are stripped from the returned strings, and titles are ignored if 
;; sy-titlecue-regexp is set to non-nil.
;;
;; Others will use methods to try to extract the name from the email
;; address of the originator.  The types of addresses readable are
;; described above.

;;
;; ----------------------------------------------------------------------
;;
;; try to extract the name from an email address of the form
;; name%[stuff]
;;
;; Unlike the get-name functions above, these functions operate on the
;; buffer instead of a supplied name-string.
;;
(defun sy-%-style-address ()
  (beginning-of-line)
  (buffer-substring
   (progn (re-search-forward "%" (point-max) t)
          (if (not (bolp)) (forward-char -1))
          (point))
   (progn (re-search-backward "^\\|[^a-zA-Z0-9]")
          (point))))

;;
;; ----------------------------------------------------------------------
;;
;; try to extract names from addresses with the form:
;; [stuff]name@[stuff]
;;
(defun sy-@-style-address ()
  (beginning-of-line)
  (buffer-substring
   (progn (re-search-forward "@" (point-max) t)
          (if (not (bolp)) (forward-char -1))
          (point))
   (progn (re-search-backward "^\\|[^a-zA-Z0-0]")
          (if (not (bolp)) (forward-char 1))
          (point))))

;;
;; ----------------------------------------------------------------------
;;
;; try to extract the name from addresses with the form:
;; [stuff]![stuff]...!name[stuff]
;;
(defun sy-!-style-address ()
  (beginning-of-line)
  (buffer-substring
   (progn (while (re-search-forward "!" (point-max) t))
          (point))
   (progn (re-search-forward "[^a-zA-Z0-9]\\|$")
          (if (not (eolp)) (forward-char -1))
          (point))))

;;
;; ----------------------------------------------------------------------
;;
;; using the different email name schemes, try each one until you get a
;; non-nil entry
;;
(defun sy-get-emailname ()
  (let ((en1 (sy-%-style-address))
        (en2 (sy-@-style-address))
        (en3 (sy-!-style-address)))
    (cond
     ((not (string-equal en1 "")) en1)
     ((not (string-equal en2 "")) en2)
     ((not (string-equal en3 "")) en3)
     (t ""))))

;;
;; ----------------------------------------------------------------------
;;
;; returns the "car" of the namestring, really the first namefield
;;
;; (sy-string-car "John Xavier Doe")
;; => "John"
;;
(defun sy-string-car (namestring)
  (substring namestring
             (progn (string-match "\\s *" namestring) (match-end 0))
             (progn (string-match "\\s *\\S +" namestring) (match-end 0))))

;;
;; ----------------------------------------------------------------------
;;
;; returns the "cdr" of the namestring, really the whole string from
;; after the first name field to the end of the string.
;;
;; (sy-string-cdr "John Xavier Doe")
;; => "Xavier Doe"
;;
(defun sy-string-cdr (namestring)
  (substring namestring
             (progn (string-match "\\s *\\S +\\s *" namestring)
                    (match-end 0))))

;;
;; ----------------------------------------------------------------------
;;
;; convert a namestring to a list of namefields
;;
;; (sy-namestring-to-list "John Xavier Doe")
;; => ("John" "Xavier" "Doe")
;;
(defun sy-namestring-to-list (namestring)
  (if (not (string-match namestring ""))
      (append (list (sy-string-car namestring))
              (sy-namestring-to-list (sy-string-cdr namestring)))))

;;
;; ----------------------------------------------------------------------
;;
;; strip the initials from each item in the list and return a string
;; that is the concatenation of the initials
;;
(defun sy-strip-initials (raw-nlist)
  (if (not raw-nlist)
      nil
    (concat (substring (car raw-nlist) 0 1)
            (sy-strip-initials (cdr raw-nlist)))))


;;
;; ----------------------------------------------------------------------
;;
;; using the namestring, build a list which is in the following order
;;
;; (email, initials, firstname, lastname, name1, name2, name3 ... nameN-1)
;;
(defun sy-build-ordered-namelist (namestring)
  (let* ((raw-nlist (sy-namestring-to-list namestring))
         (initials (sy-strip-initials raw-nlist))
         (firstname (car raw-nlist))
         (revnames (reverse (cdr raw-nlist)))
         (lastname (car revnames))
         (midnames (reverse (cdr revnames)))
         (emailnames (sy-get-emailname)))
    (append (list emailnames)
            (list initials)
            (list firstname)
            (list lastname)
            midnames)))

;;
;; ----------------------------------------------------------------------
;;
;; Query the user for the attribution string.  Supply sy-default-attribution
;; as the default choice.
;;
(defun sy-query-for-attribution ()
  (concat 
   (let* ((prompt (concat "Enter attribution string: (default "
                          sy-default-attribution
                          ") "))
          (query (read-input prompt))
          (attribution (if (string-equal query "")
                           sy-default-attribution
                         query)))
     (if sy-downcase-p
         (downcase attribution)
       attribution))
   sy-citation-string))


;;
;; ----------------------------------------------------------------------
;;
;; parse the current line for the namestring
;;
(defun sy-get-namestring ()
  (save-restriction
    (beginning-of-line)
    (if (re-search-forward "(.*)" (point-max) t)
        (let ((start (progn
                       (beginning-of-line)
                       (re-search-forward "\\((\\s *\\)\\|$" (point-max) t)
                       (point)))
              (end (progn
                     (re-search-forward
                      (concat "\\(\\s *\\()\\|" sy-titlecue-regexp "\\)\\)\\|$")
                      (point-max) t)
                     (point))))
          (narrow-to-region start end)
          (let ((start (progn
                         (beginning-of-line)
                         (point)))
                (end (progn
                       (end-of-line)
                       (re-search-backward
                        (concat "\\s *\\()\\|" sy-titlecue-regexp "\\)$")
                        (point-min) t)
                       (point))))
            (buffer-substring start end)))
      (let ((start (progn
                     (beginning-of-line)
                     (re-search-forward "^\"*")
                     (point)))
            (end (progn
                   (re-search-forward "\\(\\s *[a-zA-Z0-9\\.]+\\)*"
                                      (point-max) t)
                   (point))))
        (buffer-substring start end)))))


;;
;; ----------------------------------------------------------------------
;;
;; scan the nlist and return the integer pointing to the first legal
;; non-empty namestring.  Returns the integer pointing to the index
;; in the nlist of the preferred namestring, or nil if no legal
;; non-empty namestring could be found.
;;
(defun sy-return-preference-n (nlist)
  (let ((p sy-preferred-attribution)
        (exception nil))
    ;;
    ;; check to be sure the index is not out-of-bounds
    ;;
    (cond
     ((< p 0) (setq p 2) (setq exception t))
     ((not (nth p nlist)) (setq p 2) (setq exception t)))
    ;;
    ;; check to be sure that the explicit preference is not empty
    ;;
    (if (string-equal (nth p nlist) "")
        (progn (setq p 0)
               (setq exception t)))
    ;;
    ;; find the first non-empty namestring
    ;;
    (while (and (nth p nlist)
                (string-equal (nth p nlist) ""))
      (setq exception t)
      (setq p (+ p 1)))
    ;;
    ;; return the preference index if non-nil, otherwise nil
    ;;
    (if (or (and exception sy-use-only-preference-p)
            (not (nth p nlist)))
        nil
      p)))

;;
;;
;; ----------------------------------------------------------------------
;;
;; rebuild the nlist into an alist for completing-read.  Use as a guide
;; the index of the preferred name field.  Get the actual preferred
;; name field base on other factors (see above).  If no actual preferred
;; name field is found, then query the user for the attribution string.
;;
;; also note that the nlist is guaranteed to be non-empty.  At the very
;; least it will consist of 4 empty strings ("" "" "" "")
;; 
(defun sy-nlist-to-alist (nlist)
  (let ((preference (sy-return-preference-n nlist))
        alist
        (n 0))
    ;;
    ;; check to be sure preference is not nil
    ;;
    (if (not preference)
        (setq alist (list (cons (sy-query-for-attribution) nil)))
      ;;
      ;; preference is non-nil
      ;;
      (setq alist (list (cons (nth preference nlist) nil)))
      (while (nth n nlist)
        (if (= n preference) nil
          (setq alist (append alist (list (cons (nth n nlist) nil)))))
        (setq n (+ n 1))))
    alist))



;;
;; ----------------------------------------------------------------------
;;
;; confirm if desired after the alist has been built
;;
(defun sy-get-attribution (alist)
  (concat
   ;;
   ;; check to see if nested citations are to be used
   ;;
   (if sy-nested-citation-p
       ""
     ;;
     ;; check to see if confirmation is needed
     ;; if not, just return the preference (first element in alist)
     ;;
     (if (not sy-confirm-always-p)
         (car (car alist))
       ;;
       ;; confirmation is requested so build the prompt, confirm
       ;; and return the chosen string
       ;;
       (let* (ignore
              (prompt (concat "Complete attribution string: (default "
                              (car (car alist))
                              ") "))
              ;;
              ;; set up the local completion keymap
              ;;
              (minibuffer-local-must-match-map
               (let ((map (make-sparse-keymap)))
                 (define-key map "?"    'minibuffer-completion-help)
                 (define-key map " "    'minibuffer-complete-word)
                 (define-key map "\t"   'minibuffer-complete)
                 (define-key map "\00A" 'exit-minibuffer)
                 (define-key map "\00D" 'exit-minibuffer)
                 (define-key map "\007"
                   '(lambda ()
                      (interactive)
                      (beep)
                      (exit-minibuffer)))
                 map))
              ;;
              ;; read the completion
              ;;
              (attribution (completing-read prompt alist))
              ;;
              ;; check attribution string for emptyness
              ;;
              (choice (if (or (not attribution)
                              (string-equal attribution ""))
                          (car (car alist))
                        attribution)))
         
         (if sy-downcase-p
             (downcase choice)
           choice))))
   sy-citation-string))


;;
;; ----------------------------------------------------------------------
;;
;; this function will scan the current rmail buffer, narrowing it to the
;; from: line, then using this, it will try to decipher some names from
;; that line.  It will then build the name alist and try to confirm
;; its choice of attribution strings.  It returns the chosen attribution
;; string.
;;
(defun sy-scan-rmail-for-names (rmailbuffer)
  (save-excursion
    (let ((case-fold-search t)
          alist
          attribution)
      (switch-to-buffer rmailbuffer)
      (goto-char (point-min))
      ;;
      ;; be sure there is a from: line
      ;;
      (if (not (re-search-forward "^from:\\s *" (point-max) t))
          (setq attribution (sy-query-for-attribution))
        ;;
        ;; if there is a from: line, then scan the narrow the buffer,
        ;; grab the namestring, and build the alist, then using this
        ;; get the attribution string.
        ;;
        (save-restriction
          (narrow-to-region (point)
                            (progn (end-of-line) (point)))
          (let* ((namestring (sy-get-namestring))
                 (nlist (sy-build-ordered-namelist namestring)))
            (setq alist (sy-nlist-to-alist nlist))))
        ;;
        ;; we've built the alist, now confirm the attribution choice
        ;; if appropriate
        ;;
        (setq attribution (sy-get-attribution alist)))
      attribution)))


;;
;; ======================================================================
;;
;; the following function insert of citations, writing of headers, filling
;; paragraphs and general higher level operations
;;

;;
;; ----------------------------------------------------------------------
;;
;; insert a nested citation
;;
(defun sy-insert-citation (start end cite-string)
  (save-excursion
    (goto-char end)
    (setq end (point-marker))
    (goto-char start)
    (or (bolp)
        (forward-line 1))
    
    (let ((fill-prefix (concat cite-string " "))
          (fstart (point))
          (fend (point)))
      
      (while (< (point) end)
        ;;
        ;; remove leading tabs if desired
        ;;
        (if sy-left-justify-p
            (delete-region (point)
                           (progn (skip-chars-forward " \t") (point))))
        ;;
        ;; check to see if the current line should be cited
        ;;
        (if (or (eolp)
                (looking-at sy-cite-regexp))
            ;;
            ;; do not cite this line unless nested-citations are to be 
            ;; used
            ;;
            (progn
              (or (eolp)
                  (if sy-nested-citation-p
                      (insert cite-string)))
              
              ;; set fill start and end points
              ;;
              (or (= fstart  fend)
                  (not sy-auto-fill-region-p)
                  (progn (goto-char fend)
                         (or (not (eolp))
                             (setq fend (+ fend 1)))
                         (fill-region-as-paragraph fstart fend)))
              (setq fstart (point))
              (setq fend (point)))
          
          ;; else
          ;;
          (insert fill-prefix)
          (end-of-line)
          (setq fend (point)))
        
        (forward-line 1)))
    (move-marker end nil)))

;;
;; ----------------------------------------------------------------------
;;
;; yank a particular field into a holding variable
;;
(defun sy-yank-fields (start)
  (save-excursion
    (goto-char start)
    (setq sy-reply-yank-date         (mail-fetch-field "date")
          sy-reply-yank-from         (mail-fetch-field "from")
          sy-reply-yank-subject      (mail-fetch-field "subject")
          sy-reply-yank-newsgroups   (mail-fetch-field "newsgroups")
          sy-reply-yank-references   (mail-fetch-field "references")
          sy-reply-yank-message-id   (mail-fetch-field "message-id")
          sy-reply-yank-organization (mail-fetch-field "organization"))
    (or sy-reply-yank-date
        (setq sy-reply-yank-date "mumble mumble"))
    (or sy-reply-yank-from
        (setq sy-reply-yank-from "mumble mumble"))
    (or sy-reply-yank-subject
        (setq sy-reply-yank-subject "mumble mumble"))
    (or sy-reply-yank-newsgroups
        (setq sy-reply-yank-newsgroups "mumble mumble"))
    (or sy-reply-yank-references
        (setq sy-reply-yank-references "mumble mumble"))
    (or sy-reply-yank-message-id
        (setq sy-reply-yank-message-id "mumble mumble"))
    (or sy-reply-yank-organization
        (setq sy-reply-yank-organization "mumble mumble"))))

;;
;; ----------------------------------------------------------------------
;;
;; rewrite the header to be more conversational
;;
(defun sy-rewrite-headers (start)
  (goto-char start)
  (run-hooks 'sy-rewrite-header-hook))

;;
;; ----------------------------------------------------------------------
;;
;; some different styles of headers
;;
(defun sy-header-on-said ()
  (insert-string "\nOn " sy-reply-yank-date ",\n"
                 sy-reply-yank-from " said:\n"))

(defun sy-header-inarticle-writes ()
  (insert-string "\nIn article " sy-reply-yank-message-id
                 " " sy-reply-yank-from " writes:\n"))

(defun sy-header-regarding-writes ()
  (insert-string "\nRegarding " sy-reply-yank-subject
                 "; " sy-reply-yank-from " adds:\n"))

(defun sy-header-verbose ()
  (insert-string "\nOn " sy-reply-yank-date ",\n"
                 sy-reply-yank-from "\nfrom the organization "
                 sy-reply-yank-organization "\nhad this to say about article "
                 sy-reply-yank-message-id "\nin newsgroups "
                 sy-reply-yank-newsgroups "\nconcerning "
                 sy-reply-yank-subject "\nreferring to previous articles "
                 sy-reply-yank-references "\n"))

;;
;; ----------------------------------------------------------------------
;;
;; yank the original article in and attribute
;;
(defun sy-yank-original (arg)
  
  "Insert the message being replied to, if any (in rmail/gnus). Puts
point before the text and mark after. Calls generalized citation
function sy-insert-citation to cite all allowable lines."
  
  (interactive "P")
  (if mail-reply-buffer
      (let* ((sy-confirm-always-p (if (consp arg)
                                      t
                                    sy-confirm-always-p))
             (attribution (sy-scan-rmail-for-names mail-reply-buffer))
             (top (point))
             (start (point))
             (end (progn (delete-windows-on mail-reply-buffer)
                         (insert-buffer mail-reply-buffer)
                         (mark))))
        
        (sy-yank-fields start)
        (sy-rewrite-headers start)
        (setq start (point))
        (mail-yank-clear-headers top (mark))
        (setq sy-persist-attribution (concat attribution " "))
        (sy-insert-citation start end attribution))
    
    (goto-char top)
    (exchange-point-and-mark)))


;;
;; ----------------------------------------------------------------------
;;
;; this is here for compatibility with existing mail/news yankers
;; overloads the default mail-yank-original
;;
(defun mail-yank-original (arg)
  
  "Yank original message buffer into the reply buffer, citing as per
user preferences.  Numeric Argument forces confirmation.

Here is a description of the superyank.el package, what it does and
what variables control its operation.  This was written by Barry
Warsaw (warsaw@cme.nist.gov, {...}!uunet!cme-durer!warsaw).

A 'Citation' is the acknowledgement of the original author of a mail
message.  There are two general forms of citation. In 'nested
citations', indication is made that the cited line was written by
someone *other* that the current message author (or by that author at
an earlier time).  No indication is made as to the identity of the
original author.  Thus, a nested citation after multiple replies would
look like this (this is after my reply to a previous message):

>>John originally wrote this
>>and this as well
> Jane said that John didn't know
> what he was talking about
And that's what I think as well.

In non-nested citations, you won't see multiple \">\" characters at
the beginning of the line.  Non-nested citations will insert an
informative string at the beginning of a cited line, attributing that
line to an author.  The same message described above might look like
this if non-nested citations were used:

John> John originally wrote this
John> and this as well
Jane> Jane said that John didn't know
Jane> what he was talking about
And that's what I think as well.

Notice that my inclusion of Jane's inclusion of John's original
message did not result in a cited line of the form: Jane>John>.  Thus
no nested citations.  The style of citation is controlled by the
variable `sy-nested-citation-p'.  Nil uses non-nested citations and
non-nil uses old style, nested citations.

The variable `sy-citation-string' is the string to use as a marker for
a citation, either nested or non-nested.  For best results, this
string should be a single character with no trailing space and is
typically the character \">\".  In non-nested citations this string is
appended to the attribution string (author's name), along with a
trailing space.  In nested citations, a trailing space is only added
to a first level citation.

Another important variable is `sy-cite-regexp' which describes strings
that indicate a previously cited line.  This regular expression is
always used at the beginning of a line so it doesn't need to begin
with a \"^\" character.  Change this variable if you change
`sy-citation-string'.

The following section only applies to non-nested citations.

This package has a fair amount of intellegence related to deciphering
the author's name based on information provided by the original
message buffer.  In normal operation, the program will pick out the
author's first and last names, initials, terminal email address and
any other names it can find.  It will then pick an attribution string
from this list based on a user defined preference and it will ask for
confirmation if the user specifies.  This package gathers its
information from the `From:' line of the original message buffer.  It
recognizes From: lines with the following forms:

From: John Xavier Doe <doe@speedy.computer.com>
From: \"John Xavier Doe\" <doe@speedy.computer.com>
From: doe@speedy.computer.com (John Xavier Doe)
From: computer!speedy!doe (John Xavier Doe)
From: computer!speedy!doe (John Xavier Doe)
From: doe%speedy@computer.com (John Xavier Doe)

In this case, if confirmation is requested, the following strings will
be made available for completion and confirmation:

\"John\"
\"Xavier\"
\"Doe\"
\"JXD\"
\"doe\"

Note that completion is case sensitive.  If there was a problem
picking out a From: line, or any other problem getting even a single
name, then the user will be queried for an attribution string.  The
default attribution string is set in the variable
`sy-default-attribution'.

Sometimes people set their name fields so that it also includes a
title of the form:

From: doe@speedy.computer.com (John Doe -- Hacker Extraordinaire)

To avoid the inclusion of the string \"-- Hacker Extraordinaire\" in
the name list, the variable `sy-titlecue-regexp' is provided.  Its
default setting will still properly recognize names of the form:

From: xdoe@speedy.computer.com (John Xavier-Doe -- Crazed Hacker)

The variable `sy-preferred-attribution' contains an integer that
indicates which name field the user prefers to use as the attribution
string, based on the following key:

0: email address name is preferred
1: initials are preferred
2: first name is preferred
3: last name is preferred

The value can be greater than 3, in which case, you would be
preferring the 2nd throught nth -1 name.  In any case, if the
preferred name can't be found, then one of two actions will be taken
depending on the value of the variable `sy-use-only-preference-p'.  If
this is non-nil, then the `sy-default-attribution will be used.  If it
is nil, then a secondary scheme will be employed to find a suitable
attribution scheme.  First, the author's first name will be used.  If
that can't be found than the name list is searched for the first
non-nil, non-empty name string.  If still no name can be found, then
the user is either queried, or the `sy-default-attribution' is used,
depending on the value of `sy-confirm-always-p'.

If the variable `sy-confirm-always-p' is non-nil, superyank will always
confirm the attribution string with the user before inserting it into
the reply buffer.  Confirmation is with completion, but the completion
list is merely a suggestion; the user can override the list by typing
in a string of their choice.

The variable `sy-rewrite-header-hook' is a hook that contains a lambda
expression which rewrites the informative header at the top of the
yanked message.  Set to nil to avoid writing any header.

You can make superyank autofill each paragraph it cites by setting the
variable `sy-auto-fill-region-p' to non-nil.  Or set the variable to nil
and fill the paragraphs manually with sy-fill-paragraph-manually (see
below).

Finally, `sy-downcase-p' if non-nil, indicates that you always want to
downcase the attribution string before insertion, and
`sy-left-justify-p', if non-nil, indicates that you want to delete all
leading white space before citing.

Since the almost all yanking in other modes (RMAIL, GNUS) is done
through the function `mail-yank-original', and since superyank
overloads this function, cited yanking is automatically bound to the
C-c C-y key.  There are three other smaller functions that are
provided with superyank and they are bound as below.  Try C-h f on
each function to get more information on these functions.

Key Bindings:

C-c C-y     mail-yank-original (superyank's version)
C-c q       sy-fill-paragraph-manually
C-c C-q     sy-fill-paragraph-manually
C-c i       sy-insert-persist-attribution
C-c C-i     sy-insert-persist-attribution
C-c C-o     sy-open-line


Summary of variables, with their default values:

sy-default-attribution     (default: \"Anon\")
           Attribution to use if no attribution string can be deciphered
           from the original message buffer.

sy-citation-string         (default: \">\")
           String to append to the attribution string for citation, for
           best results, it should be one character with no trailing space.

sy-nested-citation-p       (default: nil)
           Nil means use non-nested citations, non-nil means use old style
           nested citations.

sy-cite-regexp             (default: \"[a-zA-Z0-9]*>\")
           Regular expression that matches the beginning of a previously
           cited line.  Always used at the beginning of a line so it does
           not need to start with a \"^\" character.

sy-titlecue-regexp         (default: \"\\s +-+\\s +\")
           Regular expression that matches a title delimiter in the name
           field.

sy-preferred-attribution   (default: 2)
           Integer indicating user's preferred attribution field.

sy-confirm-always-p        (default: t)
           Non-nil says always confirm with completion before inserting
           attribution.

sy-rewrite-header-hook     (default: 'sy-header-on-said)
           Hook for inserting informative header at the top of the yanked
           message.

sy-downcase-p              (default: nil)
           Non-nil says downcase the attribution string before insertion.

sy-left-justify-p          (default: nil)
           Non-nil says delete leading white space before citing.
  
sy-auto-fill-region-p      (default: nil)
           Non-nil says don't auto fill the region.  T says auto fill the
           paragraph.

sy-use-only-preference-p   (default: nil)
           If nil, use backup scheme when preferred attribution string
           can't be found.  If non-nil and preferred attribution string
           can't be found, then use sy-default-attribution."
  
  (interactive "P")
  
  (local-set-key "\C-cq"    'sy-fill-paragraph-manually)
  (local-set-key "\C-c\C-q" 'sy-fill-paragraph-manually)
  (local-set-key "\C-c\i"   'sy-insert-persist-attribution)
  (local-set-key "\C-c\C-i" 'sy-insert-persist-attribution)
  (local-set-key "\C-c\C-o" 'sy-open-line)
  
  (sy-yank-original arg))


;;
;; ----------------------------------------------------------------------
;;
;; based on Bruce Israel's "fill-paragraph-properly", and modified from
;; code posted by David C. Lawrence.  Modified to use the persistant
;; attribution if none could be found from the paragraph.
;;
(defun sy-fill-paragraph-manually (arg)
  "Fill paragraph containing or following point.
This automatically finds the sy-cite-regexp and uses it as the prefix.
If the sy-cite-regexp is not in the first line of the paragraph, it
makes a guess at what the fill-prefix for the paragraph should be by
looking at the first line and taking anything up to the first
alphanumeric character.

Prefix arg means justify both sides of paragraph as well.

This function just does fill-paragraph if the fill-prefix is set. If
what it deduces to be the paragraph prefix (based on the first line)
does not precede each line in the region, then the persistant
attribution is used.  The persistant attribution is just the last
attribution string used to cite lines."
  
  (interactive "P")
  (save-excursion
    (forward-paragraph)
    (or (bolp)
        (newline 1))
    
    (let ((end (point))
          st
          (fill-prefix fill-prefix))
      (backward-paragraph)
      (if (looking-at "\n")
          (forward-char 1))
      (setq st (point))
      (if fill-prefix
          nil
        (untabify st end) ;; die, scurvy tabs!
        ;;
        ;; untabify might have made the paragraph longer character-wise,
        ;; make sure end reflects the correct location of eop.
        ;;
        (forward-paragraph)
        (setq end (point))
        (goto-char st)
        (if (looking-at sy-cite-regexp)
            (setq fill-prefix (concat
                               (buffer-substring
                                st (progn (re-search-forward sy-cite-regexp)
                                          (point)))
                               " "))
          ;;
          ;; this regexp is is convenient because paragraphs quoted by simple
          ;; indentation must still yield to us  <evil laugh>
          ;;
          (while (looking-at "[^a-zA-Z0-9]")
            (forward-char 1))
          (setq fill-prefix (buffer-substring st (point))))
        (next-line 1) (beginning-of-line)
        (while (and (< (point) end)
                    (not (string-equal fill-prefix "")))
          ;;
          ;; if what we decided was the fill-prefix does not precede all
          ;; of the lines in the paragraph, we probably goofed.  In this
          ;; case set it to the persistant attribution.
          ;;
          (if (looking-at (regexp-quote fill-prefix))
              ()
            (setq fill-prefix sy-persist-attribution))
          (next-line 1)
          (beginning-of-line)))
      (fill-region-as-paragraph st end arg))))

;;
;; ----------------------------------------------------------------------
;;
;; insert the persistant attribution at point
;;
(defun sy-insert-persist-attribution ()
  "Insert the persistant attribution.
This inserts the peristant attribution at the beginning of the line that
point is on.  This string is the last attribution confirmed and used
in the yanked reply buffer."
  (interactive)
  (save-excursion
    (beginning-of-line)
    (insert-string sy-persist-attribution)))


;;
;; ----------------------------------------------------------------------
;;
;; open a line putting the attribution at the beginning

(defun sy-open-line (arg)
  "Insert a newline and leave point before it.
Also inserts the persistant attribution at the beginning of the line.
With argument, inserts ARG newlines."
  (interactive "p")
  (save-excursion
    (let ((start (point)))
      (open-line arg)
      (goto-char start)
      (forward-line)
      (while (< 0 arg)
        (sy-insert-persist-attribution)
        (forward-line 1)
        (setq arg (- arg 1))))))

(provide 'superyank)

;;; superyank.el ends here