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