Initial revision

1 files changed, 1563 insertions, 0 deletions

diff --git a/lisp/sc.el b/lisp/sc.el
new file mode 100644
index 00000000000..30b1b5f64e5
--- /dev/null
+++ b/lisp/sc.el
@@ -0,0 +1,1563 @@
+;; -*- Mode: Emacs-Lisp -*-
+;; sc.el -- Version 2.3 (used to be supercite.el)
+
+;; ========== Introduction ==========
+;; Citation and attribution package for various GNU emacs news and
+;; electronic mail reading subsystems.  This version of supercite will
+;; interface to VM 4.40+ and MH-E 3.7 (shipped w/ emacs 18.57) as is.
+;; It will also interface with GNUS 3.12+, RMAIL 18.55+, GNEWS, and
+;; probably most other news/mail subsystems by using the overloading
+;; functions provided in sc-oloads.el (see that file or the README for
+;; more information on interfacing supercite with your reader subsystem).
+;; This version should now be compatible with Lucid Emacs 19.x emacses.
+
+;; This package does not do any yanking of messages, but instead
+;; massages raw reply buffers set up by the reply/forward functions in
+;; the news/mail subsystems. Therefore, such useful operations as
+;; yanking and citing portions of the original article (instead of the
+;; whole article) are not within the ability or responsiblity of
+;; supercite.
+
+;; ========== Disclaimer ==========
+;; This software is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY.  No author or distributor, nor any
+;; author's past, present, or future employers 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.
+
+;; Some of this software was written as part of the supercite author's
+;; official duty as an employee of the United States Government and is
+;; thus not subject to copyright.  You are free to use that particular
+;; software as you wish, but WITHOUT ANY WARRANTY WHATSOEVER.  It
+;; would be nice, though if when you use any of this or other freely
+;; available code, you give due credit to the author.
+
+;; Other parts of this code were written by other people.  Wherever
+;; possible, credit to that author, and the copy* notice supplied by
+;; the author are included with that code. The supercite author is no
+;; longer an employee of the U.S. Government so the GNU Public Licence
+;; should be considered in effect for all enhancements and bug fixes
+;; performed by the author.
+
+;; ========== Author (unless otherwise stated) ========================
+;; NAME: Barry A. Warsaw      USMAIL: Century Computing, Inc.
+;; TELE: (301) 593-3330               1014 West Street
+;; INET: bwarsaw@cen.com              Laurel, Md 20707
+;; UUCP: uunet!cen.com!bwarsaw
+;;
+;; Want to be on the Supercite mailing list?
+;;
+;; Send articles to:
+;;     Internet: supercite@anthem.nlm.nih.gov
+;;         UUCP: uunet!anthem.nlm.nih.gov!supercite
+;; 
+;; Send administrivia (additions/deletions to list, etc) to:
+;;     Internet: supercite-request@anthem.nlm.nih.gov
+;;         UUCP: uunet!anthem.nlm.nih.gov!supercite-request
+
+;; ========== Credits and Thanks ==========
+;; This package was derived from the Superyank 1.11 package as posted
+;; to the net.  Superyank 1.11 was inspired by code and ideas from
+;; Martin Neitzel and Ashwin Ram.  Supercite version 2.3 has evolved
+;; through the comments and suggestions of the supercite mailing list
+;; which consists of many authors and users of the various mail and
+;; news reading subsystems.
+
+;; Many folks on the supercite mailing list have contributed their
+;; help in debugging, making suggestions and supplying support code or
+;; bug fixes for the previous versions of supercite.  I want to thank
+;; everyone who helped, especially (in no particular order):
+;;
+;; Mark D. Baushke, Khalid Sattar, David Lawrence, Chris Davis, Kyle
+;; Jones, Kayvan Sylvan, Masanobu Umeda, Dan Jacobson, Piet van
+;; Oostrum, Hamish (H.I.) Macdonald, and Joe Wells.
+;;
+;; I don't mean to leave anyone out. All who have helped have been
+;; appreciated.
+
+;; ========== Getting Started ==========
+;; Here is a quick guide to getting started with supercite. The
+;; information contained here is mostly excerpted from the more
+;; detailed explanations given in the accompanying README file.
+;; Naturally, there are many customizations you can do to give your
+;; replies that personalized flair, but the instructions in this
+;; section should be sufficient for getting started.
+
+;; With this release of supercite overloading is the only supported
+;; way to get supercite hooked into your favorite news/mail reading
+;; subsystems.  Overloading will be necessary for RMAIL, GNUS, GNEWS,
+;; RNEWS and PCMAIL. Overloading will not be needed for VM 4.37+ or
+;; MH-E 3.7+.  MH-E comes with emacs 18.57 but if you have an earlier
+;; version of emacs, you should be able to ftp MH-E 3.7 separately. Or
+;; you can extract the MH-E overloading stuff from version 2.1's
+;; sc-oloads.el.
+
+;; First, to connect supercite to any mail/news reading subsystem, put
+;; this in your .emacs file:
+;;
+;; (setq mail-yank-hooks 'sc-cite-original)  ; for all but MH-E
+;; (setq mh-yank-hooks   'sc-cite-original)  ; for MH-E only
+;;
+;; If supercite is not pre-loaded into your emacs session, you should
+;; add the following autoload:
+;;
+;; (autoload 'sc-cite-original "sc" "Supercite 2.3" t)
+;;
+;; Then, if you need to overload, put the following in your .emacs file:
+;;
+;; (defun my-sc-overload-hook ()
+;;   (require 'sc-oloads)      ; be sure this file is on your load-path
+;;   (sc-overload-functions))
+;;
+;; (setq news-reply-mode-hook 'my-sc-overload-hook) ; for RNEWS,GNUS,GNEWS
+;; (setq mail-setup-hook      'my-sc-overload-hook) ; for RMAIL, PCMAIL
+;;
+;; Finally, if you want to customize supercite, you should do it in a
+;; function called my-supercite-hook and:
+;;
+;; (setq sc-load-hook 'my-supercite-hook)
+
+(require 'sc-alist)
+
+
+;; vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
+;; start of user defined variables
+;; vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
+
+(defvar sc-nested-citation-p nil
+  "*Controls whether to use nested or non-nested citation style.
+Non-nil uses nested citations, nil uses non-nested citations.  Type
+\\[sc-describe] for more information.")
+
+(defvar sc-citation-leader "	"
+  "*String comprising first part of a citation.")
+
+(defvar sc-citation-delimiter ">"
+  "*String comprising third part of a citation.
+This string is used in both nested and non-nested citations.")
+
+(defvar sc-citation-separator " "
+  "*String comprising fourth and last part of a citation.")
+
+(defvar sc-default-author-name "Anonymous"
+  "*String used when author's name cannot be determined.")
+
+(defvar sc-default-attribution "Anon"
+  "*String used when author's attribution cannot be determined.")
+
+;; Noriya KOBAYASHI (nk@ics.osaka-u.ac.jp) writes to the supercite
+;; mailing list:
+;; I use supercite in Nemacs-3.3.2.  In order to handle citation using
+;; Kanji, [...set sc-cite-regexp to...]
+;; "\\s *\\([a-zA-Z0-9]\\|\\cc\\|\\cC\\|\\ch\\|\\cH\\|\\ck\\|\\cK\\)*\\s *>+"
+;;
+(defvar sc-cite-regexp "\\s *[-a-zA-Z0-9_.]*>+\\s *"
+  "*Regular expression describing how a already cited line begins.
+The regexp is only used at the beginning of a line, so it doesn't need
+to start with a '^'.")
+
+(defvar sc-titlecue-regexp "\\s +-+\\s +"
+  "*Regular expression describing the separator between names and titles.
+Set to nil to treat entire field as a name.")
+
+(defvar sc-spacify-name-chars '(?_ ?* ?+ ?=)
+  "*List of characters to convert to spaces if found in an author's name.")
+
+(defvar sc-nicknames-alist
+  '(("Michael" "Mike")
+    ("Daniel" "Dan")
+    ("David" "Dave")
+    ("Jonathan" "John")
+    ("William" "Bill")
+    ("Elizabeth" "Beth")
+    ("Elizabeth" "Betsy")
+    ("Kathleen" "Kathy")
+    ("Smith" "Smitty"))
+  "*Association list of names and their common nicknames.
+Entries are of the form (NAME NICKNAME), and NAMEs can have more than
+one nickname. Nicknames will not be automatically used as an
+attribution string, since I'm not sure this is really polite, but if a
+name is glommed from the author name and presented in the attribution
+string completion list, the matching nicknames will also be presented.
+Set this variable to nil to defeat nickname expansions. Also note that
+nicknames are not put in the supercite information alist.")
+
+(defvar sc-confirm-always-p t
+  "*If non-nil, always confirm attribution string before citing text body.")
+
+(defvar sc-preferred-attribution 'firstname
+  "*Specifies which part of the author's name becomes the attribution.
+The value of this variable must be one of the following quoted symbols:
+
+     emailname   -- email terminus name
+     initials    -- initials of author
+     firstname   -- first name of author
+     lastname    -- last name of author
+     middlename1 -- first middle name of author
+     middlename2 -- second middle name of author
+     ...
+
+Middle name indexes can be any positive integer greater than 0, though
+it is unlikely that many authors will supply more than one middle
+name, if that many.")
+
+(defvar sc-use-only-preference-p nil
+  "*Controls what happens when the preferred attribution cannot be found.
+If non-nil, then sc-default-attribution will be used. If nil, then
+some secondary scheme will be employed to find a suitable attribution
+string.")
+
+(defvar sc-downcase-p nil
+  "*Non-nil means downcase the attribution and citation strings.")
+
+(defvar sc-rewrite-header-list
+  '((sc-no-header)
+    (sc-header-on-said)
+    (sc-header-inarticle-writes)
+    (sc-header-regarding-adds)
+    (sc-header-attributed-writes)
+    (sc-header-verbose)
+    (sc-no-blank-line-or-header)
+    )
+  "*List of reference header rewrite functions.
+The variable sc-preferred-header-style controls which function in this
+list is chosen for automatic reference header insertions. Electric
+reference mode will cycle through this list of functions. For more
+information, type \\[sc-describe].")
+
+(defvar sc-preferred-header-style 1
+  "*Index into sc-rewrite-header-list specifying preferred header style.
+Index zero accesses the first function in the list.")
+
+(defvar sc-electric-references-p t
+  "*Use electric references if non-nil.")
+
+(defvar sc-electric-circular-p t
+  "*Treat electric references as circular if non-nil.")
+
+(defvar sc-mail-fields-list
+  '("date"  "message-id"  "subject" "newsgroups" "references"
+    "from"  "return-path" "path"    "reply-to"   "organization"
+    "reply" )
+  "*List of mail header whose values will be saved by supercite.
+These values can be used in header rewrite functions by accessing them
+with the sc-field function. Mail headers in this list are case
+insensitive and do not require a trailing colon.")
+
+(defvar sc-mumble-string ""
+  "*Value returned by sc-field if chosen field cannot be found.")
+
+(defvar sc-nuke-mail-headers-p t
+  "*Nuke or don't nuke mail headers.
+If non-nil, nuke mail headers after gleaning useful information from
+them.")
+
+(defvar sc-reference-tag-string ">>>>> "
+  "*String used at the beginning of built-in reference headers.")
+
+(defvar sc-fill-paragraph-hook 'sc-fill-paragraph
+  "*Hook for filling a paragraph.  
+This hook gets executed when you fill a paragraph either manually or
+automagically. It expects point to be within the extent of the
+paragraph that is going to be filled. This hook allows you to use a
+different paragraph filling package than the one supplied with
+supercite.")
+
+(defvar sc-auto-fill-region-p nil
+  "*If non-nil, automatically fill each paragraph after it has been cited.")
+
+(defvar sc-auto-fill-query-each-paragraph-p nil
+  "*If non-nil, query before filling each paragraph.
+No querying and no filling will be performed if sc-auto-fill-region-p
+is set to nil.")
+
+(defvar sc-fixup-whitespace-p nil
+  "*If non-nil, delete all leading white space before citing.")
+
+(defvar sc-all-but-cite-p nil
+  "*If non-nil, sc-cite-original does everything but cite the text.
+This is useful for manually citing large messages, or portions of
+large messages. When non-nil, sc-cite-original will still set up all
+necessary variables and databases, but will skip the citing routine
+which modify the reply buffer's text.")
+
+(defvar sc-load-hook nil
+  "*User definable hook.
+Runs after supercite is loaded. Set your customizations here.")
+
+(defvar sc-pre-hook nil
+  "*User definable hook.
+Runs before sc-cite-original executes.")
+
+(defvar sc-post-hook nil
+  "*User definable hook.
+Runs after sc-cite-original executes.")
+
+(defvar sc-header-nuke-list
+  '("via" "origin" "status" "received" "remailed" "cc" "sender" "replied"
+    "organization" "keywords" "distribution" "xref" "references" "expires"
+    "approved" "summary" "precedence" "subject" "newsgroup[s]?"
+    "\\(followup\\|apparently\\|errors\\|\\(\\(in-\\)?reply\\)?-\\)?to"
+    "x-[a-z0-9-]+" "[a-z-]*message-id" "\\(summary-\\)?line[s]"
+    "\\(\\(return\\|reply\\)-\\)?path" "\\(posted-\\)?date"
+    "\\(mail-\\)?from")
+  "*List of mail headers to remove from body of reply.")
+
+
+
+;; ======================================================================
+;; keymaps
+
+(defvar sc-default-keymap
+  '(lambda ()
+     (local-set-key "\C-c\C-r" 'sc-insert-reference)
+     (local-set-key "\C-c\C-t" 'sc-cite)
+     (local-set-key "\C-c\C-a" 'sc-recite)
+     (local-set-key "\C-c\C-u" 'sc-uncite)
+     (local-set-key "\C-c\C-i" 'sc-insert-citation)
+     (local-set-key "\C-c\C-o" 'sc-open-line)
+     (local-set-key "\C-c\C-q" 'sc-fill-paragraph-manually)
+     (local-set-key "\C-cq"    'sc-fill-paragraph-manually)
+     (local-set-key "\C-c\C-m" 'sc-modify-information)
+     (local-set-key "\C-cf"    'sc-view-field)
+     (local-set-key "\C-cg"    'sc-glom-headers)
+     (local-set-key "\C-c\C-v" 'sc-version)
+     (local-set-key "\C-c?"    'sc-describe)
+     )
+  "*Default keymap if major-mode can't be found in `sc-local-keymaps'.")
+
+(defvar sc-local-keymaps
+  '((mail-mode
+     (lambda ()
+       (local-set-key "\C-c\C-r" 'sc-insert-reference)
+       (local-set-key "\C-c\C-t" 'sc-cite)
+       (local-set-key "\C-c\C-a" 'sc-recite)
+       (local-set-key "\C-c\C-u" 'sc-uncite)
+       (local-set-key "\C-c\C-i" 'sc-insert-citation)
+       (local-set-key "\C-c\C-o" 'sc-open-line)
+       (local-set-key "\C-c\C-q" 'sc-fill-paragraph-manually)
+       (local-set-key "\C-cq"    'sc-fill-paragraph-manually)
+       (local-set-key "\C-c\C-m" 'sc-modify-information)
+       (local-set-key "\C-cf"    'sc-view-field)
+       (local-set-key "\C-cg"    'sc-glom-headers)
+       (local-set-key "\C-c\C-v" 'sc-version)
+       (local-set-key "\C-c?"    'sc-describe)
+       ))
+    (mh-letter-mode
+     (lambda ()
+       (local-set-key "\C-c\C-r" 'sc-insert-reference)
+       (local-set-key "\C-c\C-t" 'sc-cite)
+       (local-set-key "\C-c\C-a" 'sc-recite)
+       (local-set-key "\C-c\C-u" 'sc-uncite)
+       (local-set-key "\C-ci"    'sc-insert-citation)
+       (local-set-key "\C-c\C-o" 'sc-open-line)
+       (local-set-key "\C-cq"    'sc-fill-paragraph-manually)
+       (local-set-key "\C-c\C-m" 'sc-modify-information)
+       (local-set-key "\C-cf"    'sc-view-field)
+       (local-set-key "\C-cg"    'sc-glom-headers)
+       (local-set-key "\C-c\C-v" 'sc-version)
+       (local-set-key "\C-c?"    'sc-describe)
+       ))
+    (news-reply-mode mail-mode)
+    (vm-mail-mode mail-mode)
+    (e-reply-mode mail-mode)
+    (n-reply-mode mail-mode)
+    )
+  "*List of keymaps to use with the associated major-mode.")
+
+(defvar sc-electric-mode-map nil
+  "*Keymap for sc-electric-mode.")
+
+(if sc-electric-mode-map
+    nil
+  (setq sc-electric-mode-map (make-sparse-keymap))
+  (define-key sc-electric-mode-map "p"     'sc-eref-prev)
+  (define-key sc-electric-mode-map "n"     'sc-eref-next)
+  (define-key sc-electric-mode-map "s"     'sc-eref-setn)
+  (define-key sc-electric-mode-map "j"     'sc-eref-jump)
+  (define-key sc-electric-mode-map "x"     'sc-eref-abort)
+  (define-key sc-electric-mode-map "\r"    'sc-eref-exit)
+  (define-key sc-electric-mode-map "\n"    'sc-eref-exit)
+  (define-key sc-electric-mode-map "q"     'sc-eref-exit)
+  (define-key sc-electric-mode-map "g"     'sc-eref-goto)
+  )
+
+;; ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+;; end of user defined variables
+;; ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+
+;; ======================================================================
+;; global variables, not user accessable
+
+(defconst sc-version-number "2.3"
+  "Supercite's version number.")
+
+;; when rnewspost.el patch is installed (or function is overloaded)
+;; this should be nil since supercite now does this itself.
+(setq news-reply-header-hook nil)
+
+;; autoload for sc-electric-mode
+(autoload 'sc-electric-mode "sc-elec"
+	  "Quasi-major mode for viewing supercite reference headers." nil)
+
+;; global alists (gals), misc variables. make new bytecompiler happy
+(defvar sc-gal-information nil
+  "Internal global alist variable containing information.")
+(defvar sc-gal-attributions nil
+  "Internal global alist variable containing attributions.")
+(defvar sc-fill-arg nil
+  "Internal fill argument holder.")
+(defvar sc-cite-context nil
+  "Internal citation context holder.")
+(defvar sc-force-confirmation-p nil
+  "Internal variable.")
+
+(make-variable-buffer-local 'sc-gal-attributions)
+(make-variable-buffer-local 'sc-gal-information)
+(make-variable-buffer-local 'sc-leached-keymap)
+(make-variable-buffer-local 'sc-fill-arg)
+(make-variable-buffer-local 'sc-cite-context)
+
+(setq-default sc-gal-attributions nil)
+(setq-default sc-gal-information  nil)
+(setq-default sc-leached-keymap (current-local-map))
+(setq-default sc-fill-arg nil)
+(setq-default sc-cite-context nil)
+
+
+
+;; ======================================================================
+;; miscellaneous support functions
+
+(defun sc-mark ()
+  "Mark compatibility between emacs v18 and v19."
+  (let ((zmacs-regions nil))
+    (mark)))
+
+(defun sc-update-gal (attribution)
+  "Update the information alist.
+Add ATTRIBUTION and compose the nested and non-nested citation
+strings."
+  (let ((attrib (if sc-downcase-p (downcase attribution) attribution)))
+    (aput 'sc-gal-information "sc-attribution" attrib)
+    (aput 'sc-gal-information "sc-nested-citation"
+	  (concat attrib sc-citation-delimiter))
+    (aput 'sc-gal-information "sc-citation"
+	  (concat sc-citation-leader
+		  attrib
+		  sc-citation-delimiter
+		  sc-citation-separator))))
+
+(defun sc-valid-index-p (index)
+  "Returns t if INDEX is a valid index into sc-rewrite-header-list."
+  (let ((last (1- (length sc-rewrite-header-list))))
+    (and (natnump index)  ;; a number, and greater than or equal to zero
+	 (<= index last)  ;; less than or equal to the last index
+	 )))
+
+(defun sc-string-car (namestring)
+  "Return the string-equivalent \"car\" of NAMESTRING.
+
+     example: (sc-string-car \"John Xavier Doe\")
+              => \"John\""
+  (substring namestring
+	     (progn (string-match "\\s *" namestring) (match-end 0))
+	     (progn (string-match "\\s *\\S +" namestring) (match-end 0))))
+
+(defun sc-string-cdr (namestring)
+  "Return the string-equivalent \"cdr\" of NAMESTRING.
+
+     example: (sc-string-cdr \"John Xavier Doe\")
+              => \"Xavier Doe\""
+  (substring namestring
+	     (progn (string-match "\\s *\\S +\\s *" namestring)
+		    (match-end 0))))
+
+(defun sc-linepos (&optional position col-p)
+  "Return the character position at various line positions.
+Optional POSITION can be one of the following symbols:
+     bol == beginning of line
+     boi == beginning of indentation
+     eol == end of line [default]
+
+Optional COL-P non-nil returns current-column instead of character position."
+  (let ((tpnt (point))
+	rval)
+    (cond
+     ((eq position 'bol) (beginning-of-line))
+     ((eq position 'boi) (back-to-indentation))
+     (t (end-of-line)))
+    (setq rval (if col-p (current-column) (point)))
+    (goto-char tpnt)
+    rval))
+
+
+;; ======================================================================
+;; this section snarfs mail fields and places them in the info alist
+
+(defun sc-build-header-zap-regexp ()
+  "Return a regexp for sc-mail-yank-clear-headers."
+  (let ((headers sc-header-nuke-list)
+	(regexp nil))
+    (while headers
+      (setq regexp (concat regexp
+			   "^" (car headers) ":"
+			   (if (cdr headers) "\\|" nil)))
+      (setq headers (cdr headers)))
+    regexp))
+
+(defun sc-mail-yank-clear-headers (start end)
+  "Nuke mail headers between START and END."
+  (if (and sc-nuke-mail-headers-p sc-header-nuke-list)
+      (let ((regexp (sc-build-header-zap-regexp)))
+	(save-excursion
+	  (goto-char start)
+	  (if (search-forward "\n\n" end t)
+	      (save-restriction
+		(narrow-to-region start (point))
+		(goto-char start)
+		(while (let ((case-fold-search t))
+			 (re-search-forward regexp nil t))
+		  (beginning-of-line)
+		  (delete-region (point)
+				 (progn (re-search-forward "\n[^ \t]")
+					(forward-char -1)
+					(point)))
+		  )))
+	  ))))
+
+(defun sc-mail-fetch-field (field)
+  "Return the value of the header field FIELD.
+The buffer is expected to be narrowed to just the headers of the
+message."
+  (save-excursion
+    (goto-char (point-min))
+    (let ((case-fold-search t)
+	  (name (concat "^" (regexp-quote field) "[ \t]*:[ \t]*")))
+      (goto-char (point-min))
+      (if (re-search-forward name nil t)
+	  (let ((opoint (point)))
+	    (while (progn (forward-line 1)
+			  (looking-at "[ \t]")))
+	    (buffer-substring opoint (1- (point))))))))
+
+(defun sc-fetch-fields (start end)
+  "Fetch the mail fields in the region from START to END.
+These fields can be accessed in header rewrite functions with sc-field."
+  (save-excursion
+    (save-restriction
+      (narrow-to-region start end)
+      (goto-char start)
+      (let ((fields sc-mail-fields-list))
+	(while fields
+	  (let ((value (sc-mail-fetch-field (car fields)))
+		(next (cdr fields)))
+	    (and value
+		 (aput 'sc-gal-information (car fields) value))
+	    (setq fields next)))
+	(if (sc-mail-fetch-field "from")
+	    (aput 'sc-gal-information "from" (sc-mail-fetch-field "from")))))))
+
+(defun sc-field (field)
+  "Return the alist information associated with the FIELD.
+If FIELD is not a valid key, return sc-mumble-string."
+  (or (aget sc-gal-information field) sc-mumble-string))
+
+
+;; ======================================================================
+;; built-in reference header rewrite functions
+
+(defun sc-no-header ()
+  "Does nothing. Use this instead of nil to get a blank header."
+  ())
+
+(defun sc-no-blank-line-or-header()
+  "Similar to sc-no-header except it removes the preceeding blank line."
+  (if (not (bobp))
+      (if (and (eolp)
+	       (progn (forward-line -1)
+		      (or (looking-at mail-header-separator)
+			  (and (eq major-mode 'mh-letter-mode)
+			       (mh-in-header-p)))))
+	  (progn (forward-line)
+		 (let ((kill-lines-magic t)) (kill-line))))))
+
+(defun sc-header-on-said ()
+  "\"On <date>, <from> said:\", unless 1. the \"from\" field cannot be
+found, in which case nothing is inserted; or 2. the \"date\" field is
+missing in which case only the from part is printed."
+  (let* ((sc-mumble-string "")
+	 (whofrom (sc-field "from"))
+	 (when (sc-field "date")))
+    (if (not (string= whofrom ""))
+	(insert sc-reference-tag-string
+		(if (not (string= when ""))
+		    (concat "On " when ", ") "")
+		whofrom " said:\n"))))
+
+(defun sc-header-inarticle-writes ()
+  "\"In article <message-id>, <from> writes:\"
+Treats \"message-id\" and \"from\" fields similar to sc-header-on-said."
+  (let* ((sc-mumble-string "")
+	 (whofrom (sc-field "from"))
+	 (msgid (sc-field "message-id")))
+    (if (not (string= whofrom ""))
+	(insert sc-reference-tag-string
+		(if (not (string= msgid ""))
+		    (concat "In article " msgid ", ") "")
+		whofrom " writes:\n"))))
+
+(defun sc-header-regarding-adds ()
+  "\"Regarding <subject>; <from> adds:\"
+Treats \"subject\" and \"from\" fields similar to sc-header-on-said."
+  (let* ((sc-mumble-string "")
+	 (whofrom (sc-field "from"))
+	 (subj (sc-field "subject")))
+    (if (not (string= whofrom ""))
+	(insert sc-reference-tag-string
+		(if (not (string= subj ""))
+		    (concat "Regarding " subj "; ") "")
+		whofrom " adds:\n"))))
+
+(defun sc-header-attributed-writes ()
+  "\"<sc-attribution>\" == <sc-author> <address> writes:
+Treats these fields in a similar manner to sc-header-on-said."
+  (let* ((sc-mumble-string "")
+	 (whofrom (sc-field "from"))
+	 (reply (sc-field "sc-reply-address"))
+	 (from (sc-field "sc-from-address"))
+	 (attr (sc-field "sc-attribution"))
+	 (auth (sc-field "sc-author")))
+    (if (not (string= whofrom ""))
+	(insert sc-reference-tag-string
+		(if (not (string= attr ""))
+		    (concat "\"" attr "\" == " ) "")
+		(if (not (string= auth ""))
+		    (concat auth " ") "")
+		(if (not (string= reply ""))
+		    (concat "<" reply ">")
+		  (if (not (string= from ""))
+		      (concat "<" from ">") ""))
+		" writes:\n"))))
+
+(defun sc-header-verbose ()
+  "Very verbose, some say gross."
+  (let* ((sc-mumble-string "")
+	 (whofrom (sc-field "from"))
+	 (reply (sc-field "sc-reply-address"))
+	 (from (sc-field "sc-from-address"))
+	 (author (sc-field "sc-author"))
+	 (date (sc-field "date"))
+	 (org (sc-field "organization"))
+	 (msgid (sc-field "message-id"))
+	 (ngrps (sc-field "newsgroups"))
+	 (subj (sc-field "subject"))
+	 (refs (sc-field "references"))
+	 (cite (sc-field "sc-citation"))
+	 (nl sc-reference-tag-string))
+    (if (not (string= whofrom ""))
+	(insert (if (not (string= date ""))
+		    (concat nl "On " date ",\n") "")
+		(concat nl (if (not (string= author ""))
+			       author
+			     whofrom) "\n")
+		(if (not (string= org ""))
+		    (concat nl "from the organization of " org "\n") "")
+		(if (not (string= reply ""))
+		    (concat nl "who can be reached at: " reply "\n")
+		  (if (not (string= from ""))
+		      (concat nl "who can be reached at: " from "\n") ""))
+		(if (not (string= cite ""))
+		    (concat nl "(whose comments are cited below with \""
+			    cite "\"),\n") "")
+		(if (not (string= msgid ""))
+		    (concat nl "had this to say in article " msgid "\n") "")
+		(if (not (string= ngrps ""))
+		    (concat nl "in newsgroups " ngrps "\n") "")
+		(if (not (string= subj ""))
+		    (concat nl "concerning the subject of " subj "\n") "")
+		(if (not (string= refs ""))
+		    (concat nl "(see " refs " for more details)\n") "")
+		))))
+
+
+;; ======================================================================
+;; this section queries the user for necessary information
+
+(defun sc-query (&optional default)
+  "Query for an attribution string with the optional DEFAULT choice.
+Returns the string entered by the user, if non-empty and non-nil, or
+DEFAULT otherwise. If DEFAULT is not supplied, sc-default-attribution
+is used."
+  (if (not default) (setq default sc-default-attribution))
+  (let* ((prompt (concat "Enter attribution string: (default " default ") "))
+	 (query (read-string prompt)))
+    (if (or (null query)
+	    (string= query ""))
+	default
+      query)))
+
+(defun sc-confirm ()
+  "Confirm the preferred attribution with the user."
+  (if (or sc-confirm-always-p
+	  sc-force-confirmation-p)
+      (aput 'sc-gal-attributions
+	    (let* ((default (aheadsym sc-gal-attributions))
+		   chosen
+		   (prompt (concat "Complete "
+				   (cond
+				    ((eq sc-cite-context 'citing) "cite")
+				    ((eq sc-cite-context 'reciting) "recite")
+				    (t ""))
+				   " attribution string: (default "
+				   default ") "))
+		   (minibuffer-local-completion-map
+		    (copy-keymap minibuffer-local-completion-map)))
+	      (define-key minibuffer-local-completion-map "\C-g"
+		'(lambda () (interactive) (beep) (throw 'select-abort nil)))
+	      (setq chosen (completing-read prompt sc-gal-attributions))
+	      (if (or (not chosen)
+		      (string= chosen ""))
+		  default
+		chosen)))))
+
+
+;; ======================================================================
+;; this section contains primitive functions used in the email address
+;; parsing schemes.  they extract name fields from various parts of
+;; the "from:" field.
+
+(defun sc-style1-addresses (from-string &optional delim)
+  "Extract the author's email terminus from email address FROM-STRING.
+Match addresses of the style \"name%[stuff].\" when called with DELIM
+of \"%\" and addresses of the style \"[stuff]name@[stuff]\" when
+called with DELIM \"@\". If DELIM is nil or not provided, matches
+addresses of the style \"name\"."
+  (and (string-match (concat "[a-zA-Z0-9_-]+" delim) from-string 0)
+       (substring from-string
+		  (match-beginning 0)
+		  (- (match-end 0) (if (null delim) 0 1)))))
+
+(defun sc-style2-addresses (from-string)
+  "Extract the author's email terminus from email address FROM-STRING.
+Match addresses of the style \"[stuff]![stuff]...!name[stuff].\""
+  (let ((eos (length from-string))
+	(mstart (string-match "![a-zA-Z0-9_-]+\\([^!a-zA-Z0-9_-]\\|$\\)"
+			      from-string 0))
+	(mend (match-end 0)))
+    (and mstart
+	 (substring from-string (1+ mstart) (- mend (if (= mend eos) 0 1)))
+	 )))
+
+(defun sc-get-address (from-string author)
+  "Get the full email address path from FROM-STRING.
+AUTHOR is the author's name (which is removed from the address)."
+  (let ((eos (length from-string)))
+    (if (string-match (concat "\\(^\\|^\"\\)" author
+			      "\\(\\s +\\|\"\\s +\\)") from-string 0)
+	(let ((addr (substring from-string (match-end 0) eos)))
+	  (if (and (= (aref addr 0) ?<)
+		   (= (aref addr (1- (length addr))) ?>))
+	      (substring addr 1 (1- (length addr)))
+	    addr))
+      (if (string-match "[a-zA-Z0-9!@%._-]+" from-string 0)
+	  (substring from-string (match-beginning 0) (match-end 0))
+	"")
+      )))
+
+(defun sc-get-emailname (from-string)
+  "Get the email terminus name from FROM-STRING."
+  (cond
+   ((sc-style1-addresses from-string "%"))
+   ((sc-style1-addresses from-string "@"))
+   ((sc-style2-addresses from-string))
+   ((sc-style1-addresses from-string nil))
+   (t (substring from-string 0 10))))
+
+
+;; ======================================================================
+;; this section contains functions that will extract a list of names
+;; from the name field string.
+
+(defun sc-spacify-name-chars (name)
+  (let ((len (length name))
+	(s 0))
+    (while (< s len)
+      (if (memq (aref name s) sc-spacify-name-chars)
+	  (aset name s 32))
+      (setq s (1+ s)))
+    name))
+
+(defun sc-name-substring (string start end extend)
+  "Extract the specified substring of STRING from START to END.
+EXTEND is the number of characters on each side to extend the
+substring."
+  (and start
+       (let ((sos (+ start extend))
+	     (eos (- end extend)))
+	 (substring string sos
+		    (or (string-match sc-titlecue-regexp string sos) eos)
+		    ))))
+
+(defun sc-extract-namestring (from-string)
+  "Extract the name string from FROM-STRING.
+This should be the author's full name minus an optional title."
+  (let ((pstart (string-match "(.*)" from-string 0))
+	(pend (match-end 0))
+	(qstart (string-match "\".*\"" from-string 0))
+	(qend (match-end 0))
+	(bstart (string-match "\\([.a-zA-Z0-9_-]+\\s *\\)+" from-string 0))
+	(bend (match-end 0)))
+    (sc-spacify-name-chars
+     (cond
+      ((sc-name-substring from-string pstart pend 1))
+      ((sc-name-substring from-string qstart qend 1))
+      ((sc-name-substring from-string bstart bend 0))
+      ))))
+
+(defun sc-chop-namestring (namestring)
+  "Convert NAMESTRING to a list of names.
+
+     example: (sc-namestring-to-list \"John Xavier Doe\")
+              => (\"John\" \"Xavier\" \"Doe\")"
+  (if (not (string= namestring ""))
+      (append (list (sc-string-car namestring))
+	      (sc-chop-namestring (sc-string-cdr namestring)))))
+
+(defun sc-strip-initials (namelist)
+  "Extract the author's initials from the NAMELIST."
+  (if (not namelist)
+      nil
+    (concat (if (string= (car namelist) "")
+		""
+	      (substring (car namelist) 0 1))
+	    (sc-strip-initials (cdr namelist)))))
+
+
+;; ======================================================================
+;; this section handles selection of the attribution and citation strings
+
+(defun sc-populate-alists (from-string)
+  "Put important and useful information in the alists using FROM-STRING.
+Return the list of name symbols."
+  (let* ((namelist (sc-chop-namestring (sc-extract-namestring from-string)))
+	 (revnames (reverse (cdr namelist)))
+	 (midnames (reverse (cdr revnames)))
+	 (firstname (car namelist))
+	 (midnames (reverse (cdr revnames)))
+	 (lastname (car revnames))
+	 (initials (sc-strip-initials namelist))
+	 (emailname (sc-get-emailname from-string))
+	 (n 1)
+	 (symlist (list 'emailname 'initials 'firstname 'lastname)))
+    
+    ;; put basic information
+    (aput 'sc-gal-attributions 'firstname firstname)
+    (aput 'sc-gal-attributions 'lastname lastname)
+    (aput 'sc-gal-attributions 'emailname emailname)
+    (aput 'sc-gal-attributions 'initials initials)
+    
+    (aput 'sc-gal-information "sc-firstname" firstname)
+    (aput 'sc-gal-information "sc-lastname" lastname)
+    (aput 'sc-gal-information "sc-emailname" emailname)
+    (aput 'sc-gal-information "sc-initials" initials)
+    
+    ;; put middle names and build sc-author entry
+    (let ((author (concat firstname " ")))
+      (while midnames
+	(let ((name (car midnames))
+	      (next (cdr midnames))
+	      (symbol (intern (format "middlename%d" n)))
+	      (string (format "sc-middlename-%d" n)))
+	  ;; first put new middlename
+	  (aput 'sc-gal-attributions symbol name)
+	  (aput 'sc-gal-information string name)
+	  (setq n (1+ n))
+	  (nconc symlist (list symbol))
+
+	  ;; now build author name
+	  (setq author (concat author name " "))
+
+	  ;; incr loop
+	  (setq midnames next)
+	  ))
+      (setq author (concat author lastname))
+
+      ;; put author name and email address
+      (aput 'sc-gal-information "sc-author" author)
+      (aput 'sc-gal-information "sc-from-address"
+	    (sc-get-address from-string author))
+      (aput 'sc-gal-information "sc-reply-address"
+	    (sc-get-address (sc-field "reply-to") author))
+      )
+    ;; return value
+    symlist))
+
+(defun sc-sort-attribution-alist ()
+  "Put preferred attribution at head of attributions alist."
+  (asort 'sc-gal-attributions sc-preferred-attribution)
+  
+  ;; use backup scheme if preference is not legal
+  (if (or (null sc-preferred-attribution)
+	  (anot-head-p sc-gal-attributions sc-preferred-attribution)
+	  (let ((prefval (aget sc-gal-attributions
+			       sc-preferred-attribution)))
+	    (or (null prefval)
+		(string= prefval ""))))
+      ;; no legal attribution
+      (if sc-use-only-preference-p
+	  (aput 'sc-gal-attributions 'sc-user-query
+		(sc-query sc-default-attribution))
+	;; else use secondary scheme
+	(asort 'sc-gal-attributions 'firstname))))
+
+(defun sc-build-attribution-alist (from-string)
+  "Extract attributions from FROM-STRING, applying preferences."
+  (let ((symlist (sc-populate-alists from-string))
+	(headval (progn (sc-sort-attribution-alist)
+			(aget sc-gal-attributions
+			      (aheadsym sc-gal-attributions) t))))
+    
+    ;; for each element in the symlist, remove the corresponding 
+    ;; key-value pair in the alist, then insert just the value.
+    (while symlist
+      (let ((value (aget sc-gal-attributions (car symlist) t))
+	    (next (cdr symlist)))
+	(if (not (or (null value)
+		     (string= value "")))
+	    (aput 'sc-gal-attributions value))
+	(adelete 'sc-gal-attributions (car symlist))
+	(setq symlist next)))
+
+    ;; add nicknames to the completion list
+    (let ((gal sc-gal-attributions))
+      (while gal
+	(let ((nns sc-nicknames-alist)
+	      (galname (car (car gal))))
+	  (while nns
+	    (if (string= galname (car (car nns)))
+		(aput 'sc-gal-attributions (car (cdr (car nns)))))
+	    (setq nns (cdr nns)))
+	  (setq gal (cdr gal)))))
+
+    ;; now reinsert the head (preferred) attribution unless it is nil,
+    ;; this effectively just moves the head value to the front of the
+    ;; list.
+    (if headval
+	(aput 'sc-gal-attributions headval))
+    
+    ;; check to be sure alist is not nil
+    (if (null sc-gal-attributions)
+	(aput 'sc-gal-attributions sc-default-attribution))))
+
+(defun sc-select ()
+  "Select an attribution and create a citation string."
+  (cond
+   (sc-nested-citation-p
+    (sc-update-gal ""))
+   ((null (aget sc-gal-information "from" t))
+    (aput 'sc-gal-information "sc-author" sc-default-author-name)
+    (sc-update-gal (sc-query sc-default-attribution)))
+   ((null sc-gal-attributions)
+    (sc-build-attribution-alist (aget sc-gal-information "from" t))
+    (sc-confirm)
+    (sc-update-gal (aheadsym sc-gal-attributions)))
+   (t
+    (sc-confirm)
+    (sc-update-gal (aheadsym sc-gal-attributions))))
+  t)
+
+
+;; ======================================================================
+;; region citing and unciting
+
+(defun sc-cite-region (start end)
+  "Cite a region delineated by START and END."
+  (save-excursion
+    ;; set real end-of-region
+    (goto-char end)
+    (forward-line 1)
+    (set-mark (point))
+    ;; goto real beginning-of-region
+    (goto-char start)
+    (beginning-of-line)
+    (let ((fstart (point))
+	  (fend   (point)))
+      (while (< (point) (sc-mark))
+	;; remove leading whitespace if desired 
+	(and sc-fixup-whitespace-p
+	     (fixup-whitespace))
+	;; if end of line then perhaps autofill
+	(cond ((eolp)
+	       (or (= fstart fend)
+		   (not sc-auto-fill-region-p)
+		   (and sc-auto-fill-query-each-paragraph-p
+			(not (y-or-n-p "Fill this paragraph? ")))
+		   (save-excursion (set-mark fend)
+				   (goto-char (/ (+ fstart fend 1) 2))
+				   (run-hooks 'sc-fill-paragraph-hook)))
+	       (setq fstart (point)
+		     fend (point)))
+	      ;; not end of line so perhap cite it
+	      ((not (looking-at sc-cite-regexp))
+	       (insert (aget sc-gal-information "sc-citation")))
+	      (sc-nested-citation-p
+	       (insert (aget sc-gal-information "sc-nested-citation"))))
+	(setq fend (point))
+	(forward-line 1))
+      (and sc-auto-fill-query-each-paragraph-p
+	   (message " "))
+      )))
+
+(defun sc-uncite-region (start end cite-regexp)
+  "Uncite a previously cited region delineated by START and END.
+CITE-REGEXP describes how a cited line of texts starts.  Unciting also
+auto-fills paragraph if sc-auto-fill-region-p is non-nil."
+  (save-excursion
+    (set-mark end)
+    (goto-char start)
+    (beginning-of-line)
+    (let ((fstart (point))
+	  (fend (point)))
+      (while (< (point) (sc-mark))
+	;; if end of line, then perhaps autofill
+	(cond ((eolp)
+	       (or (= fstart fend)
+		   (not sc-auto-fill-region-p)
+		   (and sc-auto-fill-query-each-paragraph-p
+			(not (y-or-n-p "Fill this paragraph? ")))
+		   (save-excursion (set-mark fend)
+				   (goto-char (/ (+ fstart fend 1) 2))
+				   (run-hooks 'sc-fill-paragraph-hook)))
+	       (setq fstart (point)
+		     fend (point)))
+	      ;; not end of line so perhaps uncite it
+	      ((looking-at cite-regexp)
+	       (save-excursion
+		 (save-restriction
+		   (narrow-to-region (sc-linepos 'bol) (sc-linepos))
+		   (beginning-of-line)
+		   (delete-region (point-min)
+				  (progn (re-search-forward cite-regexp
+							    (point-max)
+							    t)
+					 (match-end 0)))))))
+	(setq fend (point))
+	(forward-line 1)))))
+
+
+;; ======================================================================
+;; this section contains paragraph filling support
+
+(defun sc-guess-fill-prefix (&optional literalp)
+  "Guess the fill prefix used on the current line.
+Use various heuristics to find the fill prefix. Search begins on first
+non-blank line after point.
+
+     1) If fill-prefix is already bound to the empty string, return
+        nil.
+
+     2) If fill-prefix is already bound, but not to the empty
+        string, return the value of fill-prefix.
+
+     3) If the current line starts with the last chosen citation
+        string, then that string is returned.
+
+     4) If the current line starts with a string matching the regular
+        expression sc-cite-regexp, return the match.  Note that if
+        optional LITERALP is provided and non-nil, then the *string*
+        that matches the regexp is return.  Otherwise, if LITERALP is
+        not provided or is nil, the *regexp* sc-cite-regexp is
+        returned.
+
+     5) If the current line starts with any number of characters,
+        followed by the sc-citation-delimiter and then white space,
+        that match is returned. See comment #4 above for handling of
+        LITERALP. 
+
+     6) Nil is returned."
+  (save-excursion
+    ;; scan for first non-blank line in the region
+    (beginning-of-line)
+    (skip-chars-forward "\n\t ")
+    (beginning-of-line)
+    (let ((citation (aget sc-gal-information "sc-citation"))
+	  (generic-citation
+	   (concat "\\s *[^ \t\n" sc-citation-delimiter "]+>\\s +")))
+      (cond
+       ((string= fill-prefix "") nil)                   ;; heuristic #1
+       (fill-prefix)                                    ;; heuristic #2
+       ((looking-at (regexp-quote citation)) citation)  ;; heuristic #3
+       ((looking-at sc-cite-regexp)                     ;; heuristic #4
+	(if literalp
+	    (buffer-substring
+	     (point)
+	     (progn (re-search-forward (concat sc-cite-regexp "\\s *")
+				       (point-max) nil)
+		    (point)))
+	  sc-cite-regexp))
+       ((looking-at generic-citation)                   ;; heuristic #5
+	(if literalp
+	    (buffer-substring
+	     (point)
+	     (progn (re-search-forward generic-citation) (point)))
+	  generic-citation))
+       (t nil)))))                                      ;; heuristic #6
+
+(defun sc-consistant-cite-p (prefix)
+  "Check current paragraph for consistant citation.
+Scans to paragraph delineated by (forward|backward)-paragraph to see
+if all lines start with PREFIX. Returns t if entire paragraph is
+consistantly cited, nil otherwise."
+  (save-excursion
+    (let ((end   (progn (forward-paragraph)
+			(beginning-of-line)
+			(or (not (eolp))
+			    (forward-char -1))
+			(point)))
+	  (start (progn (backward-paragraph)
+			(beginning-of-line)
+			(or (not (eolp))
+			    (forward-char 1))
+			(point)))
+	  (badline t))
+      (goto-char start)
+      (beginning-of-line)
+      (while (and (< (point) end)
+		  badline)
+	(setq badline (looking-at prefix))
+	(forward-line 1))
+      badline)))
+
+(defun sc-fill-start (fill-prefix)
+  "Find buffer position of start of region which begins with FILL-PREFIX.
+Restrict scan to current paragraph."
+  (save-excursion
+    (let ((badline nil)
+	  (top (save-excursion
+		 (backward-paragraph)
+		 (beginning-of-line)
+		 (or (not (eolp))
+		     (forward-char 1))
+		 (point))))
+      (while (and (not badline)
+		  (> (point) top))
+	(forward-line -1)
+	(setq badline (not (looking-at fill-prefix)))))
+    (forward-line 1)
+    (point)))
+
+(defun sc-fill-end (fill-prefix)
+  "Find the buffer position of end of region which begins with FILL-PREFIX.
+Restrict scan to current paragraph."
+  (save-excursion
+    (let ((badline nil)
+	  (bot (save-excursion
+		 (forward-paragraph)
+		 (beginning-of-line)
+		 (or (not (eolp))
+		     (forward-char -1))
+		 (point))))
+      (while (and (not badline)
+		  (< (point) bot))
+	(beginning-of-line)
+	(setq badline (not (looking-at fill-prefix)))
+	(forward-line 1)))
+    (forward-line -1)
+    (point)))
+
+(defun sc-fill-paragraph ()
+  "Supercite's paragraph fill function.
+Fill the paragraph containing or following point. Use
+sc-guess-fill-prefix to find the fill-prefix for the paragraph.
+
+If the paragraph is inconsistantly cited (mixed fill-prefix), then the
+user is queried to restrict the the fill to only those lines around
+point which begin with the fill prefix.
+
+The variable sc-fill-arg is passed to fill-paragraph and
+fill-region-as-paragraph which controls justification of the
+paragraph.  sc-fill-arg is set by sc-fill-paragraph-manually."
+  (save-excursion
+    (let ((pnt (point))
+	  (fill-prefix (sc-guess-fill-prefix t)))
+      (cond
+       ((not fill-prefix)
+	(fill-paragraph sc-fill-arg))
+       ((sc-consistant-cite-p fill-prefix)
+	(fill-paragraph sc-fill-arg))
+       ((y-or-n-p "Inconsistent citation found. Restrict? ")
+	(message "")
+	(fill-region-as-paragraph (progn (goto-char pnt)
+					 (sc-fill-start fill-prefix))
+				  (progn (goto-char pnt)
+					 (sc-fill-end fill-prefix))
+				  sc-fill-arg))
+       (t
+	(message "")
+	(progn
+	  (setq fill-prefix (aget sc-gal-information "sc-citation"))
+	  (fill-paragraph sc-fill-arg)))))))
+
+
+;; ======================================================================
+;; the following functions are the top level, interactive commands that
+;; can be bound to key strokes
+
+(defun sc-insert-reference (arg)
+  "Insert, at point, a reference header in the body of the reply.
+Numeric ARG indicates which header style from sc-rewrite-header-list
+to use when rewriting the header. No supplied ARG indicates use of
+sc-preferred-header-style.
+
+With just \\[universal-argument], electric reference insert mode is
+entered, regardless of the value of sc-electric-references-p.  See
+sc-electric-mode for more information."
+  (interactive "P")
+  (if (consp arg)
+      (sc-electric-mode)
+    (let ((pref (cond ((sc-valid-index-p arg) arg)
+		      ((sc-valid-index-p sc-preferred-header-style)
+		       sc-preferred-header-style)
+		      (t 0))))
+      (if sc-electric-references-p (sc-electric-mode pref)
+	(condition-case err
+	    (eval (nth pref sc-rewrite-header-list))
+	  (void-function
+	   (progn (message
+		   "Symbol's function definition is void: %s. (Header %d)."
+		   (symbol-name (car (cdr err)))
+		   pref)
+		  (beep)))
+	  (error
+	   (progn (message "Error evaluating rewrite header function %d."
+			   pref)
+		  (beep)))
+	  )))))
+
+(defun sc-cite (arg)
+  "Cite the region of text between point and mark.
+Numeric ARG, if supplied, is passed unaltered to sc-insert-reference."
+  (interactive "P")
+  (if (not (sc-mark))
+      (error "Please designate a region to cite (i.e. set the mark)."))
+  (catch 'select-abort
+    (let ((sc-cite-context 'citing)
+	  (sc-force-confirmation-p (interactive-p)))
+      (sc-select)
+      (undo-boundary)
+      (let ((xchange (if (> (sc-mark) (point)) nil
+		       (exchange-point-and-mark)
+		       t)))
+	(sc-insert-reference arg)
+	(sc-cite-region (point) (sc-mark))
+	;; leave point on first cited line
+	(while (and (< (point) (sc-mark))
+		    (not (looking-at (aget sc-gal-information
+					   (if sc-nested-citation-p
+					       "sc-nested-citation"
+					     "sc-citation")))))
+	  (forward-line 1))
+	(and xchange
+	     (exchange-point-and-mark))
+	))))
+
+(defun sc-uncite ()
+  "Uncite the region between point and mark."
+  (interactive)
+  (if (not (sc-mark))
+      (error "Please designate a region to uncite (i.e. set the mark)."))
+  (undo-boundary)
+  (let ((xchange (if (> (sc-mark) (point)) nil
+		   (exchange-point-and-mark)
+		   t))
+	(fp (or (sc-guess-fill-prefix)
+		"")))
+    (sc-uncite-region (point) (sc-mark) fp)
+    (and xchange
+	 (exchange-point-and-mark))))
+
+(defun sc-recite ()
+  "Recite the region by first unciting then citing the text."
+  (interactive)
+  (if (not (sc-mark))
+      (error "Please designate a region to recite (i.e. set the mark)."))
+  (catch 'select-abort
+    (let ((sc-cite-context 'reciting)
+	  (sc-force-confirmation-p t))
+      (sc-select)
+      (undo-boundary)
+      (let ((xchange (if (> (sc-mark) (point)) nil
+		       (exchange-point-and-mark)
+		       t))
+	    (fp (or (sc-guess-fill-prefix)
+		    "")))
+	(sc-uncite-region (point) (sc-mark) fp)
+	(sc-cite-region (point) (sc-mark))
+	(and xchange
+	     (exchange-point-and-mark))
+	))))
+
+(defun sc-insert-citation ()
+  "Insert citation string at beginning of current line."
+  (interactive)
+  (save-excursion
+    (beginning-of-line)
+    (insert (aget sc-gal-information "sc-citation"))))
+
+(defun sc-open-line (arg)
+  "Insert a newline and leave point before it.
+Also inserts the guessed prefix at the beginning of the new line. With
+numeric ARG, inserts that many new lines."
+  (interactive "p")
+  (save-excursion
+    (let ((start (point))
+	  (string (or (sc-guess-fill-prefix t)
+		      "")))
+      (open-line arg)
+      (goto-char start)
+      (forward-line 1)
+      (while (< 0 arg)
+	(insert string)
+	(forward-line 1)
+	(setq arg (- arg 1))))))
+
+(defun sc-fill-paragraph-manually (arg)
+  "Fill current cited paragraph.
+Really just runs the hook sc-fill-paragraph-hook, however it does set
+the global variable sc-fill-arg to the value of ARG.  This is
+currently the only way to pass an argument to a hookified function."
+  (interactive "P")
+  (setq sc-fill-arg arg)
+  (run-hooks 'sc-fill-paragraph-hook))
+
+(defun sc-modify-information (arg)
+  "Interactively modify information in the information alist.
+\\[universal-argument] if supplied, deletes the entry from the alist.
+You can add an entry by supplying a key instead of completing."
+  (interactive "P")
+  (let* ((delete-p   (consp arg))
+	 (action     (if delete-p "delete" "modify"))
+	 (defaultkey (aheadsym sc-gal-information))
+	 (prompt     (concat "Select information key to "
+			     action ": (default "
+			     defaultkey ") "))
+	 (key (completing-read prompt sc-gal-information))
+	 )
+    (if (or (string= key "")
+	    (null key))
+	(setq key defaultkey))
+    (if delete-p (adelete 'sc-gal-information key)
+      (let* ((oldval (aget sc-gal-information key t))
+	     (prompt (concat "Enter new value for key \""
+			     key "\" (default \"" oldval "\") "))
+	     (newval (read-input prompt)))
+	(if (or (string= newval "")
+		(null newval))
+	    nil
+	  (aput 'sc-gal-information key newval)
+	  )))))
+
+(defun sc-view-field (arg)
+  "View field values in the information alist.
+This is essentially an interactive version of sc-field, and is similar
+to sc-modify-information, except that the field values can't be
+modified. With \\[universal-argument], if supplied, inserts the value
+into the current buffer as well."
+  (interactive "P")
+  (let* ((defaultkey (aheadsym sc-gal-information))
+	 (prompt     (concat "View information key: (default "
+			     defaultkey ") "))
+	 (key (completing-read prompt sc-gal-information)))
+    (if (or (string= key "")
+	    (null key))
+	(setq key defaultkey))
+    (let* ((val (aget sc-gal-information key t))
+	   (pval (if val (concat "\"" val "\"") "nil")))
+      (message "value of key %s: %s" key pval)
+      (if (and key (consp arg)) (insert val)))))
+
+(defun sc-glom-headers ()
+  "Glom information from mail headers in region between point and mark.
+Any old information is lost, unless an error occurs."
+  (interactive)
+  (let ((attr (copy-sequence sc-gal-attributions))
+	(info (copy-sequence sc-gal-information)))
+    (setq sc-gal-attributions nil
+	  sc-gal-information nil)
+    (let ((start (region-beginning))
+	  (end   (region-end))
+	  (sc-force-confirmation-p t)
+	  (sc-cite-context nil))
+      (sc-fetch-fields start end)
+      (if (null sc-gal-information)
+	  (progn
+	    (message "No mail headers found! Restoring old information.")
+	    (setq sc-gal-attributions attr
+		  sc-gal-information info))
+	(sc-mail-yank-clear-headers start end)
+	(if (not (catch 'select-abort
+		   (condition-case foo
+		       (sc-select)
+		     (quit (beep) (throw 'select-abort nil)))
+		   ))
+	    (setq sc-gal-attributions attr
+		  sc-gal-information info))
+	))))
+
+(defun sc-version (arg)
+  "Show supercite version.
+Universal argument (\\[universal-argument]) ARG inserts version
+information in the current buffer instead of printing the message in
+the echo area."
+  (interactive "P")
+  (if (consp arg)
+      (insert "Using Supercite version " sc-version-number)
+    (message "Using Supercite version %s" sc-version-number)))
+
+
+;; ======================================================================
+;; leach onto current mode
+
+(defun sc-append-current-keymap ()
+  "Append some useful key bindings to the current local key map.
+This searches sc-local-keymap for the keymap to install based on the
+major-mode of the current buffer."
+  (let ((hook (car (cdr (assq major-mode sc-local-keymaps)))))
+    (cond
+     ((not hook)
+      (run-hooks 'sc-default-keymap))
+     ((not (listp hook))
+      (setq hook (car (cdr (assq hook sc-local-keymaps))))
+      (run-hooks 'hook))
+     (t
+      (run-hooks 'hook))))
+  (setq sc-leached-keymap (current-local-map)))
+
+(defun sc-snag-all-keybindings ()
+  "Snag all keybindings in major-mode's current keymap."
+  (let* ((curkeymap (current-local-map))
+	 (symregexp ".*sc-.*\n")
+	 (docstring (substitute-command-keys "\\{curkeymap}"))
+	 (start 0)
+	 (maxend (length docstring))
+	 (spooge ""))
+    (while (and (< start maxend)
+		(string-match symregexp docstring start))
+      (setq spooge (concat spooge (substring docstring
+					     (match-beginning 0)
+					     (match-end 0))))
+      (setq start (match-end 0)))
+    spooge))
+
+(defun sc-spoogify-docstring ()
+  "Modifies (makes into spooge) the docstring for the current major mode.
+This will leach the keybinding descriptions for supercite onto the end
+of the current major mode's docstring.  If major mode is preloaded,
+this function will first make a copy of the list associated with the
+mode, then modify this copy."
+  (let* ((symfunc (symbol-function major-mode))
+         (doc-cdr (and (listp symfunc) (nthcdr 2 symfunc)))
+	 (doc-str (documentation major-mode)))
+    (cond
+     ;; is a docstring even provided?
+     ((not (stringp doc-str)))
+     ;; have we already leached on?
+     ((string-match "Supercite" doc-str))
+     ;; lets build the new doc string
+     (t
+      (let* ((described (sc-snag-all-keybindings))
+	     (commonstr "
+
+The major mode for this buffer has been modified to include the
+Supercite 2.3 package for handling attributions and citations of
+original messages in email replies.  For more information on this
+package, type \"\\[sc-describe]\".")
+	    (newdoc-str
+	     (concat doc-str commonstr
+		     (if (not (string= described ""))
+			 (concat "\n\nThe following keys are bound "
+				 "to Supercite commands:\n\n"
+				 described)))
+	     ))
+        (cond
+         (doc-cdr
+          (condition-case nil
+              (setcar doc-cdr newdoc-str)
+            (error
+             ;; the major mode must be preloaded, make a copy first
+             (setq symfunc (copy-sequence (symbol-function major-mode))
+                   doc-cdr (nthcdr 2 symfunc))
+             (setcar doc-cdr newdoc-str)
+             (fset major-mode symfunc))))
+         ;; lemacs 19 byte-code.
+         ;; Set function to a new byte-code vector with the
+         ;; new documentation in the documentation slot (element 4).
+         ;; We can't use aset because aset won't allow you to modify
+         ;; a byte-code vector.
+         ;; Include element 5 if the vector has one.
+         (t
+          (fset major-mode
+                (apply 'make-byte-code
+                       (aref symfunc 0) (aref symfunc 1)
+                       (aref symfunc 2) (aref symfunc 3)
+                       newdoc-str
+                       (if (> (length symfunc) 5)
+                           (list (aref symfunc 5)))))
+	  )))))))
+
+
+;; ======================================================================
+;; this section contains default hooks and hook support for execution
+
+(defun sc-cite-original ()
+  "Hook version of sc-cite.
+This is callable from the various mail and news readers' reply
+function according to the agreed upon standard. See \\[sc-describe]
+for more details.  Sc-cite-original does not do any yanking of the
+original message but it does require a few things:
+
+     1) The reply buffer is the current buffer.
+
+     2) The original message has been yanked and inserted into the
+        reply buffer.
+
+     3) Verbose mail headers from the original message have been
+        inserted into the reply buffer directly before the text of the
+        original message.
+
+     4) Point is at the beginning of the verbose headers.
+
+     5) Mark is at the end of the body of text to be cited."
+  (run-hooks 'sc-pre-hook)
+  (setq sc-gal-attributions nil)
+  (setq sc-gal-information nil)
+  (let ((start (region-beginning))
+	(end   (region-end)))
+    (sc-fetch-fields start end)
+    (sc-mail-yank-clear-headers start end)
+    (if (not sc-all-but-cite-p)
+	(sc-cite sc-preferred-header-style))
+    (sc-append-current-keymap)
+    (sc-spoogify-docstring)
+    (run-hooks 'sc-post-hook)))
+
+
+;; ======================================================================
+;; describe this package
+;;
+(defun sc-describe ()
+  "Supercite version 2.3 is now described in a texinfo manual which
+makes the documenation available both for online perusal via emacs'
+info system, or for hard-copy printing using the TeX facility.
+
+To view the online document hit \\[info], then \"mSupercite <RET>\"."
+  (interactive)
+  (describe-function 'sc-describe))
+
+;; ======================================================================
+;; load hook
+(run-hooks 'sc-load-hook)
+(provide 'sc)