;;; tempo.el --- Flexible template insertion
-;; Copyright (C) 1994 Free Software Foundation, Inc.
-;; Author: David K}gedal <davidk@lysator.liu.se >
+;; Copyright (C) 1994, 1995, 2002, 2003, 2004,
+;; 2005 Free Software Foundation, Inc.
+
+;; Author: David K}gedal <davidk@lysator.liu.se>
;; Created: 16 Feb 1994
-;; Version: 1.2.1
+;; K}gedal's last version number: 1.2.4
;; Keywords: extensions, languages, tools
-;; $Revision: 1.5 $
;; This file is part of GNU Emacs.
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs; see the file COPYING. If not, write to
-;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+;; along with GNU Emacs; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
;;; Commentary:
;; a non-nil argument).
;; More flexible templates can be created by including lisp symbols,
-;; which will be evaluated as variables, or lists, which will will be
+;; which will be evaluated as variables, or lists, which will be
;; evaluated as lisp expressions.
;; See the documentation for tempo-define-template for the different
;; The latest tempo.el distribution can be fetched from
;; ftp.lysator.liu.se in the directory /pub/emacs
+;; There is also a WWW page at
+;; http://www.lysator.liu.se/~davidk/elisp/ which has some information
+
;;; Known bugs:
;; If the 'o is the first element in a template, strange things can
;;; Contributors:
-;; These people have given me importand feedback and new ideas for
+;; These people have given me important feedback and new ideas for
;; tempo.el. Thanks.
;; Nelson Minar <nelson@santafe.edu>
-;; Richard Stallman <rms@gnu.ai.mit.edu>
+;; Richard Stallman <rms@gnu.org>
;; Lars Lindberg <Lars.Lindberg@sypro.cap.se>
;; Glen Whitney <Glen.Whitney@math.lsa.umich.edu>
;;; Code:
-;; (provide 'tempo)
-
;;; User options
-(defvar tempo-interactive nil
+(defgroup tempo nil
+ "Flexible template insertion."
+ :prefix "tempo-"
+ :group 'tools)
+
+(defcustom tempo-interactive nil
"*Prompt user for strings in templates.
If this variable is non-nil, `tempo-insert' prompts the
-user for text to insert in the templates")
+user for text to insert in the templates."
+ :type 'boolean
+ :group 'tempo)
-(defvar tempo-insert-region nil
+(defcustom tempo-insert-region nil
"*Automatically insert current region when there is a `r' in the template
-If this variable is NIL, `r' elements will be treated just like `p'
+If this variable is nil, `r' elements will be treated just like `p'
elements, unless the template function is given a prefix (or a non-nil
-argument). If this variable is non-NIL, the behaviour is reversed.
+argument). If this variable is non-nil, the behavior is reversed.
-In Transient Mark mode, this option is unused.")
+In Transient Mark mode, this option is unused."
+ :type 'boolean
+ :group 'tempo)
-(defvar tempo-show-completion-buffer t
- "*If non-NIL, show a buffer with possible completions, when only
-a partial completion can be found")
+(defcustom tempo-show-completion-buffer t
+ "*If non-nil, show a buffer with possible completions, when only
+a partial completion can be found."
+ :type 'boolean
+ :group 'tempo)
-(defvar tempo-leave-completion-buffer nil
- "*If NIL, a completion buffer generated by \\[tempo-complete-tag]
-disappears at the next keypress; otherwise, it remains forever.")
+(defcustom tempo-leave-completion-buffer nil
+ "*If nil, a completion buffer generated by \\[tempo-complete-tag]
+disappears at the next keypress; otherwise, it remains forever."
+ :type 'boolean
+ :group 'tempo)
;;; Internal variables
(defvar tempo-insert-string-functions nil
"List of functions to run when inserting a string.
-Each function is called with a single arg, STRING." )
+Each function is called with a single arg, STRING and should return
+another string. This could be used for making all strings upcase by
+setting it to '(upcase), for example.")
(defvar tempo-tags nil
- "An association list with tags and corresponding templates")
+ "An association list with tags and corresponding templates.")
(defvar tempo-local-tags '((tempo-tags . nil))
"A list of locally installed tag completion lists.
It is a association list where the car of every element is a symbol
-whose varable value is a template list. The cdr part, if non-nil, is a
-function or a regexp that defines the string to match. See the
+whose variable value is a template list. The cdr part, if non-nil,
+is a function or a regexp that defines the string to match. See the
documentation for the function `tempo-complete-tag' for more info.
`tempo-tags' is always in the last position in this list.")
(defvar tempo-marks nil
"A list of marks to jump to with `\\[tempo-forward-mark]' and `\\[tempo-backward-mark]'.")
-(defvar tempo-match-finder "\\b\\([^\\b]+\\)\\="
+(defvar tempo-match-finder "\\b\\([[:word:]]+\\)\\="
"The regexp or function used to find the string to match against tags.
-If `tempo-match-finder is a string, it should contain a regular
-expression with at least one \\( \\) pair. When searching for tags,
+If `tempo-match-finder' is a string, it should contain a regular
+expression with at least one \\( \\) pair. When searching for tags,
`tempo-complete-tag' calls `re-search-backward' with this string, and
the string between the first \\( and \\) is used for matching against
each string in the tag list. If one is found, the whole text between
the first \\( and the point is replaced with the inserted template.
-You will probably want to include \\ \= at the end of the regexp to
+You will probably want to include \\=\\= at the end of the regexp to
make sure that the string is matched only against text adjacent to the
point.
(defvar tempo-user-elements nil
"Element handlers for user-defined elements.
A list of symbols which are bound to functions that take one argument.
-This function should return somthing to be sent to `tempo-insert' if
-it recognizes the argument, and NIL otherwise")
+This function should return something to be sent to `tempo-insert' if
+it recognizes the argument, and nil otherwise.")
(defvar tempo-named-insertions nil
- "Temporary storage for named insertions")
+ "Temporary storage for named insertions.")
(defvar tempo-region-start (make-marker)
- "Region start when inserting around the region")
+ "Region start when inserting around the region.")
(defvar tempo-region-stop (make-marker)
- "Region stop when inserting around the region")
+ "Region stop when inserting around the region.")
;; Make some variables local to every buffer
;;; Functions
-;;; First some useful functions and macros
-
-(defun tempo-mapc (fun lst)
- (if (null lst) nil
- (funcall fun (car lst))
- (tempo-mapc fun (cdr lst))))
-
-(defmacro tempo-dolist (il &rest forms)
- (let ((i (car il))
- (l (car (cdr il))))
- (list 'tempo-mapc
- (list 'function (append (list 'lambda
- (list i))
- forms))
- l)))
-(put 'tempo-dolist 'lisp-indent-function 1)
-
;;
;; tempo-define-template
list of elements in the template, TAG is the tag used for completion,
DOCUMENTATION is the documentation string for the insertion command
created, and TAGLIST (a symbol) is the tag list that TAG (if provided)
-should be added to). If TAGLIST is nil and TAG is non-nil, TAG is
-added to `tempo-tags'
+should be added to. If TAGLIST is nil and TAG is non-nil, TAG is
+added to `tempo-tags'.
The elements in ELEMENTS can be of several types:
- - A string. It is sent to the hooks in `tempo-insert-string-functions',
+ - A string: It is sent to the hooks in `tempo-insert-string-functions',
and the result is inserted.
- - The symbol 'p. This position is saved in `tempo-marks'.
- - The symbol 'r. If `tempo-insert' is called with ON-REGION non-nil
- the current region is placed here. Otherwise it works like 'p.
- - (p PROMPT <NAME>) If `tempo-interactive' is non-nil, the user is
- prompted in the minbuffer with PROMPT for a string to be inserted.
- If the optional parameter NAME is non-nil, the text is saved for
- later insertion with the `s' tag.
- If `tempo-interactive' is nil, it works like 'p.
- - (r PROMPT) like the previous, but if `tempo-interactive' is nil
- and `tempo-insert' is called with ON-REGION non-nil, the current
- region is placed here. This usually happens when you call the
- template function with a prefix argument.
- - (s NAME) Inserts text previously read with the (p ..) construct.
- Finds the insertion saved under NAME and inserts it. Acts like 'p
+ - The symbol `p': This position is saved in `tempo-marks'.
+ - The symbol `r': If `tempo-insert' is called with ON-REGION non-nil
+ the current region is placed here. Otherwise it works like `p'.
+ - (p PROMPT <NAME> <NOINSERT>): If `tempo-interactive' is non-nil, the
+ user is prompted in the minibuffer with PROMPT for a string to be
+ inserted. If the optional parameter NAME is non-nil, the text is
+ saved for later insertion with the `s' tag. If there already is
+ something saved under NAME that value is used instead and no
+ prompting is made. If NOINSERT is provided and non-nil, nothing is
+ inserted, but text is still saved when a NAME is provided. For
+ clarity, the symbol `noinsert' should be used as argument.
+ - (P PROMPT <NAME> <NOINSERT>): Works just like the previous tag, but
+ forces `tempo-interactive' to be true.
+ - (r PROMPT <NAME> <NOINSERT>): Like the previous tag, but if
+ `tempo-interactive' is nil and `tempo-insert' is called with
+ ON-REGION non-nil, the current region is placed here. This usually
+ happens when you call the template function with a prefix argument.
+ - (s NAME): Inserts text previously read with the (p ..) construct.
+ Finds the insertion saved under NAME and inserts it. Acts like `p'
if tempo-interactive is nil.
- - '& If there is only whitespace between the line start and point,
- nothing happens. Otherwise a newline is inserted.
- - '% If there is only whitespace between point and end-of-line
- nothing happens. Otherwise a newline is inserted.
- - 'n inserts a newline.
- - '> The line is indented using `indent-according-to-mode'. Note that
- you often should place this item after the text you want on the
- line.
- - 'n> Inserts a newline and indents line.
- - 'o Like '% but leaves the point before the newline.
- - nil. It is ignored.
- - Anything else. It is evaluated and the result is parsed again."
-
+ - `&': If there is only whitespace between the line start and point,
+ nothing happens. Otherwise a newline is inserted.
+ - `%': If there is only whitespace between point and end of line,
+ nothing happens. Otherwise a newline is inserted.
+ - `n': Inserts a newline.
+ - `>': The line is indented using `indent-according-to-mode'. Note
+ that you often should place this item after the text you want on
+ the line.
+ - `r>': Like `r', but it also indents the region.
+ - `n>': Inserts a newline and indents line.
+ - `o': Like `%' but leaves the point before the newline.
+ - nil: It is ignored.
+ - Anything else: It is evaluated and the result is treated as an
+ element to be inserted. One additional tag is useful for these
+ cases. If an expression returns a list '(l foo bar), the elements
+ after `l' will be inserted according to the usual rules. This makes
+ it possible to return several elements from one expression."
(let* ((template-name (intern (concat "tempo-template-"
name)))
(command-name template-name))
(set template-name elements)
(fset command-name (list 'lambda (list '&optional 'arg)
- (or documentation
+ (or documentation
(concat "Insert a " name "."))
(list 'interactive "*P")
(list 'tempo-insert-template (list 'quote
(defun tempo-insert-template (template on-region)
"Insert a template.
TEMPLATE is the template to be inserted. If ON-REGION is non-nil the
-`r' elements are replaced with the current region. In Transient Mark
+`r' elements are replaced with the current region. In Transient Mark
mode, ON-REGION is ignored and assumed true if the region is active."
- (if (and (boundp 'transient-mark-mode)
- transient-mark-mode
- mark-active)
- (setq on-region t))
- (and on-region
- (set-marker tempo-region-start (min (mark) (point)))
- (set-marker tempo-region-stop (max (mark) (point))))
- (if on-region
- (goto-char tempo-region-start))
- (save-excursion
- (tempo-insert-mark (point-marker))
- (mapcar (function (lambda (elt)
- (tempo-insert elt on-region)))
- (symbol-value template))
- (tempo-insert-mark (point-marker)))
- (tempo-forward-mark)
- (tempo-forget-insertions)
- (and (boundp 'transient-mark-mode)
- transient-mark-mode
- (deactivate-mark)))
+ (unwind-protect
+ (progn
+ (if (or (and (boundp 'transient-mark-mode) ; For Emacs
+ transient-mark-mode
+ mark-active)
+ (if (featurep 'xemacs)
+ (and zmacs-regions (mark))))
+ (setq on-region t))
+ (and on-region
+ (set-marker tempo-region-start (min (mark) (point)))
+ (set-marker tempo-region-stop (max (mark) (point))))
+ (if on-region
+ (goto-char tempo-region-start))
+ (save-excursion
+ (tempo-insert-mark (point-marker))
+ (mapcar (function (lambda (elt)
+ (tempo-insert elt on-region)))
+ (symbol-value template))
+ (tempo-insert-mark (point-marker)))
+ (tempo-forward-mark))
+ (tempo-forget-insertions)
+ ;; Should I check for zmacs here too???
+ (and (boundp 'transient-mark-mode)
+ transient-mark-mode
+ (deactivate-mark))))
;;;
;;; tempo-insert
See documentation for `tempo-define-template' for the kind of elements
possible."
(cond ((stringp element) (tempo-process-and-insert-string element))
- ((and (consp element) (eq (car element) 'p))
- (tempo-insert-prompt (cdr element)))
- ((and (consp element) (eq (car element) 'P))
- (let ((tempo-interactive t))
- (tempo-insert-prompt (cdr element))))
- ((and (consp element) (eq (car element) 'r))
- (if on-region
- (goto-char tempo-region-stop)
- (tempo-insert-prompt (cdr element))))
- ((and (consp element) (eq (car element) 's))
- (tempo-insert-named (car (cdr element))))
- ((and (consp element) (eq (car element) 'l))
- (mapcar (function (lambda (elt) (tempo-insert elt on-region)))
- (cdr element)))
+ ((and (consp element)
+ (eq (car element) 'p)) (tempo-insert-prompt-compat
+ (cdr element)))
+ ((and (consp element)
+ (eq (car element) 'P)) (let ((tempo-interactive t))
+ (tempo-insert-prompt-compat
+ (cdr element))))
+;;; ((and (consp element)
+;;; (eq (car element) 'v)) (tempo-save-named
+;;; (nth 1 element)
+;;; nil
+;;; (nth 2 element)))
+ ((and (consp element)
+ (eq (car element) 'r)) (if on-region
+ (goto-char tempo-region-stop)
+ (tempo-insert-prompt-compat
+ (cdr element))))
+ ((and (consp element)
+ (eq (car element) 's)) (tempo-insert-named (car (cdr element))))
+ ((and (consp element)
+ (eq (car element) 'l)) (mapcar (function
+ (lambda (elt)
+ (tempo-insert elt on-region)))
+ (cdr element)))
((eq element 'p) (tempo-insert-mark (point-marker)))
((eq element 'r) (if on-region
(goto-char tempo-region-stop)
;;;
;;; tempo-insert-prompt
-(defun tempo-insert-prompt (prompt)
+(defun tempo-insert-prompt-compat (prompt)
+ "Compatibility hack for `tempo-insert-prompt'.
+PROMPT can be either a prompt string, or a list of arguments to
+`tempo-insert-prompt', or nil."
+ (if (consp prompt) ; not nil either
+ (apply 'tempo-insert-prompt prompt)
+ (tempo-insert-prompt prompt)))
+
+(defun tempo-insert-prompt (prompt &optional save-name no-insert)
"Prompt for a text string and insert it in the current buffer.
If the variable `tempo-interactive' is non-nil the user is prompted
for a string in the minibuffer, which is then inserted in the current
-buffer. If `tempo-interactive' is nil, the current point is placed on
+buffer. If `tempo-interactive' is nil, the current point is placed on
`tempo-mark'.
-PROMPT is the prompt string or a list containing the prompt string and
-a name to save the inserted text under."
- (if tempo-interactive
- (let ((prompt-string (if (listp prompt)
- (car prompt)
- prompt))
- (save-name (and (listp prompt) (nth 1 prompt)))
- inserted-text)
-
- (progn
- (setq inserted-text (read-string prompt-string))
- (insert inserted-text)
- (if save-name
- (tempo-remember-insertion save-name inserted-text))))
- (tempo-insert-mark (point-marker))))
+PROMPT is the prompt string, SAVE-NAME is a name to save the inserted
+text under. If the optional argument NO-INSERT is non-nil, no text is
+inserted. This can be useful when there is a SAVE-NAME.
+
+If there already is a value for SAVE-NAME, it is used and the user is
+never prompted."
+ (let (insertion
+ (previous (and save-name
+ (tempo-lookup-named save-name))))
+ (cond
+ ;; Insert previous value, unless no-insert is non-nil
+ ((and previous
+ (not no-insert))
+ (tempo-insert-named save-name)) ; A double lookup here, but who
+ ; cares
+ ;; If no-insert is non-nil, don't insert the previous value. Just
+ ;; keep it
+ (previous
+ nil)
+ ;; No previous value. Prompt or insert mark
+ (tempo-interactive
+ (if (not (stringp prompt))
+ (error "tempo: The prompt (%s) is not a string" prompt))
+ (setq insertion (read-string prompt))
+ (or no-insert
+ (insert insertion))
+ (if save-name
+ (tempo-save-named save-name insertion)))
+ (t
+ (tempo-insert-mark (point-marker))))))
;;;
;;; tempo-is-user-element
(defun tempo-is-user-element (element)
- "Tries all the user-defined element handlers in
-`tempo-user-elements'"
+ "Tries all the user-defined element handlers in `tempo-user-elements'."
;; Sigh... I need (some list)
(catch 'found
(mapcar (function (lambda (handler)
tempo-user-elements)
(throw 'found nil)))
-;;;
-;;; tempo-remember-insertion
-
-(defun tempo-remember-insertion (save-name string)
- "Save the text in STRING under the name SAVE-NAME for later retrieval."
- (setq tempo-named-insertions (cons (cons save-name string)
- tempo-named-insertions)))
-
;;;
;;; tempo-forget-insertions
"Forget all the saved named insertions."
(setq tempo-named-insertions nil))
+;;;
+;;; tempo-save-named
+
+(defun tempo-save-named (name data) ; Had an optional prompt for 'v
+ "Save some data for later insertion
+The contents of DATA is saved under the name NAME.
+
+The data can later be retrieved with `tempo-lookup-named'.
+
+This function returns nil, so it can be used in a template without
+inserting anything."
+ (setq tempo-named-insertions
+ (cons (cons name data)
+ tempo-named-insertions))
+ nil)
+
+;;;
+;;; tempo-lookup-named
+
+(defun tempo-lookup-named (name)
+ "Lookup some saved data under the name NAME.
+Returns the data if NAME was found, and nil otherwise."
+ (cdr (assq name tempo-named-insertions)))
+
;;;
;;; tempo-insert-named
(defun tempo-insert-named (name)
"Insert the previous insertion saved under a named specified in NAME.
-If there is no such name saved, a tempo mark is inserted."
- (let* ((insertion (cdr (assq name tempo-named-insertions))))
- (if insertion
- (insert insertion)
- (tempo-insert-mark (point-marker)))))
+If there is no such name saved, a tempo mark is inserted.
+
+Note that if the data is a string, it will not be run through the string
+processor."
+ (let* ((insertion (tempo-lookup-named name)))
+ (cond ((null insertion)
+ (tempo-insert-mark (point-marker)))
+ ((stringp insertion)
+ (insert insertion))
+ (t
+ (tempo-insert insertion nil)))))
+
;;;
;;; tempo-process-and-insert-string
(setq string
(funcall tempo-insert-string-functions string)))
((listp tempo-insert-string-functions)
- (tempo-dolist (fn tempo-insert-string-functions)
+ (dolist (fn tempo-insert-string-functions)
(setq string (funcall fn string))))
(t
(error "Bogus value in tempo-insert-string-functions: %s"
;;; tempo-insert-mark
(defun tempo-insert-mark (mark)
- "Insert a mark `tempo-marks' while keeping it sorted"
+ "Insert a mark `tempo-marks' while keeping it sorted."
(cond ((null tempo-marks) (setq tempo-marks (list mark)))
((< mark (car tempo-marks)) (setq tempo-marks (cons mark tempo-marks)))
(t (let ((lp tempo-marks))
(setq lp (cdr lp)))
(if (not (= mark (car lp)))
(setcdr lp (cons mark (cdr lp))))))))
-
+
;;;
;;; tempo-forward-mark
last))))
(if prev-mark
(goto-char prev-mark))))
-
+
;;;
;;; tempo-add-tag
TAG-LIST is a symbol whose variable value is a tag list created with
`tempo-add-tag'.
-COMPLETION-FUNCTION is an obsolete option for specifyingis an optional
+COMPLETION-FUNCTION is an obsolete option for specifying an optional
function or string that is used by `\\[tempo-complete-tag]' to find a
-string to match the tag against. It has the same definition as the
-variable `tempo-match-finder'. In this version, supplying a
+string to match the tag against. It has the same definition as the
+variable `tempo-match-finder'. In this version, supplying a
COMPLETION-FUNCTION just sets `tempo-match-finder' locally."
(let ((old (assq tag-list tempo-local-tags)))
(if old
(defun tempo-build-collection ()
"Build a collection of all the tags and return it.
-If `tempo-dirty-collection' is NIL, the old collection is reused."
- (setq tempo-dirty nil)
- (or (and (not tempo-dirty-collection)
- tempo-collection)
- (setq tempo-collection
- (apply (function append)
- (mapcar (function (lambda (tag-list)
+If `tempo-dirty-collection' is nil, the old collection is reused."
+ (prog1
+ (or (and (not tempo-dirty-collection)
+ tempo-collection)
+ (setq tempo-collection
+ (apply (function append)
+ (mapcar (function (lambda (tag-list)
; If the format for
; tempo-local-tags changes,
; change this
- (eval (car tag-list))))
- tempo-local-tags)))))
+ (eval (car tag-list))))
+ tempo-local-tags))))
+ (setq tempo-dirty-collection nil)))
;;;
;;; tempo-find-match-string
(defun tempo-find-match-string (finder)
"Find a string to be matched against a tag list.
-FINDER is a function or a string. Returns (STRING . POS), or nil
+FINDER is a function or a string. Returns (STRING . POS), or nil
if no reasonable string is found."
(cond ((stringp finder)
(let (successful)
(defun tempo-complete-tag (&optional silent)
"Look for a tag and expand it.
All the tags in the tag lists in `tempo-local-tags'
-(this includes `tempo-tags') are searched for a match for the text
+\(this includes `tempo-tags') are searched for a match for the text
before the point. The way the string to match for is determined can
-be altered with the variable `tempo-match-finder'. If
+be altered with the variable `tempo-match-finder'. If
`tempo-match-finder' returns nil, then the results are the same as
no match at all.
place of the matching string.
If a partial completion or no match at all is found, and SILENT is
-non-NIL, the function will give a signal.
+non-nil, the function will give a signal.
If a partial completion is found and `tempo-show-completion-buffer' is
-non-NIL, a buffer containing possible completions is displayed."
+non-nil, a buffer containing possible completions is displayed."
;; This function may look like a hack, but this is how I want it to
;; work.
(if tempo-leave-completion-buffer
(with-output-to-temp-buffer "*Completions*"
(display-completion-list
- (all-completions string tag-list)))
+ (all-completions string tag-list)
+ string))
(save-window-excursion
(with-output-to-temp-buffer "*Completions*"
(display-completion-list
- (all-completions string tag-list)))
+ (all-completions string tag-list)
+ string))
(sit-for 32767))))
;;;
This could as an example be used in a command that is bound to the
space bar, and looks something like this:
-(defun tempo-space ()
+\(defun tempo-space ()
(interactive \"*\")
(or (tempo-expand-if-complete)
(insert \" \")))"
(provide 'tempo)
+;;; arch-tag: b3c0ee36-db3b-47bc-875f-091b4e27a063
;;; tempo.el ends here
HCoop / bpt / emacs.git / blobdiff