emacs: lisp/allout.el comparison

comparison lisp/allout.el @ 79939:f87999df3305

Many doc fixes. (allout-encrypt-string): Fix error message.

author	Richard M. Stallman <rms@gnu.org>
date	Sun, 27 Jan 2008 01:04:56 +0000
parents	5096ade2d1f5
children	b113c474ec50

comparison

equal deleted inserted replaced

-:ad7fd6c7e3ff
+:f87999df3305
 ;; Copyright (C) 1992, 1993, 1994, 2001, 2002, 2003, 2004,
 ;;   2005, 2006, 2007, 2008 Free Software Foundation, Inc.
 ;; Author: Ken Manheimer <ken dot manheimer at gmail dot com>
 ;; Maintainer: Ken Manheimer <ken dot manheimer at gmail dot com>
-;; Created: Dec 1991 - first release to usenet
+;; Created: Dec 1991 -- first release to usenet
 ;; Version: 2.2.1
 ;; Keywords: outlines wp languages
 ;; Website: http://myriadicity.net/Sundry/EmacsAllout
 ;; This file is part of GNU Emacs.
 ;;
 ;;  - Classic outline-mode topic-oriented navigation and exposure adjustment
 ;;  - Topic-oriented editing including coherent topic and subtopic
 ;;    creation, promotion, demotion, cut/paste across depths, etc.
 ;;  - Incremental search with dynamic exposure and reconcealment of text
-;;  - Customizable bullet format - enables programming-language specific
+;;  - Customizable bullet format -- enables programming-language specific
 ;;    outlining, for code-folding editing.  (Allout code itself is to try it;
-;;    formatted as an outline - do ESC-x eval-buffer in allout.el; but
+;;    formatted as an outline -- do ESC-x eval-buffer in allout.el; but
 ;;    emacs local file variables need to be enabled when the
-;;    file was visited - see `enable-local-variables'.)
+;;    file was visited -- see `enable-local-variables'.)
 ;;  - Configurable per-file initial exposure settings
 ;;  - Symmetric-key and key-pair topic encryption, plus symmetric passphrase
 ;;    mnemonic support, with verification against an established passphrase
 ;;    (using a stashed encrypted dummy string) and user-supplied hint
 ;;    maintenance.  (See allout-toggle-current-subtree-encryption docstring.
 ;;  - Automatic topic-number maintenance
 ;;  - "Hot-spot" operation, for single-keystroke maneuvering and
 ;;    exposure control (see the allout-mode docstring)
 ;;  - Easy rendering of exposed portions into numbered, latex, indented, etc
 ;;    outline styles
-;;  - Careful attention to whitespace - enabling blank lines between items
+;;  - Careful attention to whitespace -- enabling blank lines between items
 ;;    and maintenance of hanging indentation (in paragraph auto-fill and
 ;;    across topic promotion and demotion) of topic bodies consistent with
 ;;    indentation of their topic header.
 ;;
 ;; and more.
 ;; See the docstring of the variables `allout-layout' and
 ;; `allout-auto-activation' for details on automatic activation of
 ;; `allout-mode' as a minor mode.  (It has changed since allout
 ;; 3.x, for those of you that depend on the old method.)
 ;;
-;; Note - the lines beginning with `;;;_' are outline topic headers.
+;; Note -- the lines beginning with `;;;_' are outline topic headers.
 ;;        Just `ESC-x eval-buffer' to give it a whirl.
 ;; ken manheimer (ken dot manheimer at gmail dot com)
 ;;; Code:
 ;;;_ + Layout, Mode, and Topic Header Configuration
 ;;;_  = allout-auto-activation
 (defcustom allout-auto-activation nil
-"*Regulates auto-activation modality of allout outlines - see `allout-init'.
+"*Regulates auto-activation modality of allout outlines -- see `allout-init'.
 Setq-default by `allout-init' to regulate whether or not allout
 outline mode is automatically activated when the buffer-specific
 variable `allout-layout' is non-nil, and whether or not the layout
 dictated by `allout-layout' should be imposed on mode activation.
 value will automatically trigger `allout-mode', provided
 `allout-init' has been called to enable this behavior.
 The types of elements in the layout specification are:
-integer - dictate the relative depth to open the corresponding topic(s),
+INTEGER -- dictate the relative depth to open the corresponding topic(s),
 where:
-- negative numbers force the topic to be closed before opening
+-- negative numbers force the topic to be closed before opening
 to the absolute value of the number, so all siblings are open
 only to that level.
-- positive numbers open to the relative depth indicated by the
+-- positive numbers open to the relative depth indicated by the
 number, but do not force already opened subtopics to be closed.
-- 0 means to close topic - hide all subitems.
+-- 0 means to close topic -- hide all subitems.
-:   - repeat spec - apply the preceeding element to all siblings at
+:   -- repeat spec -- apply the preceeding element to all siblings at
 current level, *up to* those siblings that would be covered by specs
 following the `:' on the list.  Ie, apply to all topics at level but
 trailing ones accounted for by trailing specs.  (Only the first of
-multiple colons at the same level is honored - later ones are ignored.)
+multiple colons at the same level is honored -- later ones are ignored.)
-*   - completely exposes the topic, including bodies
+*   -- completely exposes the topic, including bodies
-+   - exposes all subtopics, but not the bodies
++   -- exposes all subtopics, but not the bodies
--   - exposes the body of the corresponding topic, but not subtopics
+-   -- exposes the body of the corresponding topic, but not subtopics
-list - a nested layout spec, to be applied intricately to its
+LIST -- a nested layout spec, to be applied intricately to its
 corresponding item(s)
 Examples:
-'(-2 : 0)
+(-2 : 0)
 	Collapse the top-level topics to show their children and
 grandchildren, but completely collapse the final top-level topic.
-'(-1 () : 1 0)
+(-1 () : 1 0)
 	Close the first topic so only the immediate subtopics are shown,
 leave the subsequent topics exposed as they are until the second
 	second to last topic, which is exposed at least one level, and
 completely close the last topic.
-'(-2 : -1 *)
+(-2 : -1 *)
 Expose children and grandchildren of all topics at current
 	level except the last two; expose children of the second to
 	last and completely expose the last one, including its subtopics.
 See `allout-expose-topic' for more about the exposure process.
 "*If non-nil, \\[allout-end-of-line] will cycle through smart-placement options.
 Cycling only happens on when the command is repeated, not when it
 follows a different command.
-Smart-placement means that repeated calls to this function will
+Smart placement means that repeated calls to this function will
 advance as follows:
 - if the cursor is not on the end-of-line,
 then it goes to the end-of-line
 - if the cursor is on the end-of-line but not the end-of-entry,
 otherwise automatically rebulleted, so their marking is
 persistent until deliberately changed.  Their significance is
 purely by convention, however.  Some conventions suggest
 themselves:
-`(' - open paren - an aside or incidental point
+`(' - open paren -- an aside or incidental point
-`?' - question mark - uncertain or outright question
+`?' - question mark -- uncertain or outright question
-`!' - exclamation point/bang - emphatic
+`!' - exclamation point/bang -- emphatic
-`[' - open square bracket - meta-note, about item instead of item's subject
+`[' - open square bracket -- meta-note, about item instead of item's subject
-`\"' - double quote - a quotation or other citation
+`\"' - double quote -- a quotation or other citation
-`=' - equal sign - an assignement, equating a name with some connotation
+`=' - equal sign -- an assignement, equating a name with some connotation
-`^' - carat - relates to something above
+`^' - carat -- relates to something above
 Some are more elusive, but their rationale may be recognizable:
-`+' - plus - pending consideration, completion
+`+' - plus -- pending consideration, completion
-`_' - underscore - done, completed
+`_' - underscore -- done, completed
-`&' - ampersand - addendum, furthermore
+`&' - ampersand -- addendum, furthermore
 \(Some other non-plain bullets have special meaning to the
 software.  By default:
-`~' marks encryptable topics - see `allout-topic-encryption-bullet'
+`~' marks encryptable topics -- see `allout-topic-encryption-bullet'
-`#' marks auto-numbered bullets - see `allout-numbered-bullet'.)
+`#' marks auto-numbered bullets -- see `allout-numbered-bullet'.)
 See `allout-plain-bullets-string' for the standard, alternating
 bullets.
 You must run `set-allout-regexp' in order for outline mode to
 :group 'allout)
 (make-variable-buffer-local 'allout-old-style-prefixes)
 ;;;###autoload
 (put 'allout-old-style-prefixes 'safe-local-variable
 (if (fboundp 'booleanp) 'booleanp '(lambda (x) (member x '(t nil)))))
-;;;_  = allout-stylish-prefixes - alternating bullets
+;;;_  = allout-stylish-prefixes -- alternating bullets
 (defcustom allout-stylish-prefixes t
 "*Do fancy stuff with topic prefix bullets according to level, etc.
 Non-nil enables topic creation, modification, and repositioning
 functions to vary the topic bullet char (the char that marks the topic
 (make-variable-buffer-local 'allout-passphrase-verifier-handling)
 ;;;_  = allout-passphrase-hint-handling
 (defcustom allout-passphrase-hint-handling 'always
 "*Dictate outline encryption passphrase reminder handling:
-always - always show reminder when prompting
+always -- always show reminder when prompting
-needed - show reminder on passphrase entry failure
+needed -- show reminder on passphrase entry failure
-disabled - never present or adjust reminder
+disabled -- never present or adjust reminder
 See the docstring for the `allout-enable-file-variable-adjustment'
 variable for details about allout ajustment of file variables."
 :type '(choice (const always)
 (const needed)
 currently being edited.  (In that case, the currently edited topic
 will be automatically decrypted before any user interaction, so they
 can continue editing but the copy on the file system will be
 encrypted.)
 Auto-saves will use the \"All except current topic\" mode if this
-one is selected, to avoid practical difficulties - see below.
+one is selected, to avoid practical difficulties -- see below.
 - All except current topic: skip the topic currently being edited, even if
 it's pending encryption.  This may expose the current topic on the
 file sytem, but avoids the nuisance of prompts for the encryption
 passphrase in the middle of editing for, eg, autosaves.
 This mode is used for auto-saves for both this option and \"Yes\".
 willing to let allout use a bunch of \C-c keybindings."
 :type 'string
 :group 'allout)
 ;;;_  = allout-keybindings-list
-;;; You have to reactivate allout-mode - `(allout-mode t)' - to
+;;; You have to reactivate allout-mode -- `(allout-mode t)' -- to
 ;;; institute changes to this var.
 (defvar allout-keybindings-list ()
 "*List of `allout-mode' key / function bindings, for `allout-mode-map'.
 String or vector key will be prefaced with `allout-command-prefix',
 For details, see `allout-toggle-current-subtree-encryption's docstring."
 :type 'boolean
 :group 'allout)
 (make-variable-buffer-local 'allout-enable-file-variable-adjustment)
-;;;_* CODE - no user customizations below.
+;;;_* CODE -- no user customizations below.
 ;;;_ #1 Internal Outline Formatting and Configuration
 ;;;_  : Version
 ;;;_   = allout-version
 (defvar allout-version "2.2.1"
 ;;;_  : Mode activation (defined here because it's referenced early)
 ;;;_   = allout-mode
 (defvar allout-mode nil "Allout outline mode minor-mode flag.")
 (make-variable-buffer-local 'allout-mode)
 ;;;_   = allout-layout nil
-(defvar allout-layout nil            ; LEAVE GLOBAL VALUE NIL - see docstring.
+(defvar allout-layout nil            ; LEAVE GLOBAL VALUE NIL -- see docstring.
 "Buffer-specific setting for allout layout.
 In buffers where this is non-nil (and if `allout-init' has been run, to
 enable this behavior), `allout-mode' will be automatically activated.  The
 layout dictated by the value will be used to set the initial exposure when
 (make-variable-buffer-local 'allout-regexp)
 ;;;_   = allout-bullets-string
 (defvar allout-bullets-string ""
 "A string dictating the valid set of outline topic bullets.
-This var should *not* be set by the user - it is set by `set-allout-regexp',
+This var should *not* be set by the user -- it is set by `set-allout-regexp',
 and is produced from the elements of `allout-plain-bullets-string'
 and `allout-distinctive-bullets-string'.")
 (make-variable-buffer-local 'allout-bullets-string)
 ;;;_   = allout-bullets-string-len
 (defvar allout-bullets-string-len 0
 				  (memq allout-use-mode-specific-leader
 					'(allout-mode-leaders
 					  comment-start
 					  t)))
 			      allout-use-mode-specific-leader
-			    ;; Oops - garbled value, equate with effect of 't:
+			    ;; Oops -- garbled value, equate with effect of t:
 			    t)))
 	 (leader
 	  (cond
 	   ((not use-leader) nil)
 	   ;; Use the explicitly designated leader:
 (if (not leader)
 	nil
 (setq allout-header-prefix leader)
 (if (not allout-old-style-prefixes)
 ;; setting allout-primary-bullet makes the top level topics use -
-;; actually, be - the special prefix:
+;; actually, be -- the special prefix:
 (setq allout-primary-bullet leader))
 allout-header-prefix)))
 (defalias 'allout-infer-header-lead
 'allout-infer-header-lead-and-primary-bullet)
 ;;;_   > allout-infer-body-reindent ()
 If the optional third element is the symbol 'append, then the new value is
 extended from the existing one by `append'ing a list containing the second
 element of the pair onto the end of the existing value.
 Extension, and resumptions in general, should not be used for hook
-functions - use the 'local mode of `add-hook' for that, instead.
+functions -- use the 'local mode of `add-hook' for that, instead.
 The settings are stored on `allout-mode-prior-settings'."
 (while pairs
 (let* ((pair (pop pairs))
 (name (car pair))
 (symbol-value name)
 (void-variable nil)))
 (when (not (assoc name allout-mode-prior-settings))
 ;; Not already added as a resumption, create the prior setting entry.
 (if (local-variable-p name)
-;; is already local variable - preserve the prior value:
+;; is already local variable -- preserve the prior value:
 (push (list name prior-value) allout-mode-prior-settings)
 ;; wasn't local variable, indicate so for resumption by killing
 ;; local value, and make it local:
 (push (list name) allout-mode-prior-settings)
 (make-local-variable name)))
 It is run at the conclusion of `allout-flag-region'.
 Functions on the hook must take three arguments:
-- from - integer indicating the point at the start of the change.
+- FROM -- integer indicating the point at the start of the change.
-- to - integer indicating the point of the end of the change.
+- TO -- integer indicating the point of the end of the change.
-- flag - change mode: nil for exposure, otherwise concealment.
+- FLAG -- change mode: nil for exposure, otherwise concealment.
 This hook might be invoked multiple times by a single command.
 This hook is replacing `allout-view-change-hook', which is being deprecated
 and eventually will not be invoked.")
 (defvar allout-structure-added-hook nil
 "*Hook that's run after addition of items to the outline.
 Functions on the hook should take two arguments:
-- new-start - integer indicating the point at the start of the first new item.
+- NEW-START -- integer indicating position of start of the first new item.
-- new-end - integer indicating the point of the end of the last new item.
+- NEW-END -- integer indicating position of end of the last new item.
-Some edits that introduce new items may missed by this hook -
+Some edits that introduce new items may missed by this hook:
 specifically edits that native allout routines do not control.
 This hook might be invoked multiple times by a single command.")
 ;;;_   = allout-structure-deleted-hook
 (defvar allout-structure-deleted-hook nil
 "*Hook that's run after disciplined deletion of subtrees from the outline.
 Functions on the hook must take two arguments:
-- depth - integer indicating the depth of the subtree that was deleted.
+- DEPTH -- integer indicating the depth of the subtree that was deleted.
-- removed-from - integer indicating the point where the subtree was removed.
+- REMOVED-FROM -- integer indicating the point where the subtree was removed.
-Some edits that remove or invalidate items may missed by this hook -
+Some edits that remove or invalidate items may missed by this hook:
 specifically edits that native allout routines do not control.
 This hook might be invoked multiple times by a single command.")
 ;;;_   = allout-structure-shifted-hook
 (defvar allout-structure-shifted-hook nil
 "*Hook that's run after shifting of items in the outline.
 Functions on the hook should take two arguments:
-- depth-change - integer indicating depth increase, negative for decrease
+- DEPTH-CHANGE -- integer indicating depth increase, negative for decrease
-- start - integer indicating the start point of the shifted parent item.
+- START -- integer indicating the start point of the shifted parent item.
-Some edits that shift items can be missed by this hook - specifically edits
+Some edits that shift items can be missed by this hook: specifically edits
 that native allout routines do not control.
 This hook might be invoked multiple times by a single command.")
 ;;;_   = allout-outside-normal-auto-fill-function
 (defvar allout-outside-normal-auto-fill-function nil
 See `allout-encryption-ciphertext-rejection-regexps' for rejection reasons.")
 (make-variable-buffer-local 'allout-encryption-ciphertext-rejection-ceiling)
 ;;;_   > allout-mode-p ()
 ;; Must define this macro above any uses, or byte compilation will lack
-;; proper def, if file isn't loaded - eg, during emacs build!
+;; proper def, if file isn't loaded -- eg, during emacs build!
 (defmacro allout-mode-p ()
 "Return t if `allout-mode' is active in current buffer."
 'allout-mode)
 ;;;_   > allout-write-file-hook-handler ()
 (defun allout-write-file-hook-handler ()
 (setplist 'allout-exposure-category nil)
 (put 'allout-exposure-category 'invisible 'allout)
 (put 'allout-exposure-category 'evaporate t)
 ;; XXX We use isearch-open-invisible *and* isearch-mode-end-hook.  The
 ;; latter would be sufficient, but it seems that a separate behavior -
-;; the _transient_ opening of invisible text during isearch - is keyed to
+;; the _transient_ opening of invisible text during isearch -- is keyed to
-;; presence of the isearch-open-invisible property - even though this
+;; presence of the isearch-open-invisible property -- even though this
 ;; property controls the isearch _arrival_ behavior.  This is the case at
 ;; least in emacs 21, 22.0, and xemacs 21.4.
 (put 'allout-exposure-category 'isearch-open-invisible
 'allout-isearch-end-handler)
 (if (featurep 'xemacs)
 The bindings are dictated by the customizable `allout-keybindings-list'
 variable.  We recommend customizing `allout-command-prefix' to use just
 `\\C-c' as the command prefix, if the allout bindings don't conflict with
 any personal bindings you have on \\C-c.  In any case, outline structure
 navigation and authoring is simplified by positioning the cursor on an
-item's bullet character, the \"hot-spot\" - then you can invoke allout
+item's bullet character, the \"hot-spot\" -- then you can invoke allout
 commands with just the un-prefixed, un-control-shifted command letters.
 This is described further in the HOT-SPOT Operation section.
 Exposure Control:
 ----------------
 \\[allout-up-current-level] `allout-up-current-level'
 \\[allout-forward-current-level] `allout-forward-current-level'
 \\[allout-backward-current-level] `allout-backward-current-level'
 \\[allout-end-of-entry] `allout-end-of-entry'
 \\[allout-beginning-of-current-entry] `allout-beginning-of-current-entry' (alternately, goes to hot-spot)
-\\[allout-beginning-of-line]  `allout-beginning-of-line' - like regular beginning-of-line, but
+\\[allout-beginning-of-line]  `allout-beginning-of-line' -- like regular beginning-of-line, but
 if immediately repeated cycles to the beginning of the current item
 and then to the hot-spot (if `allout-beginning-of-line-cycles' is set).
 Topic Header Production:
 \\[allout-shift-in] `allout-shift-in'   Shift current topic and all offspring deeper
 \\[allout-shift-out] `allout-shift-out' ... less deep
 \\[allout-rebullet-current-heading] `allout-rebullet-current-heading' Prompt for alternate bullet for
 current topic
 \\[allout-rebullet-topic] `allout-rebullet-topic'   Reconcile bullets of topic and
-its' offspring - distinctive bullets are not changed, others
+its' offspring -- distinctive bullets are not changed, others
 are alternated according to nesting depth.
 \\[allout-number-siblings] `allout-number-siblings'  Number bullets of topic and siblings -
 the offspring are not affected.
 With repeat count, revoke numbering.
 for `allout-layout'.
 \\[allout-mark-topic]       `allout-mark-topic'
 \\[allout-copy-exposed-to-buffer] `allout-copy-exposed-to-buffer'
 Duplicate outline, sans concealed text, to
 buffer with name derived from derived from that
-of current buffer - \"*BUFFERNAME exposed*\".
+of current buffer -- \"*BUFFERNAME exposed*\".
 \\[allout-flatten-exposed-to-buffer] `allout-flatten-exposed-to-buffer'
 Like above 'copy-exposed', but convert topic
 prefixes to section.subsection... numeric
 format.
 \\[eval-expression] (allout-init t) Setup Emacs session for outline mode
 `allout-structure-deleted-hook'
 `allout-structure-shifted-hook'
 Terminology
-Topic hierarchy constituents - TOPICS and SUBTOPICS:
+Topic hierarchy constituents -- TOPICS and SUBTOPICS:
 ITEM:   A unitary outline element, including the HEADER and ENTRY text.
 TOPIC:  An ITEM and any ITEMs contained within it, ie having greater DEPTH
 and with no intervening items of lower DEPTH than the container.
 CURRENT ITEM:
 (allout-this-or-next-heading)
 (condition-case err
 (progn
 (apply 'allout-expose-topic (list use-layout))
 (message "Adjusting '%s' exposure... done." (buffer-name)))
-;; Problem applying exposure - notify user, but don't
+;; Problem applying exposure -- notify user, but don't
 ;; interrupt, eg, file visit:
 (error (message "%s" (car (cdr err)))
 (sit-for 1))))))
 allout-mode
 )					; let*
 We expose the invisible text and ask for confirmation.  Refusal or
 `keyboard-quit' abandons the changes, with keyboard-quit additionally
 reclosing the opened text.
-No confirmation is necessary when `inhibit-read-only' is set - eg, allout
+No confirmation is necessary when `inhibit-read-only' is set -- eg, allout
 internal functions use this feature cohesively bunch changes."
 (when (and (not inhibit-read-only) (not after))
 (let ((start (point))
 (ol-start (overlay-start ol))
 (goto-char start))))
 ;;;_  > allout-before-change-handler (beg end)
 (defun allout-before-change-handler (beg end)
 "Protect against changes to invisible text.
-See allout-overlay-interior-modification-handler for details."
+See `allout-overlay-interior-modification-handler' for details."
 (if (and (allout-mode-p) undo-in-progress (allout-hidden-p))
 (allout-show-to-offshoot))
 ;; allout-overlay-interior-modification-handler on an overlay handles
 function can also be used as an `isearch-mode-end-hook'."
 (if (and (allout-mode-p) (allout-hidden-p))
 (allout-show-to-offshoot)))
-;;;_ #3 Internal Position State-Tracking - "allout-recent-*" funcs
+;;;_ #3 Internal Position State-Tracking -- "allout-recent-*" funcs
 ;;; All the basic outline functions that directly do string matches to
 ;;; evaluate heading prefix location set the variables
 ;;; `allout-recent-prefix-beginning'  and `allout-recent-prefix-end'
 ;;; when successful.  Functions starting with `allout-recent-' all
 ;;; use this state, providing the means to avoid redundant searches
 ;;;_   : Location Predicates
 ;;;_    > allout-do-doublecheck ()
 (defsubst allout-do-doublecheck ()
 "True if current item conditions qualify for checking on topic aberrance."
 (and
-;; presume integrity of outline and yanked content during yank - necessary,
+;; presume integrity of outline and yanked content during yank -- necessary
 ;; to allow for level disparity of yank location and yanked text:
 (not allout-inhibit-aberrance-doublecheck)
 ;; allout-doublecheck-at-and-shallower is ceiling for doublecheck:
 (<= allout-recent-depth allout-doublecheck-at-and-shallower)))
 ;;;_     > allout-aberrant-container-p ()
 (while (and (not done)
 (re-search-forward allout-line-boundary-regexp nil 0))
 (allout-prefix-data)
 (goto-char allout-recent-prefix-beginning)
 (cond
-;; sibling - continue:
+;; sibling -- continue:
 ((eq allout-recent-depth depth))
-;; first offspring is excessive - aberrant:
+;; first offspring is excessive -- aberrant:
 ((> allout-recent-depth (1+ depth))
 (setq done t aberrant t))
-;; next non-sibling is lower-depth - not aberrant:
+;; next non-sibling is lower-depth -- not aberrant:
 (t (setq done t)))))
 (if aberrant
 aberrant
 (goto-char start-point)
 ;; recalibrate allout-recent-*
 		(< orig-depth (setq curr-depth allout-recent-depth))
 		(cond ((= prev-depth curr-depth)
 		       ;; Register this one and move on:
 		       (setq chart (cons allout-recent-prefix-beginning chart))
 		       (if (and levels (<= levels 1))
-			   ;; At depth limit - skip sublevels:
+			   ;; At depth limit -- skip sublevels:
 			   (or (allout-next-sibling curr-depth)
-			       ;; or no more siblings - proceed to
+			       ;; or no more siblings -- proceed to
 			       ;; next heading at lesser depth:
 			       (while (and (<= curr-depth
 					       allout-recent-depth)
 (if visible
 (allout-next-visible-heading 1)
 (setq here (car chart))
 (if (listp here)
 	  (let ((further (allout-chart-to-reveal here (if (null depth)
 depth
 (1- depth)))))
-	    ;; We're on the start of a subtree - recurse with it, if there's
+	    ;; We're on the start of a subtree -- recurse with it, if there's
 	    ;; more depth to go:
 	    (if further (setq result (append further result)))
 	    (setq chart (cdr chart)))
 	(goto-char here)
 (if (allout-hidden-p)
 (setq done (or found (if backward (bobp) (eobp)))))
 (if (not found)
 (progn (goto-char start-point)
 nil)
 ;; rationale: if any intervening items were at a lower depth, we
-;; would now be on the first offspring at the target depth - ie,
+;; would now be on the first offspring at the target depth -- ie,
 ;; the preceeding item (per the search direction) must be at a
 ;; lesser depth.  that's all we need to check.
 (if backward (allout-next-heading) (allout-previous-heading))
 (if (< allout-recent-depth target-depth)
 ;; return to start and reestablish allout-recent-*:
 (allout-prefix-data)
 (if (and (allout-do-doublecheck)
 (allout-aberrant-container-p))
 ;; skip this aberrant prospective header line:
 t
-;; this prospective headerline qualifies - register:
+;; this prospective headerline qualifies -- register:
 (setq got allout-recent-prefix-beginning)
 ;; and break the loop:
 nil))))
 ;; Register this got, it may be the last:
 (if got (setq prev got))
 (char-to-string
 (if (and (<= 97 key-num)   ; "a"
 (>= 122 key-num)) ; "z"
 (- key-num 96) key-num)))
 t))))
-;; Qualified as an allout command - do hot-spot operation.
+;; Qualified as an allout command -- do hot-spot operation.
 (setq allout-post-goto-bullet t)
 ;; accept-defaults nil, or else we'll get allout-item-icon-key-handler.
 (setq mapped-binding (key-binding (char-to-string key-num))))
 (while (keymapp mapped-binding)
 Second arg NEW indicates that a new topic is being opened after the
 topic at point, if non-nil.  Default bullet for new topics, eg, may
 be set (contingent to other args) to numbered bullets if previous
 sibling is one.  The implication otherwise is that the current topic
-is being adjusted - shifted or rebulleted - and we don't consider
+is being adjusted -- shifted or rebulleted -- and we don't consider
 bullet or previous sibling.
 Third arg DEPTH forces the topic prefix to that depth, regardless of
 the current topics' depth.
 (bullet-char
 ;; Getting value for bullet char is practically the whole job:
 (cond
-; Simplest situation - level 1:
+; Simplest situation -- level 1:
 ((<= depth 1) (setq header-lead "") allout-primary-bullet)
 ; Simple, too: all asterisks:
 (allout-old-style-prefixes
-;; Cheat - make body the whole thing, null out header-lead and
+;; Cheat -- make body the whole thing, null out header-lead and
 ;; bullet-char:
 (setq body (make-string depth
 (string-to-char allout-primary-bullet)))
 (setq header-lead "")
 "")
 ;;;_   > allout-open-topic (relative-depth &optional before offer-recent-bullet)
 (defun allout-open-topic (relative-depth &optional before offer-recent-bullet)
 "Open a new topic at depth DEPTH.
 New topic is situated after current one, unless optional flag BEFORE
-is non-nil, or unless current line is completely empty - lacking even
+is non-nil, or unless current line is completely empty -- lacking even
-whitespace - in which case open is done on the current line.
+whitespace -- in which case open is done on the current line.
 When adding an offspring, it will be added immediately after the parent if
 the other offspring are exposed, or after the last child if the offspring
 are hidden.  (The intervening offspring will be exposed in the latter
 case.)
 doing-beginning
 start end)
 (if (not opening-on-blank)
 ; Positioning and vertical
-; padding - only if not
+; padding -- only if not
 ; opening-on-blank:
 (progn
 (goto-char ref-topic)
 (setq dbl-space               ; Determine double space action:
 (or (and (<= relative-depth 0)	; not descending;
 (forward-char 1))
 			   (if (not (looking-at "^$"))
 (open-line 1)))
 		  (allout-end-of-current-subtree)
 (if (looking-at "\n\n") (forward-char 1))))
-;; Going inwards - double-space if first offspring is
+;; Going inwards -- double-space if first offspring is
 ;; double-spaced, otherwise snug up.
 (allout-end-of-entry)
 (if (eobp)
 (newline 1)
 (line-move 1))
 (allout-beginning-of-current-line)
 (backward-char 1)
 (if (bolp)
 ;; Blank lines between current header body and next
-;; header - get to last substantive (non-white-space)
+;; header -- get to last substantive (non-white-space)
 ;; line in body:
 (progn (setq dbl-space t)
 (re-search-backward "[^ \t\n]" nil t)))
 (if (looking-at "\n\n")
 (setq dbl-space t))
 		  (setq old-indent-begin (match-beginning 1)
 			old-indent-end (match-end 1))
 		  (not (looking-at allout-regexp)))
 	   (if (> 0 (setq excess (- (- old-indent-end old-indent-begin)
 old-margin)))
-	       ;; Text starts left of old margin - don't adjust:
+	       ;; Text starts left of old margin -- don't adjust:
 	       nil
 	     ;; Text was hanging at or right of old left margin -
 	     ;; reindent it, preserving its existing indentation
 	     ;; beyond the old margin:
 	     (delete-region old-indent-begin old-indent-end)
 nil		;;; number
 starting-index
 nil)))) ;;; do-successors
 ((< starting-depth new-depth)
-;; Rare case - subtopic more than one level deeper than parent.
+;; Rare case -- subtopic more than one level deeper than parent.
 ;; Treat this one at an even deeper level:
 (allout-rebullet-topic-grunt relative-depth
 new-depth
 starting-point
 index
 allout-recent-depth)
 ;;;_    > allout-number-siblings (&optional denumber)
 (defun allout-number-siblings (&optional denumber)
 "Assign numbered topic prefix to this topic and its siblings.
-With universal argument, denumber - assign default bullet to this
+With universal argument, denumber -- assign default bullet to this
 topic and its siblings.
 With repeated universal argument (`^U^U'), solicit bullet for each
 rebulleting each topic at this level."
 (max (1+ (point))
 (next-single-char-property-change (point)
 'invisible
 nil end))))
 (if (or (not next) (eq prev next))
-;; still not at start of hidden area - must not be any left.
+;; still not at start of hidden area -- must not be any left.
 (setq done t)
 (goto-char next)
 (setq prev next)
 (if (not (allout-hidden-p))
 ;; still not at start of hidden area.
 (if (not (get-text-property (point) 'allout-was-hidden))
 (setq next (next-single-char-property-change (point)
 'allout-was-hidden
 nil end)))
 (if (or (not next) (eq prev next))
-;; no more or not advancing - must not be any left.
+;; no more or not advancing -- must not be any left.
 (setq done t)
 (goto-char next)
 (setq prev next)
 (if (not (get-text-property (point) 'allout-was-hidden))
 ;; still not at start of annotation.
 ;; `rectify-numbering' if resituating (where several topics may
 ;; be resituating) or yanking a topic into a topic slot (bol):
 (rectify-numbering (or resituate
 (and into-bol (looking-at allout-regexp)))))
 (if resituate
-;; Yanking a topic into the start of a topic - reconcile to fit:
+;; Yanking a topic into the start of a topic -- reconcile to fit:
 (let* ((inhibit-field-text-motion t)
 (prefix-len (if (not (match-end 1))
 1
 (- (match-end 1) subj-beg)))
 (subj-depth allout-recent-depth)
 (defun allout-yank-pop (&optional arg)
 "Yank-pop like `allout-yank' when popping to bare outline prefixes.
 Adapts level of popped topics to level of fresh prefix.
-Note - prefix changes to distinctive bullets will stick, if followed
+Note -- prefix changes to distinctive bullets will stick, if followed
 by pops to non-distinctive yanks.  Bug..."
 (interactive "*p")
 (setq this-command 'yank)
 (yank-pop arg)
 \(Works according to setting of `allout-file-xref-bullet')."
 (interactive)
 (if (not allout-file-xref-bullet)
 (error
-"Outline cross references disabled - no `allout-file-xref-bullet'")
+"Outline cross references disabled -- no `allout-file-xref-bullet'")
 (if (not (string= (allout-current-bullet) allout-file-xref-bullet))
 (error "Current heading lacks cross-reference bullet `%s'"
 allout-file-xref-bullet)
 (let ((inhibit-field-text-motion t)
 file-name)
 "Show everything within the current topic.
 With a repeat-count, expose this topic and its siblings."
 (interactive "P")
 (save-excursion
 (if (<= (allout-current-depth) 0)
-	;; Outside any topics - try to get to the first:
+	;; Outside any topics -- try to get to the first:
 	(if (not (allout-next-heading))
 	    (error "No topics")
-	  ;; got to first, outermost topic - set to expose it and siblings:
+	  ;; got to first, outermost topic -- set to expose it and siblings:
-	  (message "Above outermost topic - exposing all.")
+	  (message "Above outermost topic -- exposing all.")
 	  (allout-flag-region (point-min)(point-max) nil))
 (allout-beginning-of-current-line)
 (if (not arg)
 	  (allout-flag-current-subtree nil)
 	(allout-beginning-of-level)
 If optional arg JUST-CLOSE is non-nil, do not close the parent or
 siblings, even if the target topic is already closed."
 (interactive)
 (let* ((from (point))
-(sibs-msg "Top-level topic already closed - closing siblings...")
+(sibs-msg "Top-level topic already closed -- closing siblings...")
 (current-exposed (not (allout-current-topic-collapsed-p t))))
 (cond (current-exposed (allout-flag-current-subtree t))
 (just-close nil)
 ((allout-ascend) (allout-hide-current-subtree))
 (t (goto-char 0)
 - negative numbers force the topic to be closed before opening to the
 absolute value of the number, so all siblings are open only to
 that level.
 - positive numbers open to the relative depth indicated by the
 number, but do not force already opened subtopics to be closed.
-- 0 means to close topic - hide all offspring.
+- 0 means to close topic -- hide all offspring.
 :  - `repeat'
 apply prior element to all siblings at current level, *up to*
 those siblings that would be covered by specs following the `:'
 on the list.  Ie, apply to all topics at level but the last
 ones.  (Only first of multiple colons at same level is
-respected - subsequent ones are discarded.)
+respected -- subsequent ones are discarded.)
 *  - completely opens the topic, including bodies.
 +  - shows all the sub headers, but not the bodies
 -  - exposes the body of the corresponding topic.
 Examples:
 		((eq curr-elem ':)
 		 (setq stay t)
 		 ;; Expand the `repeat' spec to an explicit version,
 		 ;; w.r.t. remaining siblings:
 		 (let ((residue	   ; = # of sibs not covered by remaining spec
-			;; Dang - could be nice to make use of the chart, sigh:
+			;; Dang, could be nice to make use of the chart, sigh:
 			(- (length (allout-chart-siblings))
 			   (length spec))))
 		   (if (< 0 residue)
-		       ;; Some residue - cover it with prev-elem:
+		       ;; Some residue -- cover it with prev-elem:
 		       (setq spec (append (make-list residue prev-elem)
 					  spec)))))))
 	 ((numberp curr-elem)
 	  (if (and (>= 0 curr-elem) (not (allout-hidden-p)))
 	      (save-excursion (allout-hide-current-subtree t)
 	'(if (not (or (allout-goto-prefix-doublechecked)
 		      (allout-next-heading)))
 	     (error "allout-new-exposure: Can't find any outline topics"))
 	(list 'allout-expose-topic (list 'quote spec))))
-;;;_ #7 Systematic outline presentation - copying, printing, flattening
+;;;_ #7 Systematic outline presentation -- copying, printing, flattening
 ;;;_  - Mapping and processing of topics
 ;;;_   ( See also Subtree Charting, in Navigation code.)
 ;;;_   > allout-stringify-flat-index (flat-index)
 (defun allout-stringify-flat-index (flat-index &optional context)
 Optional START and END indicate bounds of region.
 Optional arg, FORMAT, designates an alternate presentation form for
 the prefix:
-list - Present prefix as numeric section.subsection..., starting with
+list -- Present prefix as numeric section.subsection..., starting with
 	section indicated by the list, innermost nesting first.
-`indent' (symbol) -  Convert header prefixes to all white space,
+`indent' (symbol) --  Convert header prefixes to all white space,
 		       except for distinctive bullets.
 The elements of the list produced are lists that represents a topic
 header and body.  The elements of that list are:
 (goto-char start)
 (beginning-of-line)
 ;; Goto initial topic, and register preceeding stuff, if any:
 (if (> (allout-goto-prefix-doublechecked) start)
-	  ;; First topic follows beginning point - register preliminary stuff:
+	  ;; First topic follows beginning point -- register preliminary stuff:
 	  (setq result (list (list 0 "" nil
 				   (buffer-substring start (1- (point)))))))
 (while (and (not done)
 		  (not (eobp))		; Loop until we've covered the region.
 		  (not (> (point) end)))
 	;; Reasses format, if any:
 	(if (and format (listp format))
 	    (cond ((= new-depth depth)
 		   (setq format (cons (1+ (car format))
 					  (cdr format))))
-		  ((> new-depth depth)	; descending - assume by 1:
+		  ((> new-depth depth)	; descending -- assume by 1:
 		   (setq format (cons 1 format)))
 		  (t
 					; Pop the residue:
 		   (while (< new-depth depth)
 		       (setq format (cdr format))
 Apply FUNCTION to exposed portions FROM position TO position in buffer
 FROMBUF to buffer TOBUF.  Sixth optional arg, FORMAT, designates an
 alternate presentation form:
-`flat' - Present prefix as numeric section.subsection..., starting with
+`flat' -- Present prefix as numeric section.subsection..., starting with
 	 section indicated by the START-NUM, innermost nesting first.
-X`flat-indented' - Prefix is like `flat' for first topic at each
+X`flat-indented' -- Prefix is like `flat' for first topic at each
 X		   level, but subsequent topics have only leaf topic
 X		   number, padded with blanks to line up with first.
-`indent' (symbol) -  Convert header prefixes to all white space,
+`indent' (symbol) --  Convert header prefixes to all white space,
 		       except for distinctive bullets.
 Defaults:
 FUNCTION:	`allout-insert-listified'
 FROM:		region start, if region active, else start of buffer
 (if (my-region-active-p)
 	  (setq from (region-beginning) to (region-end))
 	(setq from (point-min) to (point-max))))
 (if frombuf
 (if (not (bufferp frombuf))
-	  ;; Specified but not a buffer - get it:
+	  ;; Specified but not a buffer -- get it:
 	  (let ((got (get-buffer frombuf)))
 	    (if (not got)
 		(error (concat "allout-process-exposed: source buffer "
 			       frombuf
 			       " not found."))
 	      (setq frombuf got))))
-;; not specified - default it:
+;; not specified -- default it:
 (setq frombuf (current-buffer)))
 (if tobuf
 (if (not (bufferp tobuf))
 	  (setq tobuf (get-buffer-create tobuf)))
-;; not specified - default it:
+;; not specified -- default it:
 (setq tobuf (concat "*" (buffer-name frombuf) " exposed*")))
 (if (listp format)
 (nreverse format))
 (let* ((listified
 (goto-char start-pt)))
 ;;;_   > allout-flatten-exposed-to-buffer (&optional arg tobuf)
 (defun allout-flatten-exposed-to-buffer (&optional arg tobuf)
 "Present numeric outline of outline's exposed portions in another buffer.
-The resulting outline is not compatible with outline mode - use
+The resulting outline is not compatible with outline mode -- use
 `allout-copy-exposed-to-buffer' if you want that.
 Use `allout-indented-exposed-to-buffer' for indented presentation.
 With repeat count, copy the exposed portions of only current topic.
 (allout-copy-exposed-to-buffer arg tobuf 'flat))
 ;;;_   > allout-indented-exposed-to-buffer (&optional arg tobuf)
 (defun allout-indented-exposed-to-buffer (&optional arg tobuf)
 "Present indented outline of outline's exposed portions in another buffer.
-The resulting outline is not compatible with outline mode - use
+The resulting outline is not compatible with outline mode -- use
 `allout-copy-exposed-to-buffer' if you want that.
 Use `allout-flatten-exposed-to-buffer' for numeric sectional presentation.
 With repeat count, copy the exposed portions of only current topic.
 not.  When a file with topics pending encryption is saved, topics pending
 encryption are encrypted.  See allout-encrypt-unencrypted-on-saves for
 auto-encryption specifics.
 \*NOTE WELL* that automatic encryption that happens during saves will
-default to symmetric encryption - you must deliberately (re)encrypt key-pair
+default to symmetric encryption -- you must deliberately (re)encrypt key-pair
 encrypted topics if you want them to continue to use the key-pair cipher.
 Level-one topics, with prefix consisting solely of an `*' asterisk, cannot be
 encrypted.  If you want to encrypt the contents of a top-level topic, use
 \\[allout-shift-in] to increase its depth.
 (subtree-end (allout-end-of-subtree))
 (subject-text (buffer-substring-no-properties subtree-beg
 subtree-end))
 (subtree-end-char (char-after (1- subtree-end)))
 (subtree-trailing-char (char-after subtree-end))
-;; kluge - result-text needs to be nil, but we also want to
+;; kluge -- result-text needs to be nil, but we also want to
 ;;         check for the error condition
 (result-text (if (or (string= "" subject-text)
 (string= "\n" subject-text))
 (error "No topic contents to %scrypt"
 (if was-encrypted "de" "en"))
 If DECRYPT is true (default false), then decrypt instead of encrypt.
 FETCH-PASS (default false) forces fresh prompting for the passphrase.
-KEY-TYPE indicates whether to use a 'symmetric or 'keypair cipher.
+KEY-TYPE, either `symmetric' or `keypair', specifies which type
+of cypher to use.
 FOR-KEY is human readable identification of the first of the user's
 eligible secret keys a keypair decryption targets, or else nil.
-Optional RETRIED is for internal use - conveys the number of failed keys
+Optional RETRIED is for internal use -- conveys the number of failed keys
 that have been solicited in sequence leading to this current call.
 Optional PASSPHRASE enables explicit delivery of the decryption passphrase,
 for verification purposes.
-Optional REJECTED is for internal use - conveys the number of
+Optional REJECTED is for internal use -- conveys the number of
 rejections due to matches against
 `allout-encryption-ciphertext-rejection-regexps', as limited by
 `allout-encryption-ciphertext-rejection-ceiling'.
 Returns the resulting string, or nil if the transformation fails."
 (pgg-encrypt-symmetric (point-min) (point-max)
 passphrase)))
 (if status
 (pgg-situate-output (point-min) (point-max))
-;; failed - handle passphrase caching
+;; failed -- handle passphrase caching
 (if verifying
 (throw 'encryption-failed nil)
 (pgg-remove-passphrase-from-cache target-cache-id t)
-(error "Symmetric-cipher %scryption failed - %s"
+(error "Symmetric-cipher %scryption failed -- %s"
 (if decrypt "de" "en")
-"try again with different passphrase."))))
+"try again with different passphrase"))))
 ;; encrypt 'keypair:
 ((not decrypt)
 (setq status
 (setq result-text
 (buffer-substring-no-properties
 1 (- (point-max) (if decrypt 0 1))))
 )
-;; validate result - non-empty
+;; validate result -- non-empty
 (cond ((not result-text)
 (if verifying
 nil
 ;; transform was fruitless, retry w/new passphrase.
 (pgg-remove-passphrase-from-cache target-cache-id t)
 ;; Barf if encryption yields extraordinary control chars:
 ((and (not decrypt)
 (string-match "[\C-a\C-k\C-o-\C-z\C-@]"
 result-text))
 (error (concat "Encryption produced non-armored text, which"
-"conflicts with allout mode - reconfigure!")))
+"conflicts with allout mode -- reconfigure!")))
 ;; valid result and just verifying or non-symmetric:
 ((or verifying (not (equal key-type 'symmetric)))
 (if (or verifying decrypt)
 (pgg-add-passphrase-to-cache target-cache-id
 passphrase t))
 result-text)
-;; valid result and regular symmetric - "register"
+;; valid result and regular symmetric -- "register"
 ;; passphrase with mnemonic aids/cache.
 (t
 (set-buffer allout-buffer)
 (if passphrase
 (pgg-add-passphrase-to-cache target-cache-id
 CACHE-ID is the cache id of the key for the passphrase.
 PROMPT-ID is the id for use when prompting the user.
-KEY-TYPE is either 'symmetric or 'keypair.
+KEY-TYPE is either `symmetric' or `keypair'.
 ALLOUT-BUFFER is the buffer containing the entry being en/decrypted.
 RETRIED is the number of this attempt to obtain this passphrase.
 (setq confirmation (format "%s" got-pass))))
 (if (and (not confirmation)
 (if (yes-or-no-p
 (concat "Passphrase differs from established"
-" - use new one instead? "))
+" -- use new one instead? "))
 ;; deactivate password for subsequent
 ;; confirmation:
 (progn
 (pgg-remove-passphrase-from-cache cache-id t)
 (setq prompt prompt-sans-hint)
 nil)
 t))
 (progn (pgg-remove-passphrase-from-cache cache-id t)
 (error "Wrong passphrase."))))
-;; No verifier string - force confirmation by repetition of
+;; No verifier string -- force confirmation by repetition of
 ;; (new) passphrase:
 ((or fetch-pass (not cached))
 (pgg-remove-passphrase-from-cache cache-id t))))
-;; confirmation vs new input - doing pgg-read-passphrase will do the
+;; confirmation vs new input -- doing pgg-read-passphrase will do the
 ;; right thing, in either case:
 (if (not confirmation)
 (setq confirmation
 (pgg-read-passphrase (concat prompt
 " ... confirm spelling: ")
 cache-id t)))
 (prog1
 (if (equal got-pass confirmation)
 confirmation
 (if (yes-or-no-p (concat "spelling of original and"
-" confirmation differ - retry? "))
+" confirmation differ -- retry? "))
 (progn (setq retried (if retried (1+ retried) 1))
 (pgg-remove-passphrase-from-cache cache-id t)
 ;; recurse to this routine:
 (pgg-read-passphrase prompt-sans-hint cache-id t))
 (pgg-remove-passphrase-from-cache cache-id t)
 ;;;_  > allout-encrypted-key-info (text)
 ;; XXX gpg-specific, alas
 (defun allout-encrypted-key-info (text)
 "Return a pair of the key type and identity of a recipient's secret key.
-The key type is one of 'symmetric or 'keypair.
+The key type is one of `symmetric' or `keypair'.
-If 'keypair, and some of the user's secret keys are among those for which
+If `keypair', and some of the user's secret keys are among those for which
 the message was encoded, return the identity of the first.  Otherwise,
 return nil for the second item of the pair.
 An error is raised if the text is not encrypted."
 (require 'pgg-parse)
 ;;;_  > allout-encrypt-decrypted (&optional except-mark)
 (defun allout-encrypt-decrypted (&optional except-mark)
 "Encrypt topics pending encryption except those containing exemption point.
 EXCEPT-MARK identifies a point whose containing topics should be excluded
-from encryption.  This supports 'except-current mode of
+from encryption.  This supports the `except-current' mode of
 `allout-encrypt-unencrypted-on-saves'.
 If a topic that is currently being edited was encrypted, we return a list
 containing the location of the topic and the location of the cursor just
 before the topic was encrypted.  This can be used, eg, to decrypt the topic
 (save-excursion
 (goto-char (point-min))
 (if (allout-goto-prefix)
 	t
 (allout-open-topic 2)
-(insert (concat "Dummy outline topic header - see"
+(insert (concat "Dummy outline topic header -- see"
 "`allout-mode' docstring: `^Hm'."))
 (allout-adjust-file-variable
 "allout-layout" (or allout-layout '(-1 : 0))))))
 ;;;_   > allout-file-vars-section-data ()
 (defun allout-file-vars-section-data ()
 "Return data identifying the file-vars section, or nil if none.
-Returns list `(beginning-point prefix-string suffix-string)'."
+Returns a list of the form (BEGINNING-POINT PREFIX-STRING SUFFIX-STRING)."
 ;; minimally gleaned from emacs 21.4 files.el hack-local-variables function.
 (let (beg prefix suffix)
 (save-excursion
 (goto-char (point-max))
 (search-backward "\n\^L" (max (- (point-max) 3000) (point-min)) 'move)
 (let ((configvar-value (symbol-value configvar-name))
 got)
 (dolist (sym configvar-value)
 (if (not (boundp sym))
-(if (yes-or-no-p (format "%s entry `%s' is unbound - remove it? "
+(if (yes-or-no-p (format "%s entry `%s' is unbound -- remove it? "
 configvar-name sym))
 (delq sym (symbol-value configvar-name)))
 (push (symbol-value sym) got)))
 (reverse got)))
 ;;;_  : Topics:
 					    got
 					    " ...pick from: "
 					    string
 					    ""))
 		   nil))))
-;; got something out of loop - return it:
+;; got something out of loop -- return it:
 got)
 )
 ;;;_  : Strings:
 ;;;_   > regexp-sans-escapes (string)
 (defun regexp-sans-escapes (regexp &optional successive-backslashes)
 "Return a copy of REGEXP with all character escapes stripped out.
-Representations of actual backslashes - '\\\\\\\\' - are left as a
+Representations of actual backslashes -- '\\\\\\\\' -- are left as a
 single backslash.
 Optional arg SUCCESSIVE-BACKSLASHES is used internally for recursion."
 (if (string= regexp "")
 (move-overlay o (overlay-start o) beg))
 (if (> (overlay-end o) end)
 (move-overlay o end (overlay-end o))
 (delete-overlay o)))))))
 )
-;;;_   > copy-overlay if necessary - xemacs ~ 21.4
+;;;_   > copy-overlay if necessary -- xemacs ~ 21.4
 (if (not (fboundp 'copy-overlay))
 (defun copy-overlay (o)
 "Return a copy of overlay O."
 (let ((o1 (make-overlay (overlay-start o) (overlay-end o)
 ;; FIXME: there's no easy way to find the
 (overlay-buffer o)))
 (props (overlay-properties o)))
 (while props
 (overlay-put o1 (pop props) (pop props)))
 o1)))
-;;;_   > add-to-invisibility-spec if necessary - xemacs ~ 21.4
+;;;_   > add-to-invisibility-spec if necessary -- xemacs ~ 21.4
 (if (not (fboundp 'add-to-invisibility-spec))
 (defun add-to-invisibility-spec (element)
 "Add ELEMENT to `buffer-invisibility-spec'.
 See documentation for `buffer-invisibility-spec' for the kind of elements
 that can be added."
 (if (eq buffer-invisibility-spec t)
 (setq buffer-invisibility-spec (list t)))
 (setq buffer-invisibility-spec
 (cons element buffer-invisibility-spec))))
-;;;_   > remove-from-invisibility-spec if necessary - xemacs ~ 21.4
+;;;_   > remove-from-invisibility-spec if necessary -- xemacs ~ 21.4
 (if (not (fboundp 'remove-from-invisibility-spec))
 (defun remove-from-invisibility-spec (element)
 "Remove ELEMENT from `buffer-invisibility-spec'."
 (if (consp buffer-invisibility-spec)
 (setq buffer-invisibility-spec (delete element
 buffer-invisibility-spec)))))
-;;;_   > move-beginning-of-line if necessary - older emacs, xemacs
+;;;_   > move-beginning-of-line if necessary -- older emacs, xemacs
 (if (not (fboundp 'move-beginning-of-line))
 (defun move-beginning-of-line (arg)
 "Move point to beginning of current line as displayed.
 \(This disregards invisible newlines such as those
 which are part of the text that an image rests on.)
 (previous-property-change (point))
 (previous-char-property-change (point))))
 (skip-chars-backward "^\n"))
 (vertical-motion 0))
 )
-;;;_   > move-end-of-line if necessary - older emacs, xemacs
+;;;_   > move-end-of-line if necessary -- older emacs, xemacs
 (if (not (fboundp 'move-end-of-line))
 (defun move-end-of-line (arg)
 "Move point to end of current line as displayed.
 \(This disregards invisible newlines such as those
 which are part of the text that an image rests on.)
 				"[ \t]*"
 				bullet)))
 (isearch-repeat 'forward)
 (isearch-mode t)))
-;;;_ #11 Unit tests - this should be last item before "Provide"
+;;;_ #11 Unit tests -- this should be last item before "Provide"
 ;;;_  > allout-run-unit-tests ()
 (defun allout-run-unit-tests ()
 "Run the various allout unit tests."
 (message "Running allout tests...")
 (allout-test-resumptions)
 "Completely unbind variable with NAME."
 (if (local-variable-p name) (kill-local-variable name))
 (while (boundp name) (makunbound name)))
 ;;;_   > allout-test-resumptions ()
 (defvar allout-tests-globally-unbound nil
-"Fodder for allout resumptions tests - defvar just for byte compiler.")
+"Fodder for allout resumptions tests -- defvar just for byte compiler.")
 (defvar allout-tests-globally-true nil
-"Fodder for allout resumptions tests - defvar just for byte compiler.")
+"Fodder for allout resumptions tests -- defvar just for byte compiler.")
 (defvar allout-tests-locally-true nil
-"Fodder for allout resumptions tests - defvar just for byte compiler.")
+"Fodder for allout resumptions tests -- defvar just for byte compiler.")
 (defun allout-test-resumptions ()
 "Exercise allout resumptions."
 ;; for each resumption case, we also test that the right local/global
 ;; scopes are affected during resumption effects:
 ;; ensure that prior local value is resumed
 (with-temp-buffer
 (allout-tests-obliterate-variable 'allout-tests-locally-true)
 (set (make-local-variable 'allout-tests-locally-true) t)
 (assert (not (default-boundp 'allout-tests-locally-true))
-nil (concat "Test setup mistake - variable supposed to"
+nil (concat "Test setup mistake -- variable supposed to"
 " not have global binding, but it does."))
 (assert (local-variable-p 'allout-tests-locally-true)
-nil (concat "Test setup mistake - variable supposed to have"
+nil (concat "Test setup mistake -- variable supposed to have"
 " local binding, but it lacks one."))
 (allout-add-resumptions '(allout-tests-locally-true nil))
 (assert (not (default-boundp 'allout-tests-locally-true)))
 (assert (local-variable-p 'allout-tests-locally-true))
 (assert (equal allout-tests-locally-true nil))

Mercurial > emacs

comparison lisp/allout.el @ 79939:f87999df3305