lisp/mail/supercite.el

   1 ;;; supercite.el --- minor mode for citing mail and news replies
   2
   3 ;; Copyright (C) 1993 Free Software Foundation, Inc.
   4
   5 ;; Author: 1993 Barry A. Warsaw, Century Computing, Inc. <bwarsaw@cen.com>
   6 ;; Maintainer:    supercite-help@anthem.nlm.nih.gov
   7 ;; Created:       February 1993
   8 ;; Version:       3.1
   9 ;; Last Modified: 1993/09/22 18:58:46
  10 ;; Keywords: mail, news
  11
  12 ;; supercite.el revision: 3.54
  13
  14 ;; This file is part of GNU Emacs.
  15
  16 ;; GNU Emacs is free software; you can redistribute it and/or modify
  17 ;; it under the terms of the GNU General Public License as published by
  18 ;; the Free Software Foundation; either version 2, or (at your option)
  19 ;; any later version.
  20
  21 ;; GNU Emacs is distributed in the hope that it will be useful,
  22 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  23 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24 ;; GNU General Public License for more details.
  25
  26 ;; You should have received a copy of the GNU General Public License
  27 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  28 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  29 ;; Boston, MA 02111-1307, USA.
  30
  31 ;; LCD Archive Entry
  32 ;; supercite|Barry A. Warsaw|supercite-help@anthem.nlm.nih.gov
  33 ;; |Mail and news reply citation package
  34 ;; |1993/09/22 18:58:46|3.1|
  35
  36 ;; Code:
  37
  38 \f
  39 (require 'regi)
  40
  41 ;; start user configuration variables
  42 ;; vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
  43
  44 (defvar sc-auto-fill-region-p t
  45   "*If non-nil, automatically fill each paragraph after it has been cited.")
  46
  47 (defvar sc-blank-lines-after-headers 1
  48   "*Number of blank lines to leave after mail headers have been nuked.
  49 Set to nil, to use whatever blank lines happen to occur naturally.")
  50
  51 (defvar sc-citation-leader "    "
  52   "*String comprising first part of a citation.")
  53 (defvar sc-citation-delimiter ">"
  54   "*String comprising third part of a citation.
  55 This string is used in both nested and non-nested citations.")
  56 (defvar sc-citation-separator " "
  57   "*String comprising fourth and last part of a citation.")
  58
  59 (defvar sc-citation-leader-regexp "[ \t]*"
  60   "*Regexp describing citation leader for a cited line.
  61 This should NOT have a leading `^' character.")
  62
  63 ;; Nemacs and Mule users note: please see the texinfo manual for
  64 ;; suggestions on setting these variables.
  65 (defvar sc-citation-root-regexp "[-._a-zA-Z0-9]*"
  66   "*Regexp describing variable root part of a citation for a cited line.
  67 This should NOT have a leading `^' character.  See also
  68 `sc-citation-nonnested-root-regexp'.")
  69 (defvar sc-citation-nonnested-root-regexp "[-._a-zA-Z0-9]+"
  70   "*Regexp describing the variable root part of a nested citation.
  71 This should NOT have a leading `^' character.  This variable is
  72 related to `sc-citation-root-regexp' but whereas that variable
  73 describes both nested and non-nested citation roots, this variable
  74 describes only nested citation roots.")
  75 (defvar sc-citation-delimiter-regexp "[>]+"
  76   "*Regexp describing citation delimiter for a cited line.
  77 This should NOT have a leading `^' character.")
  78 (defvar sc-citation-separator-regexp "[ \t]*"
  79   "*Regexp describing citation separator for a cited line.
  80 This should NOT have a leading `^' character.")
  81
  82 (defvar sc-cite-blank-lines-p nil
  83   "*If non-nil, put a citation on blank lines.")
  84
  85 (defvar sc-cite-frame-alist '()
  86   "*Alist for frame selection during citing.
  87 Each element of this list has the following form:
  88
  89    (INFOKEY ((REGEXP . FRAME)
  90              (REGEXP . FRAME)
  91              (...)))
  92
  93 Where INFOKEY is a key for `sc-mail-field', REGEXP is a regular
  94 expression to match against the INFOKEY's value.  FRAME is a citation
  95 frame, or a variable containing a citation frame.")
  96 (defvar sc-uncite-frame-alist '()
  97   "*Alist for frame selection during unciting.
  98 See the variable `sc-cite-frame-alist' for details.")
  99 (defvar sc-recite-frame-alist '()
 100   "*Alist for frame selection during reciting.
 101 See the variable `sc-cite-frame-alist' for details.")
 102
 103 (defvar sc-default-cite-frame
 104   '(;; initialize fill state and temporary variables when entering
 105     ;; frame. this makes things run much faster
 106     (begin (progn
 107              (sc-fill-if-different)
 108              (setq sc-tmp-nested-regexp (sc-cite-regexp "")
 109                    sc-tmp-nonnested-regexp (sc-cite-regexp)
 110                    sc-tmp-dumb-regexp
 111                    (concat "\\("
 112                            (sc-cite-regexp "")
 113                            "\\)"
 114                            (sc-cite-regexp sc-citation-nonnested-root-regexp))
 115                    )))
 116     ;; blank lines mean paragraph separators, so fill the last cited
 117     ;; paragraph, unless sc-cite-blank-lines-p is non-nil, in which
 118     ;; case we treat blank lines just like any other line.
 119     ("^[ \t]*$"                 (if sc-cite-blank-lines-p
 120                                     (sc-cite-line)
 121                                   (sc-fill-if-different "")))
 122     ;; do nothing if looking at a reference tag. make sure that the
 123     ;; tag string isn't the empty string since this will match every
 124     ;; line.  it cannot be nil.
 125     (sc-reference-tag-string    (if (string= sc-reference-tag-string "")
 126                                     (list 'continue)
 127                                   nil))
 128     ;; this regexp catches nested citations in which the author cited
 129     ;; a non-nested citation with a dumb citer.
 130     (sc-tmp-dumb-regexp         (sc-cite-coerce-dumb-citer))
 131     ;; if we are looking at a nested citation then add a citation level
 132     (sc-tmp-nested-regexp       (sc-add-citation-level))
 133     ;; if we're looking at a non-nested citation, coerce it to our style
 134     (sc-tmp-nonnested-regexp    (sc-cite-coerce-cited-line))
 135     ;; we must be looking at an uncited line. if we are in nested
 136     ;; citations, just add a citation level
 137     (sc-nested-citation-p       (sc-add-citation-level))
 138     ;; we're looking at an uncited line and we are in non-nested
 139     ;; citations, so cite it with a non-nested citation
 140     (t                          (sc-cite-line))
 141     ;; be sure when we're done that we fill the last cited paragraph.
 142     (end                        (sc-fill-if-different ""))
 143     )
 144   "*Default REGI frame for citing a region.")
 145
 146 (defvar sc-default-uncite-frame
 147   '(;; do nothing on a blank line
 148     ("^[ \t]*$"       nil)
 149     ;; if the line is cited, uncite it
 150     ((sc-cite-regexp) (sc-uncite-line))
 151     )
 152   "*Default REGI frame for unciting a region.")
 153
 154 (defvar sc-default-recite-frame
 155   '(;; initialize fill state when entering frame
 156     (begin            (sc-fill-if-different))
 157     ;; do nothing on a blank line
 158     ("^[ \t]*$"       nil)
 159     ;; if we're looking at a cited line, recite it
 160     ((sc-cite-regexp) (sc-recite-line (sc-cite-regexp)))
 161     ;; otherwise, the line is uncited, so just cite it
 162     (t                (sc-cite-line))
 163     ;; be sure when we're done that we fill the last cited paragraph.
 164     (end              (sc-fill-if-different ""))
 165     )
 166   "*Default REGI frame for reciting a region.")
 167
 168 (defvar sc-cite-region-limit t
 169   "*This variable controls automatic citation of yanked text.
 170 Legal values are:
 171
 172 non-nil   -- cite the entire region, regardless of its size
 173 nil       -- do not cite the region at all
 174 <integer> -- a number indicating the threshold for citation.  When
 175              the number of lines in the region is greater than this
 176              value, a warning message will be printed and the region
 177              will not be cited.  Lines in region are counted with
 178              `count-lines'.
 179
 180 The gathering of attribution information is not affected by the value
 181 of this variable.  The number of lines in the region is calculated
 182 *after* all mail headers are removed.  This variable is only consulted
 183 during the initial citing via `sc-cite-original'.")
 184
 185 (defvar sc-confirm-always-p t
 186   "*If non-nil, always confirm attribution string before citing text body.")
 187
 188 (defvar sc-default-attribution "Anon"
 189   "*String used when author's attribution cannot be determined.")
 190 (defvar sc-default-author-name "Anonymous"
 191   "*String used when author's name cannot be determined.")
 192
 193 (defvar sc-downcase-p nil
 194   "*Non-nil means downcase the attribution and citation strings.")
 195
 196 (defvar sc-electric-circular-p t
 197   "*If non-nil, treat electric references as circular.")
 198 (defvar sc-electric-mode-hook nil
 199   "*Hook for `sc-electric-mode' electric references mode.")
 200 (defvar sc-electric-references-p nil
 201   "*Use electric references if non-nil.")
 202
 203 (defvar sc-fixup-whitespace-p nil
 204   "*If non-nil, delete all leading white space before citing.")
 205
 206 (defvar sc-load-hook nil
 207   "*Hook which gets run once after Supercite loads.")
 208 (defvar sc-pre-hook nil
 209   "*Hook which gets run before each invocation of `sc-cite-original'.")
 210 (defvar sc-post-hook nil
 211   "*Hook which gets run after each invocation of `sc-cite-original'.")
 212
 213 (defvar sc-mail-warn-if-non-rfc822-p t
 214   "*Warn if mail headers don't conform to RFC822.")
 215 (defvar sc-mumble ""
 216   "*Value returned by `sc-mail-field' if field isn't in mail headers.")
 217
 218 (defvar sc-name-filter-alist
 219   '(("^\\(Mr\\|Mrs\\|Ms\\|Dr\\)[.]?$" . 0)
 220     ("^\\(Jr\\|Sr\\)[.]?$" . last)
 221     ("^ASTS$" . 0)
 222     ("^[I]+$" . last))
 223   "*Name list components which are filtered out as noise.
 224 This variable contains an association list where each element is of
 225 the form:  (REGEXP . POSITION).
 226
 227 REGEXP is a regular expression which matches the name list component.
 228 Match is performed using `string-match'.  POSITION is the position in
 229 the name list which can match the regular expression, starting at zero
 230 for the first element.  Use `last' to match the last element in the
 231 list and `any' to match all elements.")
 232
 233 (defvar sc-nested-citation-p nil
 234   "*Controls whether to use nested or non-nested citation style.
 235 Non-nil uses nested citations, nil uses non-nested citations.")
 236
 237 (defvar sc-nuke-mail-headers 'all
 238   "*Controls mail header nuking.
 239 Used in conjunction with `sc-nuke-mail-header-list'.  Legal values are:
 240
 241 `all'       -- nuke all mail headers
 242 `none'      -- don't nuke any mail headers
 243 `specified' -- nuke headers specified in `sc-nuke-mail-header-list'
 244 `keep'      -- keep headers specified in `sc-nuke-mail-header-list'")
 245
 246 (defvar sc-nuke-mail-header-list nil
 247   "*List of mail header regexps to remove or keep in body of reply.
 248 This list contains regular expressions describing the mail headers to
 249 keep or nuke, depending on the value of `sc-nuke-mail-headers'.")
 250
 251 (defvar sc-preferred-attribution-list
 252   '("sc-lastchoice" "x-attribution" "firstname" "initials" "lastname")
 253   "*Specifies what to use as the attribution string.
 254 Supercite creates a list of possible attributions when it scans the
 255 mail headers from the original message.  Each attribution choice is
 256 associated with a key in an attribution alist.  Supercite tries to
 257 pick a \"preferred\" attribution by matching the attribution alist
 258 keys against the elements in `sc-preferred-attribution-list' in order.
 259 The first non-empty string value found is used as the preferred
 260 attribution.
 261
 262 Note that Supercite now honors the X-Attribution: mail field.  If
 263 present in the original message, the value of this field should always
 264 be used to select the most preferred attribution since it reflects how
 265 the original author would like to be distinguished.  It should be
 266 considered bad taste to put any attribution preference key before
 267 \"x-attribution\" in this list, except perhaps for \"sc-lastchoice\"
 268 \(see below).
 269
 270 Supercite remembers the last attribution used when reciting an already
 271 cited paragraph.  This attribution will always be saved with the
 272 \"sc-lastchoice\" key, which can be used in this list.  Note that the
 273 last choice is always reset after every call of `sc-cite-original'.
 274
 275 Barring error conditions, the following preferences are always present
 276 in the attribution alist:
 277
 278 \"emailname\"    -- email terminus name
 279 \"initials\"     -- initials of author
 280 \"firstname\"    -- first name of author
 281 \"lastname\"     -- last name of author
 282 \"middlename-1\" -- first middle name of author
 283 \"middlename-2\" -- second middle name of author
 284 ...
 285
 286 Middle name indexes can be any positive integer greater than 0,
 287 although it is unlikely that many authors will supply more than one
 288 middle name, if that many.  The string of all middle names is
 289 associated with the key \"middlenames\".")
 290
 291 (defvar sc-attrib-selection-list nil
 292   "*An alist for selecting preferred attribution based on mail headers.
 293 Each element of this list has the following form:
 294
 295    (INFOKEY ((REGEXP . ATTRIBUTION)
 296              (REGEXP . ATTRIBUTION)
 297              (...)))
 298
 299 Where INFOKEY is a key for `sc-mail-field', REGEXP is a regular
 300 expression to match against the INFOKEY's value. ATTRIBUTION can be a
 301 string or a list.  If its a string, then it is the attribution that is
 302 selected by `sc-select-attribution'.  If it is a list, it is `eval'd
 303 and the return value must be a string, which is used as the selected
 304 attribution.  Note that the variable `sc-preferred-attribution-list'
 305 must contain an element of the string \"sc-consult\" for this variable
 306 to be consulted during attribution selection.")
 307
 308 (defvar sc-attribs-preselect-hook nil
 309   "*Hook to run before selecting an attribution.")
 310 (defvar sc-attribs-postselect-hook nil
 311   "*Hook to run after selecting an attribution, but before confirmation.")
 312
 313 (defvar sc-pre-cite-hook nil
 314   "*Hook to run before citing a region of text.")
 315 (defvar sc-pre-uncite-hook nil
 316   "*Hook to run before unciting a region of text.")
 317 (defvar sc-pre-recite-hook nil
 318   "*Hook to run before reciting a region of text.")
 319
 320 (defvar sc-preferred-header-style 4
 321   "*Index into `sc-rewrite-header-list' specifying preferred header style.
 322 Index zero accesses the first function in the list.")
 323
 324 (defvar sc-reference-tag-string ">>>>> "
 325   "*String used at the beginning of built-in reference headers.")
 326
 327 (defvar sc-rewrite-header-list
 328   '((sc-no-header)
 329     (sc-header-on-said)
 330     (sc-header-inarticle-writes)
 331     (sc-header-regarding-adds)
 332     (sc-header-attributed-writes)
 333     (sc-header-author-writes)
 334     (sc-header-verbose)
 335     (sc-no-blank-line-or-header)
 336     )
 337   "*List of reference header rewrite functions.
 338 The variable `sc-preferred-header-style' controls which function in
 339 this list is chosen for automatic reference header insertions.
 340 Electric reference mode will cycle through this list of functions.")
 341
 342 (defvar sc-titlecue-regexp "\\s +-+\\s +"
 343   "*Regular expression describing the separator between names and titles.
 344 Set to nil to treat entire field as a name.")
 345
 346 (defvar sc-use-only-preference-p nil
 347   "*Controls what happens when the preferred attribution cannot be found.
 348 If non-nil, then `sc-default-attribution' will be used.  If nil, then
 349 some secondary scheme will be employed to find a suitable attribution
 350 string.")
 351
 352 ;; ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 353 ;; end user configuration variables
 354 \f
 355 (defconst sc-version "3.1"
 356   "Supercite version number.")
 357 (defconst sc-help-address "supercite-help@anthem.nlm.nih.gov"
 358   "Address accepting submissions of bug reports.")
 359
 360 (defvar sc-mail-info nil
 361   "Alist of mail header information gleaned from reply buffer.")
 362 (defvar sc-attributions nil
 363   "Alist of attributions for use when citing.")
 364
 365 (defconst sc-emacs-features
 366   (let ((version 'v18)
 367         (flavor  'GNU))
 368     (if (string= (substring emacs-version 0 2) "19")
 369         (setq version 'v19))
 370     (if (string-match "Lucid" emacs-version)
 371         (setq flavor 'Lucid))
 372     ;; cobble up list
 373     (list version flavor))
 374   "A list describing what version of Emacs we're running on.
 375 Known flavors are:
 376
 377 All GNU18's: (v18 GNU)
 378 FSF19.x    : (v19 GNU)
 379 Lucid19.x  : (v19 Lucid)")
 380
 381
 382 (defvar sc-tmp-nested-regexp nil
 383   "Temporary regepx describing nested citations.")
 384 (defvar sc-tmp-nonnested-regexp nil
 385   "Temporary regexp describing non-nested citations.")
 386 (defvar sc-tmp-dumb-regexp nil
 387   "Temp regexp describing non-nested citation cited with a nesting citer.")
 388
 389 (defvar sc-minor-mode nil
 390   "Supercite minor mode on flag.")
 391 (defvar sc-mode-string " SC"
 392   "Supercite minor mode string.")
 393
 394 (make-variable-buffer-local 'sc-mail-info)
 395 (make-variable-buffer-local 'sc-attributions)
 396 (make-variable-buffer-local 'sc-minor-mode)
 397
 398 \f
 399 ;; ======================================================================
 400 ;; supercite keymaps
 401
 402 (defvar sc-mode-map-prefix "\C-c\C-p"
 403   "*Key binding to install Supercite keymap.
 404 If this is nil, Supercite keymap is not installed.")
 405
 406 (defvar sc-T-keymap ()
 407   "Keymap for sub-keymap of setting and toggling functions.")
 408 (if sc-T-keymap
 409     ()
 410   (setq sc-T-keymap (make-sparse-keymap))
 411   (define-key sc-T-keymap "a" 'sc-S-preferred-attribution-list)
 412   (define-key sc-T-keymap "b" 'sc-T-mail-nuke-blank-lines)
 413   (define-key sc-T-keymap "c" 'sc-T-confirm-always)
 414   (define-key sc-T-keymap "d" 'sc-T-downcase)
 415   (define-key sc-T-keymap "e" 'sc-T-electric-references)
 416   (define-key sc-T-keymap "f" 'sc-T-auto-fill-region)
 417   (define-key sc-T-keymap "h" 'sc-T-describe)
 418   (define-key sc-T-keymap "l" 'sc-S-cite-region-limit)
 419   (define-key sc-T-keymap "n" 'sc-S-mail-nuke-mail-headers)
 420   (define-key sc-T-keymap "N" 'sc-S-mail-header-nuke-list)
 421   (define-key sc-T-keymap "o" 'sc-T-electric-circular)
 422   (define-key sc-T-keymap "p" 'sc-S-preferred-header-style)
 423   (define-key sc-T-keymap "s" 'sc-T-nested-citation)
 424   (define-key sc-T-keymap "u" 'sc-T-use-only-preferences)
 425   (define-key sc-T-keymap "w" 'sc-T-fixup-whitespace)
 426   (define-key sc-T-keymap "?" 'sc-T-describe)
 427   )
 428
 429 (defvar sc-mode-map ()
 430   "Keymap for Supercite quasi-mode.")
 431 (if sc-mode-map
 432     ()
 433   (setq sc-mode-map (make-sparse-keymap))
 434   (define-key sc-mode-map "c"    'sc-cite-region)
 435   (define-key sc-mode-map "f"    'sc-mail-field-query)
 436   (define-key sc-mode-map "g"    'sc-mail-process-headers)
 437   (define-key sc-mode-map "h"    'sc-describe)
 438   (define-key sc-mode-map "i"    'sc-insert-citation)
 439   (define-key sc-mode-map "o"    'sc-open-line)
 440   (define-key sc-mode-map "r"    'sc-recite-region)
 441   (define-key sc-mode-map "\C-p" 'sc-raw-mode-toggle)
 442   (define-key sc-mode-map "u"    'sc-uncite-region)
 443   (define-key sc-mode-map "v"    'sc-version)
 444   (define-key sc-mode-map "w"    'sc-insert-reference)
 445   (define-key sc-mode-map "\C-t"  sc-T-keymap)
 446   (define-key sc-mode-map "\C-b" 'sc-submit-bug-report)
 447   (define-key sc-mode-map "?"    'sc-describe)
 448   )
 449
 450 (defvar sc-electric-mode-map ()
 451   "Keymap for `sc-electric-mode' electric references mode.")
 452 (if sc-electric-mode-map
 453     nil
 454   (setq sc-electric-mode-map (make-sparse-keymap))
 455   (define-key sc-electric-mode-map "p"    'sc-eref-prev)
 456   (define-key sc-electric-mode-map "n"    'sc-eref-next)
 457   (define-key sc-electric-mode-map "s"    'sc-eref-setn)
 458   (define-key sc-electric-mode-map "j"    'sc-eref-jump)
 459   (define-key sc-electric-mode-map "x"    'sc-eref-abort)
 460   (define-key sc-electric-mode-map "q"    'sc-eref-abort)
 461   (define-key sc-electric-mode-map "\r"   'sc-eref-exit)
 462   (define-key sc-electric-mode-map "\n"   'sc-eref-exit)
 463   (define-key sc-electric-mode-map "g"    'sc-eref-goto)
 464   (define-key sc-electric-mode-map "?"    'describe-mode)
 465   (define-key sc-electric-mode-map "\C-h" 'describe-mode)
 466   (define-key sc-electric-mode-map [f1]   'describe-mode)
 467   (define-key sc-electric-mode-map [help] 'describe-mode)
 468   )
 469
 470 (defvar sc-minibuffer-local-completion-map nil
 471   "Keymap for minibuffer confirmation of attribution strings.")
 472 (if sc-minibuffer-local-completion-map
 473     ()
 474   (setq sc-minibuffer-local-completion-map
 475         (copy-keymap minibuffer-local-completion-map))
 476   (define-key sc-minibuffer-local-completion-map "\C-t" 'sc-toggle-fn)
 477   (define-key sc-minibuffer-local-completion-map " "    'self-insert-command))
 478
 479 (defvar sc-minibuffer-local-map nil
 480   "Keymap for minibuffer confirmation of attribution strings.")
 481 (if sc-minibuffer-local-map
 482     ()
 483   (setq sc-minibuffer-local-map (copy-keymap minibuffer-local-map))
 484   (define-key sc-minibuffer-local-map "\C-t" 'sc-toggle-fn))
 485
 486 \f
 487 ;; ======================================================================
 488 ;; utility functions
 489
 490 (defun sc-completing-read (prompt table &optional predicate require-match
 491                                   initial-contents history)
 492   "Compatibility between Emacs 18 and 19 `completing-read'.
 493 In version 18, the HISTORY argument is ignored."
 494   (if (memq 'v19 sc-emacs-features)
 495       (funcall 'completing-read prompt table predicate require-match
 496                initial-contents history)
 497     (funcall 'completing-read prompt table predicate require-match
 498              (or (car-safe initial-contents)
 499                  initial-contents))))
 500
 501 (defun sc-read-string (prompt &optional initial-contents history)
 502   "Compatibility between Emacs 18 and 19 `read-string'.
 503 In version 18, the HISTORY argument is ignored."
 504   (if (memq 'v19 sc-emacs-features)
 505       ;; maybe future versions will take a `history' argument:
 506       (read-string prompt initial-contents)
 507     (read-string prompt initial-contents)))
 508
 509 (if (fboundp 'match-string)
 510     (defalias 'sc-submatch 'match-string)
 511   (defun sc-submatch (matchnum &optional string)
 512     "Returns `match-beginning' and `match-end' sub-expression for MATCHNUM.
 513 If optional STRING is provided, take sub-expression using `substring'
 514 of argument, otherwise use `buffer-substring' on current buffer.  Note
 515 that `match-data' must have already been generated and no error
 516 checking is performed by this function."
 517     (if string
 518         (substring string (match-beginning matchnum) (match-end matchnum))
 519       (buffer-substring (match-beginning matchnum) (match-end matchnum)))))
 520
 521 (if (fboundp 'member)
 522     (defalias 'sc-member 'member)
 523   (defun sc-member (elt list)
 524     "Like `memq', but uses `equal' instead of `eq'.
 525 Emacs19 has a builtin function `member' which does exactly this."
 526     (catch 'elt-is-member
 527       (while list
 528         (if (equal elt (car list))
 529             (throw 'elt-is-member list))
 530         (setq list (cdr list))))))
 531
 532 ;; One day maybe Emacs will have this...
 533 (if (fboundp 'string-text)
 534     (defalias 'sc-string-text 'string-text)
 535   (defun sc-string-text (string)
 536     "Return STRING with all text properties removed."
 537     (let ((string (copy-sequence string)))
 538       (set-text-properties 0 (length string) nil string)
 539       string)))
 540
 541 (defun sc-ask (alist)
 542   "Ask a question in the minibuffer requiring a single character answer.
 543 This function is kind of an extension of `y-or-n-p' where a single
 544 letter is used to answer a question.  Question is formed from ALIST
 545 which has members of the form:  (WORD . LETTER).  WORD is the long
 546 word form, while LETTER is the letter for selecting that answer.  The
 547 selected letter is returned, or nil if the question was not answered.
 548 Note that WORD is a string and LETTER is a character.  All LETTERs in
 549 the list should be unique."
 550   (let* ((prompt (concat
 551                   (mapconcat (function (lambda (elt) (car elt))) alist ", ")
 552                   "? ("
 553                   (mapconcat
 554                    (function
 555                     (lambda (elt) (char-to-string (cdr elt)))) alist "/")
 556                   ") "))
 557          (p prompt)
 558          (event
 559           (if (memq 'Lucid sc-emacs-features)
 560               (allocate-event)
 561             nil)))
 562     (while (stringp p)
 563       (if (let ((cursor-in-echo-area t)
 564                 (inhibit-quit t))
 565             (message "%s" p)
 566             ;; lets be good neighbors and be compatible with all emacsen
 567             (cond
 568              ((memq 'v18 sc-emacs-features)
 569               (setq event (read-char)))
 570              ((memq 'Lucid sc-emacs-features)
 571               (next-command-event event))
 572              (t                         ; must be FSF19
 573               (setq event (read-event))))
 574             (prog1 quit-flag (setq quit-flag nil)))
 575           (progn
 576             (message "%s%s" p (single-key-description event))
 577             (and (memq 'Lucid sc-emacs-features)
 578                  (deallocate-event event))
 579             (setq quit-flag nil)
 580             (signal 'quit '())))
 581       (let ((char
 582              (if (memq 'Lucid sc-emacs-features)
 583                  (let* ((key (and (key-press-event-p event) (event-key event)))
 584                         (char (and key (event-to-character event))))
 585                    char)
 586                event))
 587             elt)
 588         (if char (setq char (downcase char)))
 589         (cond
 590          ((setq elt (rassq char alist))
 591           (message "%s%s" p (car elt))
 592           (setq p (cdr elt)))
 593          ((and (memq 'Lucid sc-emacs-features)
 594                (button-release-event-p event)) ; ignore them
 595           nil)
 596          (t
 597           (message "%s%s" p (single-key-description event))
 598           (if (memq 'Lucid sc-emacs-features)
 599               (ding nil 'y-or-n-p)
 600             (ding))
 601           (discard-input)
 602           (if (eq p prompt)
 603               (setq p (concat "Try again.  " prompt)))))))
 604     (and (memq 'Lucid sc-emacs-features)
 605          (deallocate-event event))
 606     p))
 607
 608 (defun sc-scan-info-alist (alist)
 609   "Find a match in the info alist that matches a regexp in ALIST."
 610   (let ((sc-mumble "")
 611         rtnvalue)
 612     (while alist
 613       (let* ((elem    (car alist))
 614              (infokey (car elem))
 615              (infoval (sc-mail-field infokey))
 616              (mlist   (car (cdr elem))))
 617         (while mlist
 618           (let* ((ml-elem (car mlist))
 619                  (regexp  (car ml-elem))
 620                  (thing   (cdr ml-elem)))
 621             (if (string-match regexp infoval)
 622                 ;; we found a match, time to return
 623                 (setq rtnvalue thing
 624                       mlist nil
 625                       alist nil)
 626               ;; else we didn't find a match
 627               (setq mlist (cdr mlist))
 628               )))                       ;end of mlist loop
 629         (setq alist (cdr alist))
 630         ))                              ;end of alist loop
 631     rtnvalue))
 632
 633 \f
 634 ;; ======================================================================
 635 ;; extract mail field information from headers in reply buffer
 636
 637 ;; holder variables for bc happiness
 638 (defvar sc-mail-headers-start nil
 639   "Start of header fields.")
 640 (defvar sc-mail-headers-end nil
 641   "End of header fields.")
 642 (defvar sc-mail-field-history nil
 643   "For minibuffer completion on mail field queries.")
 644 (defvar sc-mail-field-modification-history nil
 645   "For minibuffer completion on mail field modifications.")
 646 (defvar sc-mail-glom-frame
 647   '((begin                        (setq sc-mail-headers-start (point)))
 648     ("^x-attribution:[ \t]+.*$"   (sc-mail-fetch-field t) nil t)
 649     ("^\\S +:.*$"                 (sc-mail-fetch-field) nil t)
 650     ("^$"                         (list 'abort '(step . 0)))
 651     ("^[ \t]+"                    (sc-mail-append-field))
 652     (sc-mail-warn-if-non-rfc822-p (sc-mail-error-in-mail-field))
 653     (end                          (setq sc-mail-headers-end (point))))
 654   "Regi frame for glomming mail header information.")
 655
 656 ;; regi functions
 657 (defun sc-mail-fetch-field (&optional attribs-p)
 658   "Insert a key and value into `sc-mail-info' alist.
 659 If optional ATTRIBS-P is non-nil, the key/value pair is placed in
 660 `sc-attributions' too."
 661   (if (string-match "^\\(\\S *\\)\\s *:\\s +\\(.*\\)$" curline)
 662       (let* ((key (downcase (sc-string-text (sc-submatch 1 curline))))
 663              (val (sc-string-text (sc-submatch 2 curline)))
 664              (keyval (cons key val)))
 665         (setq sc-mail-info (cons keyval sc-mail-info))
 666         (if attribs-p
 667             (setq sc-attributions (cons keyval sc-attributions)))
 668         ))
 669   nil)
 670
 671 (defun sc-mail-append-field ()
 672   "Append a continuation line onto the last fetched mail field's info."
 673   (let ((keyval (car sc-mail-info)))
 674     (if (and keyval (string-match "^\\s *\\(.*\\)$" curline))
 675         (setcdr keyval (concat (cdr keyval) " "
 676                                (sc-string-text (sc-submatch 1 curline))))))
 677   nil)
 678
 679 (defun sc-mail-error-in-mail-field ()
 680   "Issue warning that mail headers don't conform to RFC 822."
 681   (let* ((len (min (length curline) 10))
 682          (ellipsis (if (< len (length curline)) "..." ""))
 683          (msg "Mail header \"%s%s\" doesn't conform to RFC 822. skipping..."))
 684     (message msg (substring curline 0 len) ellipsis))
 685   (beep)
 686   (sit-for 2)
 687   nil)
 688
 689 ;; mail header nuking
 690 (defvar sc-mail-last-header-nuked-p nil
 691   "True if the last header was nuked.")
 692
 693 (defun sc-mail-nuke-line ()
 694   "Nuke the current mail header line."
 695   (delete-region (regi-pos 'bol) (regi-pos 'bonl))
 696   '((step . -1)))
 697
 698 (defun sc-mail-nuke-header-line ()
 699   "Delete current-line and set up for possible continuation."
 700   (setq sc-mail-last-header-nuked-p t)
 701   (sc-mail-nuke-line))
 702
 703 (defun sc-mail-nuke-continuation-line ()
 704   "Delete a continuation line if the last header line was deleted."
 705   (if sc-mail-last-header-nuked-p
 706       (sc-mail-nuke-line)))
 707
 708 (defun sc-mail-cleanup-blank-lines ()
 709   "Leave some blank lines after original mail headers are nuked.
 710 The number of lines left is specified by `sc-blank-lines-after-headers'."
 711   (if sc-blank-lines-after-headers
 712       (save-restriction
 713         (widen)
 714         (skip-chars-backward " \t\n")
 715         (forward-line 1)
 716         (delete-blank-lines)
 717         (beginning-of-line)
 718         (if (looking-at "[ \t]*$")
 719             (delete-region (regi-pos 'bol) (regi-pos 'bonl)))
 720         (insert-char ?\n sc-blank-lines-after-headers)))
 721   nil)
 722
 723 (defun sc-mail-build-nuke-frame ()
 724   "Build the regiframe for nuking mail headers."
 725   (let (every-func entry-func nonentry-func)
 726     (cond
 727      ((eq sc-nuke-mail-headers 'all)
 728       (setq every-func '(progn (forward-line -1) (sc-mail-nuke-line))))
 729      ((eq sc-nuke-mail-headers 'specified)
 730       (setq entry-func    '(sc-mail-nuke-header-line)
 731             nonentry-func '(setq sc-mail-last-header-nuked-p nil)))
 732      ((eq sc-nuke-mail-headers 'keep)
 733       (setq entry-func    '(setq sc-mail-last-header-nuked-p nil)
 734             nonentry-func '(sc-mail-nuke-header-line)))
 735      ;; we never get far enough to interpret a frame if s-n-m-h == 'none
 736      ((eq sc-nuke-mail-headers 'none))
 737      (t (error "Illegal value for sc-nuke-mail-headers: %s"
 738                sc-nuke-mail-headers))
 739      )                                  ; end-cond
 740     (append
 741      (and entry-func
 742           (regi-mapcar sc-nuke-mail-header-list entry-func nil t))
 743      (and nonentry-func (list (list "^\\S +:.*$" nonentry-func)))
 744      (and (not every-func)
 745           '(("^[ \t]+" (sc-mail-nuke-continuation-line))))
 746      '((begin     (setq sc-mail-last-header-zapped-p nil)))
 747      '((end       (sc-mail-cleanup-blank-lines)))
 748      (and every-func (list (list 'every every-func)))
 749      )))
 750
 751 ;; mail processing and zapping. this is the top level entry defun to
 752 ;; all header processing.
 753 (defun sc-mail-process-headers (start end)
 754   "Process original mail message's mail headers.
 755 After processing, mail headers may be nuked.  Header information is
 756 stored in `sc-mail-info', and any old information is lost unless an
 757 error occurs."
 758   (interactive "r")
 759   (let ((info (copy-alist sc-mail-info))
 760         (attribs (copy-alist sc-attributions)))
 761     (setq sc-mail-info nil
 762           sc-attributions nil)
 763     (regi-interpret sc-mail-glom-frame start end)
 764     (if (null sc-mail-info)
 765         (progn
 766           (message "No mail headers found! Restoring old information.")
 767           (setq sc-mail-info info
 768                 sc-attributions attribs))
 769       (regi-interpret (sc-mail-build-nuke-frame)
 770                       sc-mail-headers-start sc-mail-headers-end)
 771       )))
 772
 773 \f
 774 ;; let the user change mail field information
 775 (defun sc-mail-field (field)
 776   "Return the mail header field value associated with FIELD.
 777 If there was no mail header with FIELD as its key, return the value of
 778 `sc-mumble'.  FIELD is case insensitive."
 779   (or (cdr (assoc (downcase field) sc-mail-info)) sc-mumble))
 780
 781 (defun sc-mail-field-query (arg)
 782   "View the value of a mail field.
 783 With `\\[universal-argument]', prompts for action on mail field.
 784 Action can be one of: View, Modify, Add, or Delete."
 785   (interactive "P")
 786   (let* ((alist '(("view" . ?v) ("modify" . ?m) ("add" . ?a) ("delete" . ?d)))
 787          (action (if (not arg) ?v (sc-ask alist)))
 788          key)
 789     (if (not action)
 790         ()
 791       (setq key (sc-completing-read
 792                  (concat (car (rassq action alist))
 793                               " information key: ")
 794                  sc-mail-info nil
 795                  (if (eq action ?a) nil 'noexit)
 796                  nil 'sc-mail-field-history))
 797       (cond
 798        ((eq action ?v)
 799         (message "%s: %s" key (cdr (assoc key sc-mail-info))))
 800        ((eq action ?d)
 801         (setq sc-mail-info (delq (assoc key sc-mail-info) sc-mail-info)))
 802        ((eq action ?m)
 803         (let ((keyval (assoc key sc-mail-info)))
 804           ;; first put initial value onto list if not already there
 805           (if (not (sc-member (cdr keyval)
 806                               sc-mail-field-modification-history))
 807               (setq sc-mail-field-modification-history
 808                     (cons (cdr keyval) sc-mail-field-modification-history)))
 809           (setcdr keyval (sc-read-string
 810                           (concat key ": ") (cdr keyval)
 811                           'sc-mail-field-modification-history))))
 812        ((eq action ?a)
 813         (setq sc-mail-info
 814               (cons (cons key
 815                           (sc-read-string (concat key ": "))) sc-mail-info)))
 816        ))))
 817
 818 \f
 819 ;; ======================================================================
 820 ;; attributions
 821
 822 (defvar sc-attribution-confirmation-history nil
 823   "History for confirmation of attribution strings.")
 824 (defvar sc-citation-confirmation-history nil
 825   "History for confirmation of attribution prefixes.")
 826
 827 (defun sc-attribs-%@-addresses (from &optional delim)
 828   "Extract the author's email terminus from email address FROM.
 829 Match addresses of the style ``name%[stuff].'' when called with DELIM
 830 of \"%\" and addresses of the style ``[stuff]name@[stuff]'' when
 831 called with DELIM \"@\".  If DELIM is nil or not provided, matches
 832 addresses of the style ``name''."
 833   (and (string-match (concat "[-a-zA-Z0-9_.]+" delim) from 0)
 834        (substring from
 835                   (match-beginning 0)
 836                   (- (match-end 0) (if (null delim) 0 1)))))
 837
 838 (defun sc-attribs-!-addresses (from)
 839   "Extract the author's email terminus from email address FROM.
 840 Match addresses of the style ``[stuff]![stuff]...!name[stuff].''"
 841   (let ((eos (length from))
 842         (mstart (string-match "![-a-zA-Z0-9_.]+\\([^-!a-zA-Z0-9_.]\\|$\\)"
 843                               from 0))
 844         (mend (match-end 0)))
 845     (and mstart
 846          (substring from (1+ mstart) (- mend (if (= mend eos) 0 1)))
 847          )))
 848
 849 (defun sc-attribs-<>-addresses (from)
 850   "Extract the author's email terminus from email address FROM.
 851 Match addresses of the style ``<name[stuff]>.''"
 852   (and (string-match "<\\(.*\\)>" from)
 853        (sc-submatch 1 from)))
 854
 855 (defun sc-get-address (from author)
 856   "Get the full email address path from FROM.
 857 AUTHOR is the author's name (which is removed from the address)."
 858   (let ((eos (length from)))
 859     (if (string-match (concat "\\(^\\|^\"\\)" author
 860                               "\\(\\s +\\|\"\\s +\\)") from 0)
 861         (let ((address (substring from (match-end 0) eos)))
 862           (if (and (= (aref address 0) ?<)
 863                    (= (aref address (1- (length address))) ?>))
 864               (substring address 1 (1- (length address)))
 865             address))
 866       (if (string-match "[-a-zA-Z0-9!@%._]+" from 0)
 867           (sc-submatch 0 from)
 868         "")
 869       )))
 870
 871 (defun sc-attribs-emailname (from)
 872   "Get the email terminus name from FROM."
 873   (or
 874    (sc-attribs-%@-addresses from "%")
 875    (sc-attribs-%@-addresses from "@")
 876    (sc-attribs-!-addresses  from)
 877    (sc-attribs-<>-addresses from)
 878    (sc-attribs-%@-addresses from)
 879    (substring from 0 10)))
 880
 881 (defun sc-name-substring (string start end extend)
 882   "Extract the specified substring of STRING from START to END.
 883 EXTEND is the number of characters on each side to extend the
 884 substring."
 885   (and start
 886        (let ((sos (+ start extend))
 887              (eos (- end extend)))
 888          (substring string sos
 889                     (or (string-match sc-titlecue-regexp string sos) eos)
 890                     ))))
 891
 892 (defun sc-attribs-extract-namestring (from)
 893   "Extract the name string from FROM.
 894 This should be the author's full name minus an optional title."
 895   (let ((namestring
 896          (or
 897           ;; If there is a <...> in the name,
 898           ;; treat everything before that as the full name.
 899           ;; Even if it contains parens, use the whole thing.
 900           ;; On the other hand, we do look for quotes in the usual way.
 901           (and (string-match " *<.*>" from 0)
 902                (let ((before-angles
 903                       (sc-name-substring from 0 (match-beginning 0) 0)))
 904                  (if (string-match "\".*\"" before-angles 0)
 905                      (sc-name-substring
 906                       before-angles (match-beginning 0) (match-end 0) 1)
 907                    before-angles)))
 908           (sc-name-substring
 909            from (string-match "(.*)" from 0) (match-end 0) 1)
 910           (sc-name-substring
 911            from (string-match "\".*\"" from 0) (match-end 0) 1)
 912           (sc-name-substring
 913            from (string-match "\\([-.a-zA-Z0-9_]+\\s +\\)+<" from 0)
 914            (match-end 1) 0)
 915           (sc-attribs-emailname from))))
 916     ;; strip off any leading or trailing whitespace
 917     (if namestring
 918         (let ((bos 0)
 919               (eos (1- (length namestring))))
 920           (while (and (<= bos eos)
 921                       (memq (aref namestring bos) '(32 ?\t)))
 922             (setq bos (1+ bos)))
 923           (while (and (> eos bos)
 924                       (memq (aref namestring eos) '(32 ?\t)))
 925             (setq eos (1- eos)))
 926           (substring namestring bos (1+ eos))))))
 927
 928 (defun sc-attribs-chop-namestring (namestring)
 929   "Convert NAMESTRING to a list of names.
 930 example: (sc-namestring-to-list \"John Xavier Doe\")
 931          => (\"John\" \"Xavier\" \"Doe\")"
 932   (if (string-match "\\([ \t]*\\)\\([^ \t._]+\\)\\([ \t]*\\)" namestring)
 933       (cons (sc-submatch 2 namestring)
 934             (sc-attribs-chop-namestring (substring namestring (match-end 3)))
 935             )))
 936
 937 (defun sc-attribs-strip-initials (namelist)
 938   "Extract the author's initials from the NAMELIST."
 939   (mapconcat
 940    (function
 941     (lambda (name)
 942       (if (< 0 (length name))
 943           (substring name 0 1))))
 944    namelist ""))
 945
 946 (defun sc-guess-attribution (&optional string)
 947   "Guess attribution string on current line.
 948 If attribution cannot be guessed, nil is returned.  Optional STRING if
 949 supplied, is used instead of the line point is on in the current buffer."
 950   (let ((start 0)
 951         (string (or string (buffer-substring (regi-pos 'bol) (regi-pos 'eol))))
 952         attribution)
 953     (and
 954      (= start (or (string-match sc-citation-leader-regexp string start) -1))
 955      (setq start (match-end 0))
 956      (= start (or (string-match sc-citation-root-regexp string start) 1))
 957      (setq attribution (sc-submatch 0 string)
 958            start (match-end 0))
 959      (= start (or (string-match sc-citation-delimiter-regexp string start) -1))
 960      (setq start (match-end 0))
 961      (= start (or (string-match sc-citation-separator-regexp string start) -1))
 962      attribution)))
 963
 964 (defun sc-attribs-filter-namelist (namelist)
 965   "Filter out noise in NAMELIST according to `sc-name-filter-alist'."
 966   (let ((elements (length namelist))
 967         (position -1)
 968         keepers filtered-list)
 969     (mapcar
 970      (function
 971       (lambda (name)
 972         (setq position (1+ position))
 973         (let ((keep-p t))
 974           (mapcar
 975            (function
 976             (lambda (filter)
 977               (let ((regexp (car filter))
 978                     (pos (cdr filter)))
 979                 (if (and (string-match regexp name)
 980                          (or (and (numberp pos)
 981                                   (= pos position))
 982                              (and (eq pos 'last)
 983                                   (= position (1- elements)))
 984                              (eq pos 'any)))
 985                     (setq keep-p nil))
 986                 )))
 987            sc-name-filter-alist)
 988           (if keep-p
 989               (setq keepers (cons position keepers)))
 990           )))
 991      namelist)
 992     (mapcar
 993      (function
 994       (lambda (position)
 995         (setq filtered-list (cons (nth position namelist) filtered-list))
 996         ))
 997      keepers)
 998     filtered-list))
 999
1000 (defun sc-attribs-chop-address (from)
1001   "Extract attribution information from FROM.
1002 This populates the `sc-attributions' with the list of possible attributions."
1003   (if (and (stringp from)
1004            (< 0 (length from)))
1005       (let* ((sc-mumble "")
1006              (namestring (sc-attribs-extract-namestring from))
1007              (namelist   (sc-attribs-filter-namelist
1008                           (sc-attribs-chop-namestring namestring)))
1009              (revnames   (reverse (cdr namelist)))
1010              (firstname  (car namelist))
1011              (midnames   (reverse (cdr revnames)))
1012              (lastname   (car revnames))
1013              (initials   (sc-attribs-strip-initials namelist))
1014              (emailname  (sc-attribs-emailname from))
1015              (n 1)
1016              author middlenames)
1017
1018         ;; put basic information
1019         (setq
1020          ;; put middle names and build sc-author entry
1021          middlenames (mapconcat
1022                       (function
1023                        (lambda (midname)
1024                          (let ((key-attribs (format "middlename-%d" n))
1025                                (key-mail    (format "sc-middlename-%d" n)))
1026                            (setq
1027                             sc-attributions (cons (cons key-attribs midname)
1028                                                   sc-attributions)
1029                             sc-mail-info (cons (cons key-mail midname)
1030                                                sc-mail-info)
1031                             n (1+ n))
1032                            midname)))
1033                       midnames " ")
1034
1035          author (concat firstname " " middlenames (and midnames " ") lastname)
1036
1037          sc-attributions (append
1038                           (list
1039                            (cons "firstname"   firstname)
1040                            (cons "lastname"    lastname)
1041                            (cons "emailname"   emailname)
1042                            (cons "initials"    initials))
1043                           sc-attributions)
1044          sc-mail-info (append
1045                        (list
1046                         (cons "sc-firstname"   firstname)
1047                         (cons "sc-middlenames" middlenames)
1048                         (cons "sc-lastname"    lastname)
1049                         (cons "sc-emailname"   emailname)
1050                         (cons "sc-initials"    initials)
1051                         (cons "sc-author"      author)
1052                         (cons "sc-from-address" (sc-get-address
1053                                                  (sc-mail-field "from")
1054                                                  namestring))
1055                         (cons "sc-reply-address" (sc-get-address
1056                                                   (sc-mail-field "reply-to")
1057                                                   namestring))
1058                         (cons "sc-sender-address" (sc-get-address
1059                                                    (sc-mail-field "sender")
1060                                                    namestring))
1061                         )
1062                        sc-mail-info)
1063          ))
1064     ;; from string is empty
1065     (setq sc-mail-info (cons (cons "sc-author" sc-default-author-name)
1066                              sc-mail-info))))
1067
1068 (defvar sc-attrib-or-cite nil
1069   "Used to toggle between attribution input or citation input.")
1070
1071 (defun sc-toggle-fn ()
1072   "Toggle between attribution selection and citation selection.
1073 Only used during confirmation."
1074   (interactive)
1075   (setq sc-attrib-or-cite (not sc-attrib-or-cite))
1076   (throw 'sc-reconfirm t))
1077
1078 (defun sc-select-attribution ()
1079   "Select an attribution from `sc-attributions'.
1080
1081 Variables involved in selection process include:
1082      `sc-preferred-attribution-list'
1083      `sc-use-only-preference-p'
1084      `sc-confirm-always-p'
1085      `sc-default-attribution'
1086      `sc-attrib-selection-list'.
1087
1088 Runs the hook `sc-attribs-preselect-hook' before selecting an
1089 attribution and the hook `sc-attribs-postselect-hook' after making the
1090 selection but before querying is performed.  During
1091 `sc-attribs-postselect-hook' the variable `citation' is bound to the
1092 auto-selected citation string and the variable `attribution' is bound
1093 to the auto-selected attribution string."
1094   (run-hooks 'sc-attribs-preselect-hook)
1095   (let ((query-p sc-confirm-always-p)
1096         attribution citation
1097         (attriblist sc-preferred-attribution-list))
1098
1099     ;; first cruise through sc-preferred-attribution-list looking for
1100     ;; a match in either sc-attributions or sc-mail-info.  if the
1101     ;; element is "sc-consult", then we have to do the alist
1102     ;; consultation phase
1103     (while attriblist
1104       (let* ((preferred (car attriblist)))
1105         (cond
1106          ((string= preferred "sc-consult")
1107           ;; we've been told to consult the attribution vs. mail
1108           ;; header key alist.  we do this until we find a match in
1109           ;; the sc-attrib-selection-list.  if we do not find a match,
1110           ;; we continue scanning attriblist
1111           (let ((attrib (sc-scan-info-alist sc-attrib-selection-list)))
1112             (cond
1113              ((not attrib)
1114               (setq attriblist (cdr attriblist)))
1115              ((stringp attrib)
1116               (setq attribution attrib
1117                     attriblist nil))
1118              ((listp attrib)
1119               (setq attribution (eval attrib)
1120                     attriblist nil))
1121              (t (error "%s did not evaluate to a string or list!"
1122                        "sc-attrib-selection-list"))
1123              )))
1124          ((setq attribution (cdr (assoc preferred sc-attributions)))
1125           (setq attriblist nil))
1126          (t
1127           (setq attriblist (cdr attriblist)))
1128          )))
1129
1130     ;; if preference was not found, we may use a secondary method to
1131     ;; find a valid attribution
1132     (if (and (not attribution)
1133              (not sc-use-only-preference-p))
1134         ;; secondary method tries to find a preference in this order
1135         ;; 1. sc-lastchoice
1136         ;; 2. x-attribution
1137         ;; 3. firstname
1138         ;; 4. lastname
1139         ;; 5. initials
1140         ;; 6. first non-empty attribution in alist
1141         (setq attribution
1142               (or (cdr (assoc "sc-lastchoice" sc-attributions))
1143                   (cdr (assoc "x-attribution" sc-attributions))
1144                   (cdr (assoc "firstname" sc-attributions))
1145                   (cdr (assoc "lastname" sc-attributions))
1146                   (cdr (assoc "initials" sc-attributions))
1147                   (cdr (car sc-attributions)))))
1148
1149     ;; still couldn't find an attribution. we're now limited to using
1150     ;; the default attribution, but we'll force a query when this happens
1151     (if (not attribution)
1152         (setq attribution sc-default-attribution
1153               query-p t))
1154
1155     ;; create the attribution prefix
1156     (setq citation (sc-make-citation attribution))
1157
1158     ;; run the post selection hook before querying the user
1159     (run-hooks 'sc-attribs-postselect-hook)
1160
1161     ;; query for confirmation
1162     (if query-p
1163         (let* ((query-alist (mapcar (function (lambda (entry)
1164                                                 (list (cdr entry))))
1165                                     sc-attributions))
1166                (minibuffer-local-completion-map
1167                 sc-minibuffer-local-completion-map)
1168                (minibuffer-local-map sc-minibuffer-local-map)
1169                (initial attribution)
1170                (completer-disable t)    ; in case completer.el is used
1171                choice)
1172           (setq sc-attrib-or-cite nil)  ; nil==attribution, t==citation
1173           (while
1174               (catch 'sc-reconfirm
1175                 (string= "" (setq choice
1176                                   (if sc-attrib-or-cite
1177                                       (sc-read-string
1178                                        "Enter citation prefix: "
1179                                        citation
1180                                        'sc-citation-confirmation-history)
1181                                     (sc-completing-read
1182                                      "Complete attribution name: "
1183                                      query-alist nil nil
1184                                      (cons initial 0)
1185                                      'sc-attribution-confirmation-history)
1186                                     )))))
1187           (if sc-attrib-or-cite
1188               ;; since the citation was chosen, we have to guess at
1189               ;; the attribution
1190               (setq citation choice
1191                     attribution (or (sc-guess-attribution citation)
1192                                     citation))
1193
1194             (setq citation (sc-make-citation choice)
1195                   attribution choice))
1196           ))
1197
1198     ;; its possible that the user wants to downcase the citation and
1199     ;; attribution
1200     (if sc-downcase-p
1201         (setq citation (downcase citation)
1202               attribution (downcase attribution)))
1203
1204     ;; set up mail info alist
1205     (let* ((ckey "sc-citation")
1206            (akey "sc-attribution")
1207            (ckeyval (assoc ckey sc-mail-info))
1208            (akeyval (assoc akey sc-mail-info)))
1209       (if ckeyval
1210           (setcdr ckeyval citation)
1211         (setq sc-mail-info
1212               (append (list (cons ckey citation)) sc-mail-info)))
1213       (if akeyval
1214           (setcdr akeyval attribution)
1215         (setq sc-mail-info
1216               (append (list (cons akey attribution)) sc-mail-info))))
1217
1218     ;; set the sc-lastchoice attribution
1219     (let* ((lkey "sc-lastchoice")
1220            (lastchoice (assoc lkey sc-attributions)))
1221       (if lastchoice
1222           (setcdr lastchoice attribution)
1223         (setq sc-attributions
1224               (cons (cons lkey attribution) sc-attributions))))
1225     ))
1226
1227 \f
1228 ;; ======================================================================
1229 ;; filladapt hooks for supercite 3.1. you shouldn't need anything
1230 ;; extra to make gin-mode understand supercited lines.  Even this
1231 ;; stuff might not be entirely necessary...
1232
1233 (defun sc-cite-regexp (&optional root-regexp)
1234   "Return a regexp describing a Supercited line.
1235 The regexp is the concatenation of `sc-citation-leader-regexp',
1236 `sc-citation-root-regexp', `sc-citation-delimiter-regexp', and
1237 `sc-citation-separator-regexp'.  If optional ROOT-REGEXP is supplied,
1238 use it instead of `sc-citation-root-regexp'."
1239   (concat sc-citation-leader-regexp
1240           (or root-regexp sc-citation-root-regexp)
1241           sc-citation-delimiter-regexp
1242           sc-citation-separator-regexp))
1243
1244 (defun sc-make-citation (attribution)
1245   "Make a non-nested citation from ATTRIBUTION."
1246   (concat sc-citation-leader
1247           attribution
1248           sc-citation-delimiter
1249           sc-citation-separator))
1250
1251 (defun sc-setup-filladapt ()
1252   "Setup `filladapt-prefix-table' to handle Supercited paragraphs."
1253   (let* ((fa-sc-elt 'filladapt-supercite-included-text)
1254          (elt (rassq fa-sc-elt filladapt-prefix-table)))
1255     (if elt (setcar elt (sc-cite-regexp))
1256       (message "Filladapt doesn't seem to know about Supercite.")
1257       (beep))))
1258
1259 \f
1260 ;; ======================================================================
1261 ;; citing and unciting regions of text
1262
1263 (defvar sc-fill-begin 1
1264   "Buffer position to begin filling.")
1265 (defvar sc-fill-line-prefix ""
1266   "Fill prefix of previous line")
1267
1268 ;; filling
1269 (defun sc-fill-if-different (&optional prefix)
1270   "Fill the region bounded by `sc-fill-begin' and point.
1271 Only fill if optional PREFIX is different than `sc-fill-line-prefix'.
1272 If `sc-auto-fill-region-p' is nil, do not fill region.  If PREFIX is
1273 not supplied, initialize fill variables.  This is useful for a regi
1274 `begin' frame-entry."
1275   (if (not prefix)
1276       (setq sc-fill-line-prefix ""
1277             sc-fill-begin (regi-pos 'bol))
1278     (if (and sc-auto-fill-region-p
1279              (not (string= prefix sc-fill-line-prefix)))
1280         (let ((fill-prefix sc-fill-line-prefix))
1281           (if (not (string= fill-prefix ""))
1282               (fill-region sc-fill-begin (regi-pos 'bol)))
1283           (setq sc-fill-line-prefix prefix
1284                 sc-fill-begin (regi-pos 'bol))))
1285     )
1286   nil)
1287
1288 (defun sc-cite-coerce-cited-line ()
1289   "Coerce a Supercited line to look like our style."
1290   (let* ((attribution (sc-guess-attribution))
1291          (regexp (sc-cite-regexp attribution))
1292          (prefix (sc-make-citation attribution)))
1293     (if (and attribution
1294              (looking-at regexp))
1295         (progn
1296           (delete-region
1297            (match-beginning 0)
1298            (save-excursion
1299              (goto-char (match-end 0))
1300              (if (bolp) (forward-char -1))
1301              (point)))
1302           (insert prefix)
1303           (sc-fill-if-different prefix)))
1304     nil))
1305
1306 (defun sc-cite-coerce-dumb-citer ()
1307   "Coerce a non-nested citation that's been cited with a dumb nesting citer."
1308   (delete-region (match-beginning 1) (match-end 1))
1309   (beginning-of-line)
1310   (sc-cite-coerce-cited-line))
1311
1312 (defun sc-guess-nesting (&optional string)
1313   "Guess the citation nesting on the current line.
1314 If nesting cannot be guessed, nil is returned.  Optional STRING if
1315 supplied, is used instead of the line point is on in the current
1316 buffer."
1317   (let ((start 0)
1318         (string (or string (buffer-substring (regi-pos 'bol) (regi-pos 'eol))))
1319         nesting)
1320     (and
1321      (= start (or (string-match sc-citation-leader-regexp string start) -1))
1322      (setq start (match-end 0))
1323      (= start (or (string-match sc-citation-delimiter-regexp string start) -1))
1324      (setq nesting (sc-submatch 0 string)
1325            start (match-end 0))
1326      (= start (or (string-match sc-citation-separator-regexp string start) -1))
1327      nesting)))
1328
1329 (defun sc-add-citation-level ()
1330   "Add a citation level for nested citation style w/ coercion."
1331   (let* ((nesting (sc-guess-nesting))
1332          (citation (make-string (1+ (length nesting))
1333                                 (string-to-char sc-citation-delimiter)))
1334          (prefix (concat sc-citation-leader citation sc-citation-separator)))
1335     (if (looking-at (sc-cite-regexp ""))
1336         (delete-region (match-beginning 0) (match-end 0)))
1337     (insert prefix)
1338     (sc-fill-if-different prefix)))
1339
1340 (defun sc-cite-line (&optional citation)
1341   "Cite a single line of uncited text.
1342 Optional CITATION overrides any citation automatically selected."
1343   (if sc-fixup-whitespace-p
1344       (fixup-whitespace))
1345   (let ((prefix (or citation
1346                     (cdr (assoc "sc-citation" sc-mail-info))
1347                     sc-default-attribution)))
1348     (insert prefix)
1349     (sc-fill-if-different prefix))
1350   nil)
1351
1352 (defun sc-uncite-line ()
1353   "Remove citation from current line."
1354   (let ((cited (looking-at (sc-cite-regexp))))
1355     (if cited
1356         (delete-region (match-beginning 0) (match-end 0))))
1357   nil)
1358
1359 (defun sc-recite-line (regexp)
1360   "Remove citation matching REGEXP from current line and recite line."
1361   (let ((cited (looking-at (concat "^" regexp)))
1362         (prefix (cdr (assoc "sc-citation" sc-mail-info))))
1363     (if cited
1364         (delete-region (match-beginning 0) (match-end 0)))
1365     (insert (or prefix sc-default-attribution))
1366     (sc-fill-if-different prefix))
1367   nil)
1368
1369 ;; interactive functions
1370 (defun sc-cite-region (start end &optional confirm-p)
1371   "Cite a region delineated by START and END.
1372 If optional CONFIRM-P is non-nil, the attribution is confirmed before
1373 its use in the citation string.  This function first runs
1374 `sc-pre-cite-hook'."
1375   (interactive "r\nP")
1376   (undo-boundary)
1377   (let ((frame (or (sc-scan-info-alist sc-cite-frame-alist)
1378                    sc-default-cite-frame))
1379         (sc-confirm-always-p (if confirm-p t sc-confirm-always-p)))
1380     (run-hooks 'sc-pre-cite-hook)
1381     (if (interactive-p)
1382         (sc-select-attribution))
1383     (regi-interpret frame start end)))
1384
1385 (defun sc-uncite-region (start end)
1386   "Uncite a region delineated by START and END.
1387 First runs `sc-pre-uncite-hook'."
1388   (interactive "r")
1389   (undo-boundary)
1390   (let ((frame (or (sc-scan-info-alist sc-uncite-frame-alist)
1391                    sc-default-uncite-frame)))
1392     (run-hooks 'sc-pre-uncite-hook)
1393     (regi-interpret frame start end)))
1394
1395 (defun sc-recite-region (start end)
1396   "Recite a region delineated by START and END.
1397 First runs `sc-pre-recite-hook'."
1398   (interactive "r")
1399   (let ((sc-confirm-always-p t))
1400     (sc-select-attribution))
1401   (undo-boundary)
1402   (let ((frame (or (sc-scan-info-alist sc-recite-frame-alist)
1403                    sc-default-recite-frame)))
1404     (run-hooks 'sc-pre-recite-hook)
1405     (regi-interpret frame start end)))
1406
1407 \f
1408 ;; ======================================================================
1409 ;; building headers
1410
1411 (defun sc-hdr (prefix field &optional sep return-nil-p)
1412   "Returns a concatenation of PREFIX and FIELD.
1413 If FIELD is not a string or is the empty string, the empty string will
1414 be returned.  Optional third argument SEP is concatenated on the end if
1415 it is a string.  Returns empty string, unless optional RETURN-NIL-P is
1416 non-nil."
1417   (if (and (stringp field)
1418            (not (string= field "")))
1419       (concat prefix field (or sep ""))
1420     (and (not return-nil-p) "")))
1421
1422 (defun sc-whofrom ()
1423   "Return the value of (sc-mail-field \"from\") or nil."
1424   (let ((sc-mumble nil))
1425     (sc-mail-field "from")))
1426
1427 (defun sc-no-header ()
1428   "Does nothing.  Use this instead of nil to get a blank header."
1429   ())
1430
1431 (defun sc-no-blank-line-or-header()
1432   "Similar to `sc-no-header' except it removes the preceding blank line."
1433   (if (not (bobp))
1434       (if (and (eolp)
1435                (progn (forward-line -1)
1436                       (or (looking-at
1437                            (concat "^" (regexp-quote mail-header-separator) "$"))
1438                           (and (eq major-mode 'mh-letter-mode)
1439                                (mh-in-header-p)))))
1440           (progn (forward-line)
1441                  (let ((kill-lines-magic t))
1442                    (kill-line))))))
1443
1444 (defun sc-header-on-said ()
1445   "\"On <date>, <from> said:\" unless:
1446 1. the \"from\" field cannot be found, in which case nothing is inserted;
1447 2. the \"date\" field is missing in which case only the from part is printed."
1448   (let ((sc-mumble "")
1449         (whofrom (sc-whofrom)))
1450     (if whofrom
1451         (insert sc-reference-tag-string
1452                 (sc-hdr "On " (sc-mail-field "date") ", ")
1453                 whofrom " said:\n"))))
1454
1455 (defun sc-header-inarticle-writes ()
1456   "\"In article <message-id>, <from> writes:\"
1457 Treats \"message-id\" and \"from\" fields similar to `sc-header-on-said'."
1458   (let ((sc-mumble "")
1459         (whofrom (sc-mail-field "from")))
1460     (if whofrom
1461         (insert sc-reference-tag-string
1462                 (sc-hdr "In article " (sc-mail-field "message-id") ", ")
1463                 whofrom " writes:\n"))))
1464
1465 (defun sc-header-regarding-adds ()
1466   "\"Regarding <subject>; <from> adds:\"
1467 Treats \"subject\" and \"from\" fields similar to `sc-header-on-said'."
1468   (let ((sc-mumble "")
1469         (whofrom (sc-whofrom)))
1470     (if whofrom
1471         (insert sc-reference-tag-string
1472                 (sc-hdr "Regarding " (sc-mail-field "subject") "; ")
1473                 whofrom " adds:\n"))))
1474
1475 (defun sc-header-attributed-writes ()
1476   "\"<sc-attribution>\" == <sc-author> <address> writes:
1477 Treats these fields in a similar manner to `sc-header-on-said'."
1478   (let ((sc-mumble "")
1479         (whofrom (sc-whofrom)))
1480     (if whofrom
1481         (insert sc-reference-tag-string
1482                 (sc-hdr "\"" (sc-mail-field "sc-attribution") "\" == ")
1483                 (sc-hdr ""   (sc-mail-field "sc-author") " ")
1484                 (or (sc-hdr "<" (sc-mail-field "sc-from-address") ">" t)
1485                     (sc-hdr "<" (sc-mail-field "sc-reply-address") ">"  t)
1486                     "")
1487                 " writes:\n"))))
1488
1489 (defun sc-header-author-writes ()
1490   "<sc-author> writes:"
1491   (let ((sc-mumble "")
1492         (whofrom (sc-whofrom)))
1493     (if whofrom
1494         (insert sc-reference-tag-string
1495                 (sc-hdr "" (sc-mail-field "sc-author"))
1496                 " writes:\n"))))
1497
1498 (defun sc-header-verbose ()
1499   "Very verbose, some say gross."
1500   (let ((sc-mumble "")
1501         (whofrom (sc-whofrom))
1502         (tag sc-reference-tag-string))
1503     (if whofrom
1504         (insert (sc-hdr (concat tag "On ") (sc-mail-field "date") ",\n")
1505                 (or (sc-hdr tag (sc-mail-field "sc-author") "\n" t)
1506                     (concat tag whofrom "\n"))
1507                 (sc-hdr (concat tag "from the organization of ")
1508                         (sc-mail-field "organization") "\n")
1509                 (let ((rtag (concat tag "who can be reached at: ")))
1510                   (or (sc-hdr rtag (sc-mail-field "sc-from-address") "\n" t)
1511                       (sc-hdr rtag (sc-mail-field "sc-reply-address")  "\n" t)
1512                       ""))
1513                 (sc-hdr
1514                  (concat tag "(whose comments are cited below with \"")
1515                  (sc-mail-field "sc-citation") "\"),\n")
1516                 (sc-hdr (concat tag "had this to say in article ")
1517                         (sc-mail-field "message-id") "\n")
1518                 (sc-hdr (concat tag "in newsgroups ")
1519                         (sc-mail-field "newsgroups") "\n")
1520                 (sc-hdr (concat tag "concerning the subject of ")
1521                         (sc-mail-field "subject") "\n")
1522                 (sc-hdr (concat tag "(see ")
1523                         (sc-mail-field "references")
1524                         " for more details)\n")
1525                 ))))
1526
1527 \f
1528 ;; ======================================================================
1529 ;; header rewrites
1530
1531 (defconst sc-electric-bufname " *sc-erefs* "
1532   "Supercite electric reference mode's buffer name.")
1533 (defvar sc-eref-style 0
1534   "Current electric reference style.")
1535
1536 (defun sc-valid-index-p (index)
1537   "Returns INDEX if it is a valid index into `sc-rewrite-header-list'.
1538 Otherwise returns nil."
1539     ;; a number, and greater than or equal to zero
1540     ;; less than or equal to the last index
1541     (and (natnump index)
1542          (< index (length sc-rewrite-header-list))
1543          index))
1544
1545 (defun sc-eref-insert-selected (&optional nomsg)
1546   "Insert the selected reference header in the current buffer.
1547 Optional NOMSG, if non-nil, inhibits printing messages, unless an
1548 error occurs."
1549   (let ((ref (nth sc-eref-style sc-rewrite-header-list)))
1550     (condition-case err
1551         (progn
1552           (eval ref)
1553           (let ((lines (count-lines (point-min) (point-max))))
1554             (or nomsg (message "Ref header %d [%d line%s]: %s"
1555                                sc-eref-style lines
1556                                (if (= lines 1) "" "s")
1557                                ref))))
1558       (void-function
1559        (progn (message
1560                "Symbol's function definition is void: %s (Header %d)"
1561                (car (cdr err)) sc-eref-style)
1562               (beep)
1563               ))
1564       )))
1565
1566 (defun sc-electric-mode (&optional arg)
1567   "
1568 Mode for viewing Supercite reference headers.  Commands are:
1569 \n\\{sc-electric-mode-map}
1570
1571 `sc-electric-mode' is not intended to be run interactively, but rather
1572 accessed through Supercite's electric reference feature.  See
1573 `sc-insert-reference' for more details.  Optional ARG is the initial
1574 header style to use, unless not supplied or invalid, in which case
1575 `sc-preferred-header-style' is used."
1576
1577   (let ((info sc-mail-info))
1578
1579     (setq sc-eref-style
1580           (or (sc-valid-index-p arg)
1581               (sc-valid-index-p sc-preferred-header-style)
1582               0))
1583
1584     (get-buffer-create sc-electric-bufname)
1585     ;; set up buffer and enter command loop
1586     (save-excursion
1587       (save-window-excursion
1588         (pop-to-buffer sc-electric-bufname)
1589         (kill-all-local-variables)
1590         (let ((sc-mail-info info)
1591               (buffer-read-only t)
1592               (mode-name "SC Electric Refs")
1593               (major-mode 'sc-electric-mode))
1594           (use-local-map sc-electric-mode-map)
1595           (sc-eref-show sc-eref-style)
1596           (run-hooks 'sc-electric-mode-hook)
1597           (recursive-edit)
1598           )))
1599
1600     (and sc-eref-style
1601          (sc-eref-insert-selected))
1602     (kill-buffer sc-electric-bufname)
1603     ))
1604
1605 ;; functions for electric reference mode
1606 (defun sc-eref-show (index)
1607   "Show reference INDEX in `sc-rewrite-header-list'."
1608   (let ((msg "No %ing reference headers in list.")
1609         (last (length sc-rewrite-header-list)))
1610     (setq sc-eref-style
1611           (cond
1612            ((sc-valid-index-p index) index)
1613            ((< index 0)
1614             (if sc-electric-circular-p
1615                 (1- last)
1616               (progn (error msg "preced") 0)))
1617            ((>= index last)
1618             (if sc-electric-circular-p
1619                 0
1620               (progn (error msg "follow") (1- last))))
1621            ))
1622     (save-excursion
1623      (set-buffer sc-electric-bufname)
1624      (let ((buffer-read-only nil))
1625        (erase-buffer)
1626        (goto-char (point-min))
1627        (sc-eref-insert-selected)
1628        ;; now shrink the window to just contain the electric reference
1629        ;; header.
1630        (let ((hdrlines (count-lines (point-min) (point-max)))
1631              (winlines (1- (window-height))))
1632          (if (/= hdrlines winlines)
1633              (if (> hdrlines winlines)
1634                  ;; we have to enlarge the window
1635                  (enlarge-window (- hdrlines winlines))
1636                ;; we have to shrink the window
1637                (shrink-window (- winlines (max hdrlines window-min-height)))
1638                )))
1639        ))))
1640
1641 (defun sc-eref-next ()
1642   "Display next reference in other buffer."
1643   (interactive)
1644   (sc-eref-show (1+ sc-eref-style)))
1645
1646 (defun sc-eref-prev ()
1647   "Display previous reference in other buffer."
1648   (interactive)
1649   (sc-eref-show (1- sc-eref-style)))
1650
1651 (defun sc-eref-setn ()
1652   "Set reference header selected as preferred."
1653   (interactive)
1654   (setq sc-preferred-header-style sc-eref-style)
1655   (message "Preferred reference style set to header %d." sc-eref-style))
1656
1657 (defun sc-eref-goto (refnum)
1658   "Show reference style indexed by REFNUM.
1659 If REFNUM is an invalid index, don't go to that reference and return
1660 nil."
1661   (interactive "NGoto Reference: ")
1662   (if (sc-valid-index-p refnum)
1663       (sc-eref-show refnum)
1664     (error "Invalid reference: %d. (Range: [%d .. %d])"
1665            refnum 0 (1- (length sc-rewrite-header-list)))
1666     ))
1667
1668 (defun sc-eref-jump ()
1669   "Set reference header to preferred header."
1670   (interactive)
1671   (sc-eref-show sc-preferred-header-style))
1672
1673 (defun sc-eref-abort ()
1674   "Exit from electric reference mode without inserting reference."
1675   (interactive)
1676   (setq sc-eref-style nil)
1677   (exit-recursive-edit))
1678
1679 (defun sc-eref-exit ()
1680   "Exit from electric reference mode and insert selected reference."
1681   (interactive)
1682   (exit-recursive-edit))
1683
1684 (defun sc-insert-reference (arg)
1685   "Insert, at point, a reference header in the body of the reply.
1686 Numeric ARG indicates which header style from `sc-rewrite-header-list'
1687 to use when rewriting the header.  No supplied ARG indicates use of
1688 `sc-preferred-header-style'.
1689
1690 With just `\\[universal-argument]', electric reference insert mode is
1691 entered, regardless of the value of `sc-electric-references-p'.  See
1692 `sc-electric-mode' for more information."
1693   (interactive "P")
1694   (if (consp arg)
1695       (sc-electric-mode)
1696     (let ((preference (or (sc-valid-index-p arg)
1697                           (sc-valid-index-p sc-preferred-header-style)
1698                           sc-preferred-header-style
1699                           0)))
1700       (if sc-electric-references-p
1701           (sc-electric-mode preference)
1702         (sc-eref-insert-selected t)
1703         ))))
1704
1705 \f
1706 ;; ======================================================================
1707 ;; variable toggling
1708
1709 (defun sc-raw-mode-toggle ()
1710   "Toggle, in one fell swoop, two important SC variables:
1711 `sc-fixup-whitespace-p' and `sc-auto-fill-region-p'"
1712   (interactive)
1713   (setq sc-fixup-whitespace-p (not sc-fixup-whitespace-p)
1714         sc-auto-fill-region-p (not sc-auto-fill-region-p))
1715   (sc-set-mode-string)
1716   (force-mode-line-update))
1717
1718 (defun sc-toggle-var (variable)
1719   "Boolean toggle VARIABLE's value.
1720 VARIABLE must be a bound symbol.  Nil values change to t, non-nil
1721 values are changed to nil."
1722   (message "%s changed from %s to %s"
1723            variable (symbol-value variable)
1724            (set-variable variable (not (eval-expression variable))))
1725   (sc-set-mode-string))
1726
1727 (defun sc-set-variable (var)
1728   "Set the Supercite VARIABLE.
1729 This function mimics `set-variable', except that the variable to set
1730 is determined non-interactively.  The value is queried for in the
1731 minibuffer exactly the same way that `set-variable' does it.
1732
1733 You can see the current value of the variable when the minibuffer is
1734 querying you by typing `C-h'.  Note that the format is changed
1735 slightly from that used by `set-variable' -- the current value is
1736 printed just after the variable's name instead of at the bottom of the
1737 help window."
1738   (let* ((minibuffer-help-form
1739           '(funcall myhelp))
1740          (myhelp
1741           (function
1742            (lambda ()
1743              (with-output-to-temp-buffer "*Help*"
1744                (prin1 var)
1745                (if (boundp var)
1746                    (let ((print-length 20))
1747                      (princ "\t(Current value: ")
1748                      (prin1 (symbol-value var))
1749                      (princ ")")))
1750                (princ "\n\nDocumentation:\n")
1751                (princ (substring (documentation-property
1752                                   var
1753                                   'variable-documentation)
1754                                   1))
1755                (save-excursion
1756                  (set-buffer standard-output)
1757                  (help-mode))
1758                nil)))))
1759     (set var (eval-minibuffer (format "Set %s to value: " var))))
1760   (sc-set-mode-string))
1761
1762 (defmacro sc-toggle-symbol (rootname)
1763   (list 'defun (intern (concat "sc-T-" rootname)) '()
1764         (list 'interactive)
1765         (list 'sc-toggle-var
1766               (list 'quote (intern (concat "sc-" rootname "-p"))))))
1767
1768 (defmacro sc-setvar-symbol (rootname)
1769   (list 'defun (intern (concat "sc-S-" rootname)) '()
1770         (list 'interactive)
1771         (list 'sc-set-variable
1772               (list 'quote (intern (concat "sc-" rootname))))))
1773
1774 (sc-toggle-symbol "confirm-always")
1775 (sc-toggle-symbol "downcase")
1776 (sc-toggle-symbol "electric-references")
1777 (sc-toggle-symbol "auto-fill-region")
1778 (sc-toggle-symbol "mail-nuke-blank-lines")
1779 (sc-toggle-symbol "nested-citation")
1780 (sc-toggle-symbol "electric-circular")
1781 (sc-toggle-symbol "use-only-preferences")
1782 (sc-toggle-symbol "fixup-whitespace")
1783
1784 (sc-setvar-symbol "preferred-attribution-list")
1785 (sc-setvar-symbol "preferred-header-style")
1786 (sc-setvar-symbol "mail-nuke-mail-headers")
1787 (sc-setvar-symbol "mail-header-nuke-list")
1788 (sc-setvar-symbol "cite-region-limit")
1789
1790 (defun sc-T-describe ()
1791   "
1792
1793 Supercite provides a number of key bindings which simplify the process
1794 of setting or toggling certain variables controlling its operation.
1795
1796 Note on function names in this list: all functions of the form
1797 `sc-S-<name>' actually call `sc-set-variable' on the corresponding
1798 `sc-<name>' variable.  All functions of the form `sc-T-<name>' call
1799 `sc-toggle-var' on the corresponding `sc-<name>-p' variable.
1800
1801 \\{sc-T-keymap}"
1802   (interactive)
1803   (describe-function 'sc-T-describe))
1804
1805 (defun sc-set-mode-string ()
1806   "Update the minor mode string to show state of Supercite."
1807   (setq sc-mode-string
1808         (concat " SC"
1809                 (if (or sc-auto-fill-region-p
1810                         sc-fixup-whitespace-p)
1811                     ":" "")
1812                 (if sc-auto-fill-region-p "f" "")
1813                 (if sc-fixup-whitespace-p "w" "")
1814                 )))
1815
1816 \f
1817 ;; ======================================================================
1818 ;; published interface to mail and news readers
1819
1820 ;;;###autoload
1821 (defun sc-cite-original ()
1822   "Workhorse citing function which performs the initial citation.
1823 This is callable from the various mail and news readers' reply
1824 function according to the agreed upon standard.  See `\\[sc-describe]'
1825 for more details.  `sc-cite-original' does not do any yanking of the
1826 original message but it does require a few things:
1827
1828      1) The reply buffer is the current buffer.
1829
1830      2) The original message has been yanked and inserted into the
1831         reply buffer.
1832
1833      3) Verbose mail headers from the original message have been
1834         inserted into the reply buffer directly before the text of the
1835         original message.
1836
1837      4) Point is at the beginning of the verbose headers.
1838
1839      5) Mark is at the end of the body of text to be cited.
1840
1841 For Emacs 19's, the region need not be active (and typically isn't
1842 when this function is called.  Also, the hook `sc-pre-hook' is run
1843 before, and `sc-post-hook' is run after the guts of this function."
1844   (run-hooks 'sc-pre-hook)
1845
1846   ;; before we do anything, we want to insert the supercite keymap so
1847   ;; we can proceed from here
1848   (and sc-mode-map-prefix
1849        (local-set-key sc-mode-map-prefix sc-mode-map))
1850
1851   ;; hack onto the minor mode alist, if it hasn't been done before,
1852   ;; then turn on the minor mode. also, set the minor mode string with
1853   ;; the values of fill and fixup whitespace variables
1854   (if (not (get 'minor-mode-alist 'sc-minor-mode))
1855       (progn
1856         (put 'minor-mode-alist 'sc-minor-mode 'sc-minor-mode)
1857         (setq minor-mode-alist
1858               (cons '(sc-minor-mode sc-mode-string) minor-mode-alist))
1859         ))
1860   (setq sc-minor-mode t)
1861   (sc-set-mode-string)
1862
1863   (undo-boundary)
1864
1865   ;; grab point and mark since the region is probably not active when
1866   ;; this function gets automatically called. we want point to be a
1867   ;; mark so any deleting before point works properly
1868   (let* ((zmacs-regions nil)            ; for Lemacs
1869          (mark-active t)                ; for FSFmacs
1870          (point (point-marker))
1871          (mark  (copy-marker (mark-marker))))
1872
1873     ;; make sure point comes before mark, not all functions are
1874     ;; interactive "r"
1875     (if (< mark point)
1876         (let ((tmp point))
1877           (setq point mark
1878                 mark tmp)))
1879
1880     ;; first process mail headers, and populate sc-mail-info
1881     (sc-mail-process-headers point mark)
1882
1883     ;; now get possible attributions
1884     (sc-attribs-chop-address (or (sc-mail-field "from")
1885                                  (sc-mail-field "reply")
1886                                  (sc-mail-field "reply-to")
1887                                  (sc-mail-field "sender")))
1888     ;; select the attribution
1889     (sc-select-attribution)
1890
1891     ;; cite the region, but first check the value of sc-cite-region-limit
1892     (let ((linecnt (count-lines point mark)))
1893       (and sc-cite-region-limit
1894            (if (or (not (numberp sc-cite-region-limit))
1895                    (<= linecnt sc-cite-region-limit))
1896                (progn
1897                  ;; cite the region and insert the header rewrite
1898                  (sc-cite-region point mark)
1899                  (goto-char point)
1900                  (let ((sc-eref-style (or sc-preferred-header-style 0)))
1901                    (if sc-electric-references-p
1902                        (sc-electric-mode sc-eref-style)
1903                      (sc-eref-insert-selected t))))
1904              (beep)
1905              (message
1906               "Region not cited. %d lines exceeds sc-cite-region-limit: %d"
1907               linecnt sc-cite-region-limit))))
1908
1909     ;; finally, free the point-marker
1910     (set-marker point nil)
1911     (set-marker mark nil)
1912     )
1913   (run-hooks 'sc-post-hook)
1914   ;; post hook could have changed the variables
1915   (sc-set-mode-string))
1916
1917 \f
1918 ;; ======================================================================
1919 ;; bug reporting and miscellaneous commands
1920
1921 (defun sc-open-line (arg)
1922   "Like `open-line', but insert the citation prefix at the front of the line.
1923 With numeric ARG, inserts that many new lines."
1924   (interactive "p")
1925   (save-excursion
1926     (let ((start (point))
1927           (prefix (or (progn (beginning-of-line)
1928                              (if (looking-at (sc-cite-regexp))
1929                                  (sc-submatch 0)))
1930                       "")))
1931       (goto-char start)
1932       (open-line arg)
1933       (forward-line 1)
1934       (while (< 0 arg)
1935         (insert prefix)
1936         (forward-line 1)
1937         (setq arg (1- arg))
1938         ))))
1939
1940 (defun sc-insert-citation (arg)
1941   "Insert citation string at beginning of current line if not already cited.
1942 With `\\[universal-argument]' insert citation even if line is already
1943 cited."
1944   (interactive "P")
1945   (save-excursion
1946     (beginning-of-line)
1947     (if (or (not (looking-at (sc-cite-regexp)))
1948             (looking-at "^[ \t]*$")
1949             (consp arg))
1950         (insert (sc-mail-field "sc-citation"))
1951       (error "Line is already cited."))))
1952
1953 (defun sc-version (arg)
1954   "Echo the current version of Supercite in the minibuffer.
1955 With \\[universal-argument] (universal-argument), or if run non-interactively,
1956 inserts the version string in the current buffer instead."
1957   (interactive "P")
1958   (let ((verstr (format "Using Supercite.el %s" sc-version)))
1959     (if (or (consp arg)
1960             (not (interactive-p)))
1961         (insert "`sc-version' says: " verstr)
1962       (message verstr))))
1963
1964 (defun sc-describe ()
1965   "
1966 Supercite is a package which provides a flexible mechanism for citing
1967 email and news replies.  Please see the associated texinfo file for
1968 more information."
1969   (interactive)
1970   (describe-function 'sc-describe))
1971
1972 (defun sc-submit-bug-report ()
1973   "Submit a bug report on Supercite via mail."
1974   (interactive)
1975   (require 'reporter)
1976   (and
1977    (y-or-n-p "Do you want to submit a report on Supercite? ")
1978    (reporter-submit-bug-report
1979     sc-help-address
1980     (concat "Supercite version " sc-version)
1981     (list
1982      'sc-attrib-selection-list
1983      'sc-auto-fill-region-p
1984      'sc-blank-lines-after-headers
1985      'sc-citation-leader
1986      'sc-citation-delimiter
1987      'sc-citation-separator
1988      'sc-citation-leader-regexp
1989      'sc-citation-root-regexp
1990      'sc-citation-nonnested-root-regexp
1991      'sc-citation-delimiter-regexp
1992      'sc-citation-separator-regexp
1993      'sc-cite-region-limit
1994      'sc-confirm-always-p
1995      'sc-default-attribution
1996      'sc-default-author-name
1997      'sc-downcase-p
1998      'sc-electric-circular-p
1999      'sc-electric-references-p
2000      'sc-fixup-whitespace-p
2001      'sc-mail-warn-if-non-rfc822-p
2002      'sc-mumble
2003      'sc-name-filter-alist
2004      'sc-nested-citation-p
2005      'sc-nuke-mail-headers
2006      'sc-nuke-mail-header-list
2007      'sc-preferred-attribution-list
2008      'sc-preferred-header-style
2009      'sc-reference-tag-string
2010      'sc-rewrite-header-list
2011      'sc-titlecue-regexp
2012      'sc-use-only-preference-p
2013      ))))
2014
2015 \f
2016 ;; useful stuff
2017 (provide 'supercite)
2018 (run-hooks 'sc-load-hook)
2019
2020 ;;; supercite.el ends here