;;; tempo.el --- Flexible template insertion
-;; Copyright (C) 1994 Free Software Foundation, Inc.
+
+;; Copyright (C) 1994, 1995 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.29 $
;; 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., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, 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>
;;; 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'
elements, unless the template function is given a prefix (or a non-nil
argument). If this variable is non-NIL, the behaviour 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
+(defcustom tempo-show-completion-buffer t
"*If non-NIL, show a buffer with possible completions, when only
-a partial completion can be found")
+a partial completion can be found"
+ :type 'boolean
+ :group 'tempo)
-(defvar tempo-leave-completion-buffer nil
+(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.")
+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")
(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
+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.
(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
+This function should return something to be sent to `tempo-insert' if
it recognizes the argument, and NIL otherwise")
(defvar tempo-named-insertions nil
;;; 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 (car il)))
- forms))
- (cadr il))))
-(put 'tempo-dolist 'lisp-indent-function 1)
-
;;
;; tempo-define-template
- 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.
+ - (p PROMPT <NAME> <NOINSERT>) 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 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, 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.
- '> 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 parsed again."
+ - 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)))
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
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)
+ (and (boundp 'zmacs-regions) ; For XEmacs
+ 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
`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 i
+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
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"
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
(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)
+ (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-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
`tempo-match-finder' returns nil, then the results are the same as
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 \" \")))"
HCoop / bpt / emacs.git / blobdiff