new version
[emacs.git] / lisp / expand.el
blob51a1213989735da17754e3e71b7700d50bf0fb28
1 ;;; expand.el --- make abbreviations more usable.
3 ;; Copyright (C) 1995, 1996 Free Software Foundation, Inc.
5 ;; Author: Frederic Lepied <Frederic.Lepied@sugix.frmug.org>
6 ;; Maintainer: Frederic Lepied <Frederic.Lepied@sugix.frmug.org>
7 ;; Keywords: abbrev
9 ;; This file is part of GNU Emacs.
11 ;; GNU Emacs is free software; you can redistribute it and/or modify
12 ;; it under the terms of the GNU General Public License as published by
13 ;; the Free Software Foundation; either version 2, or (at your option)
14 ;; any later version.
16 ;; GNU Emacs is distributed in the hope that it will be useful,
17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 ;; GNU General Public License for more details.
21 ;; You should have received a copy of the GNU General Public License
22 ;; along with GNU Emacs; see the file COPYING. If not, write to the
23 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
24 ;; Boston, MA 02111-1307, USA.
26 ;;; Commentary:
28 ;; This package defines abbrevs which expand into structured constructs
29 ;; for certain languages. The construct is indented for you,
30 ;; and contains slots for you to fill in other text.
32 ;; These abbrevs expand only at the end of a line and when not in a comment
33 ;; or a string.
35 ;; Look at the Sample: section for emacs-lisp, perl and c expand lists.
36 ;; For example for c-mode, you could declare your abbrev table with :
38 ;; (defconst c-expand-list
39 ;; '(("if" "if () {\n \n} else {\n \n}" (5 10 21))
40 ;; ("ifn" "if () {}" (5 8))
41 ;; ("uns" "unsigned ")
42 ;; ("for" "for(; ; ) {\n\n}" (5 7 9 13))
43 ;; ("switch" "switch () {\n\n}" (9 13))
44 ;; ("case" "case :\n\nbreak;\n" (6 8 16))
45 ;; ("do" "do {\n\n} while ();" (6 16))
46 ;; ("while" "while () {\n\n}" (8 12))
47 ;; ("default" "default:\n\nbreak;" 10)
48 ;; ("main" "int\nmain(int argc, char * argv[])\n{\n\n}\n" 37))
49 ;; "Expansions for C mode")
50 ;;
51 ;; and enter Abbrev mode with the following hook :
53 ;; (add-hook 'c-mode-hook (function (lambda ()
54 ;; (expand-add-abbrevs c-mode-abbrev-table c-expand-list)
55 ;; (abbrev-mode))))
57 ;; you can also init some post-process hooks :
59 ;; (add-hook 'expand-load-hook
60 ;; (function
61 ;; (lambda ()
62 ;; (add-hook 'expand-expand-hook 'indent-according-to-mode)
63 ;; (add-hook 'expand-jump-hook 'indent-according-to-mode))))
65 ;; Remarks:
67 ;; Many thanks to Heddy Boubaker <boubaker@cenatls.cena.dgac.fr>,
68 ;; Jerome Santini <santini@chambord.univ-orleans.fr>,
69 ;; Jari Aalto <jaalto@tre.tele.nokia.fi>.
71 ;; Please send me a word to give me your feeling about this feature or
72 ;; to explain me how you use it (your expansions table for example) using
73 ;; the function expand-submit-report.
75 ;;; Constants:
77 (defvar expand-load-hook nil
78 "Hooks run when `expand.el' is loaded.")
80 (defvar expand-expand-hook nil
81 "Hooks run when an abbrev made by `expand-add-abbrevs' is expanded.")
83 (defvar expand-jump-hook nil
84 "Hooks run by `expand-jump-to-previous-slot' and `expand-jump-to-next-slot'.")
86 ;;; Samples:
88 (define-skeleton expand-c-for-skeleton "For loop skeleton"
89 "Loop var: "
90 "for(" str _ @ "=0; " str @ "; " str @ ") {" \n
91 @ _ \n
92 "}" >
95 (defconst expand-c-sample-expand-list
96 '(("if" "if () {\n \n} else {\n \n}" (5 10 21))
97 ("ifn" "if () {}" (5 8))
98 ("uns" "unsigned ")
99 ("for" expand-c-for-skeleton)
100 ("switch" "switch () {\n\n}" (9 13))
101 ("case" "case :\n\nbreak;\n" (6 8 16))
102 ("do" "do {\n\n} while ();" (6 16))
103 ("while" "while () {\n\n}" (8 12))
104 ("default" "default:\n\nbreak;" 10)
105 ("main" "int\nmain(int argc, char * argv[])\n{\n\n}\n" 37))
106 "Expansions for C mode. See `expand-add-abbrevs'.")
108 ;; lisp example from Jari Aalto <jaalto@tre.tele.nokia.fi>
109 (defconst expand-sample-lisp-mode-expand-list
110 (list
111 (list
112 "defu"
113 (concat
114 "(defun ()\n"
115 " \"\"\n"
116 " (interactive)\n"
117 " (let* (\n"
118 " )\n"
119 " \n"
120 " ))")
121 (list 8 11 16 32 43 59))
123 (list
124 "defs"
125 (concat
126 "(defsubst ()\n"
127 " \"\"\n"
128 " (interactive)\n"
129 " )")
130 (list 11 14 19 23 39))
132 (list
133 "defm"
134 (concat
135 "(defmacro ()\n"
136 " \"\"\n"
137 " (` \n"
138 " ))")
139 (list 11 13 18 25))
141 (list
142 "defa"
143 (concat
144 "(defadvice (around act)\n"
145 " \"\"\n"
146 " \n"
147 " )")
148 (list 12 22 32 36))
150 (list
151 "defc"
152 "(defconst nil\n \"\")\n"
153 (list 11 13 20))
155 (list
156 "defv"
157 "(defvar nil\n \"\")\n"
158 (list 9 11 18))
160 (list
161 "let"
162 "(let* (\n)\n "
163 (list 8 13))
165 (list
166 "sav"
167 "(save-excursion\n \n)"
168 (list 18))
170 (list
171 "aut"
172 "(autoload ' \"\" t t)\n"
173 (list 12 14))
176 "Expansions for Lisp mode. See `expand-add-abbrevs'.")
178 ;; perl example from Jari Aalto <jaalto@tre.tele.nokia.fi>
179 (defconst expand-sample-perl-mode-expand-list
180 (list
181 (list
182 ;; This is default perl4 subroutine template
184 "sub"
185 (concat
186 "#" (make-string 70 ?-) "\n"
187 "sub {\n"
188 " # DESCRIPTION\n"
189 " # \n"
190 " # \n"
191 " # INPUT\n"
192 " # \n"
193 " # \n"
194 " # RETURN\n"
195 " # \n"
196 "\n"
197 " local( $f ) = \"$lib.\";\n" ;; Function name AFTER period
198 " local() = @_;\n" ;; func arguments here
199 " \n"
200 " \n}\n"
202 (list 77 88 120 146 159 176))
204 (list
205 "for" ; foreach
206 (concat
207 "for ( )\n"
208 "{\n\n\}"
210 (list 7 12))
212 (list
213 "whi" ; foreach
214 (concat
215 "while ( )\n"
216 "{\n\n\}"
218 (list 9 15))
221 ;; The normal "if" can be used like
222 ;; print $F "xxxxxx" if defined @arr;
224 (list
225 "iff"
226 (concat
227 "if ( )\n"
228 "{\n\n\}"
230 (list 6 12))
232 (list "loc" "local( $ );" (list 9))
233 (list "my" "my( $ );" (list 6))
234 (list "ope" "open(,\"\")\t|| die \"$f: Can't open [$]\";" (list 6 8 36))
235 (list "clo" "close ;" 7)
236 (list "def" "defined " (list 9))
237 (list "und" "undef ;" (list 7))
239 ;; There is no ending colon, because they can be in statement
240 ;; defined $REXP_NOT_NEW && (print "xxxxx" );
242 (list "pr" "print " 7)
243 (list "pf" "printf " 8)
246 (list "gre" "grep( //, );" (list 8 11))
247 (list "pus" "push( , );" (list 7 9))
248 (list "joi" "join( '', );" (list 7 11))
249 (list "rtu" "return ;" (list 8))
252 "Expansions for Perl mode. See `expand-add-abbrevs'.")
254 ;;; Code:
256 ;;;###autoload
257 (defun expand-add-abbrevs (table abbrevs)
258 "Add a list of abbrev to abbrev table TABLE.
259 ABBREVS is a list of abbrev definitions; each abbrev description entry
260 has the form (ABBREV EXPANSION ARG).
262 ABBREV is the abbreviation to replace.
264 EXPANSION is the replacement string or a function which will make the
265 expansion. For example you, could use the DMacros or skeleton packages
266 to generate such functions.
268 ARG is an optional argument which can be a number or a list of
269 numbers. If ARG is a number, point is placed ARG chars from the
270 beginning of the expanded text.
272 If ARG is a list of numbers, point is placed according to the first
273 member of the list, but you can visit the other specified positions
274 cyclicaly with the functions `expand-jump-to-previous-slot' and
275 `expand-jump-to-next-slot'.
277 If ARG is omitted, point is placed at the end of the expanded text."
279 (if (null abbrevs)
280 table
281 (expand-add-abbrev table (nth 0 (car abbrevs)) (nth 1 (car abbrevs))
282 (nth 2 (car abbrevs)))
283 (expand-add-abbrevs table (cdr abbrevs))))
285 (defvar expand-list nil "Temporary variable used by the Expand package.")
287 (defvar expand-pos nil
288 "If non nil, stores a vector containing markers to positions defined by the last expansion.
289 This variable is local to a buffer.")
290 (make-variable-buffer-local 'expand-pos)
292 (defvar expand-index 0
293 "Index of the last marker used in `expand-pos'.
294 This variable is local to a buffer.")
295 (make-variable-buffer-local 'expand-index)
297 (defvar expand-point nil
298 "End of the expanded region.
299 This variable is local to a buffer.")
300 (make-variable-buffer-local 'expand-point)
302 (defun expand-add-abbrev (table abbrev expansion arg)
303 "Add one abbreviation and provide the hook to move to the specified positions."
304 (let* ((string-exp (if (and (symbolp expansion) (fboundp expansion))
306 expansion))
307 (position (if (and arg string-exp)
308 (if (listp arg)
309 (- (length expansion) (1- (car arg)))
310 (- (length expansion) (1- arg)))
311 0)))
312 (define-abbrev
313 table
314 abbrev
315 (vector string-exp
316 position
317 (if (and (listp arg)
318 (not (null arg)))
319 (cons (length string-exp) arg)
320 nil)
321 (if (and (symbolp expansion) (fboundp expansion))
322 expansion
323 nil)
325 'expand-abbrev-hook)))
327 (put 'expand-abbrev-hook 'no-self-insert t)
328 (defun expand-abbrev-hook ()
329 "Abbrev hook used to do the expansion job of expand abbrevs.
330 See `expand-add-abbrevs'."
331 ;; Expand only at the end of a line if we are near a word that has
332 ;; an abbrev built from expand-add-abbrev.
333 (if (and (eolp)
334 (not (expand-in-literal)))
335 (let ((p (point)))
336 (setq expand-point nil)
337 ;; don't expand if the preceding char isn't a word constituent
338 (if (and (eq (char-syntax (preceding-char))
340 (expand-do-expansion))
341 (progn
342 ;; expand-point tells us if we have inserted the text
343 ;; ourself or if it is the hook which has done the job.
344 (if expand-point
345 (progn
346 (if (vectorp expand-list)
347 (expand-build-marks expand-point))
348 (indent-region p expand-point nil))
349 ;; an outside function can set expand-list to a list of
350 ;; markers in reverse order.
351 (if (listp expand-list)
352 (setq expand-index 0
353 expand-pos (expand-list-to-markers expand-list)
354 expand-list nil)))
355 (run-hooks 'expand-expand-hook)
356 t))))
359 (defun expand-do-expansion ()
360 (delete-backward-char (length last-abbrev-text))
361 (let* ((vect (symbol-value last-abbrev))
362 (text (aref vect 0))
363 (position (aref vect 1))
364 (jump-args (aref vect 2))
365 (hook (aref vect 3)))
366 (cond (text
367 (insert text)
368 (setq expand-point (point))))
369 (if jump-args
370 (funcall 'expand-build-list (car jump-args) (cdr jump-args)))
371 (if position
372 (backward-char position))
373 (if hook
374 (funcall hook))
378 (defun expand-abbrev-from-expand (word)
379 "Test if an abbrev has a hook."
381 (and (intern-soft word local-abbrev-table)
382 (symbol-function (intern-soft word local-abbrev-table)))
383 (and (intern-soft word global-abbrev-table)
384 (symbol-function (intern-soft word global-abbrev-table)))))
386 (defun expand-previous-word ()
387 "Return the previous word."
388 (save-excursion
389 (let ((p (point)))
390 (backward-word 1)
391 (buffer-substring p (point)))))
393 ;;;###autoload
394 (defun expand-jump-to-previous-slot ()
395 "Move the cursor to the previous slot in the last abbrev expansion.
396 This is used only in conjunction with `expand-add-abbrevs'."
397 (interactive)
398 (if expand-pos
399 (progn
400 (setq expand-index (1- expand-index))
401 (if (< expand-index 0)
402 (setq expand-index (1- (length expand-pos))))
403 (goto-char (aref expand-pos expand-index))
404 (run-hooks 'expand-jump-hook))))
406 ;;;###autoload
407 (defun expand-jump-to-next-slot ()
408 "Move the cursor to the next slot in the last abbrev expansion.
409 This is used only in conjunction with `expand-add-abbrevs'."
410 (interactive)
411 (if expand-pos
412 (progn
413 (setq expand-index (1+ expand-index))
414 (if (>= expand-index (length expand-pos))
415 (setq expand-index 0))
416 (goto-char (aref expand-pos expand-index))
417 (run-hooks 'expand-jump-hook))))
419 ;;;###autoload (define-key ctl-x-map "ap" 'expand-jump-to-previous-slot)
420 ;;;###autoload (define-key ctl-x-map "an" 'expand-jump-to-next-slot)
422 (defun expand-build-list (len l)
423 "Build a vector of offset positions from the list of positions."
424 (expand-clear-markers)
425 (setq expand-list (vconcat l))
426 (let ((i 0)
427 (lenlist (length expand-list)))
428 (while (< i lenlist)
429 (aset expand-list i (- len (1- (aref expand-list i))))
430 (setq i (1+ i))))
433 (defun expand-build-marks (p)
434 "Transform the offsets vector into a marker vector."
435 (if expand-list
436 (progn
437 (setq expand-index 0)
438 (setq expand-pos (make-vector (length expand-list) nil))
439 (let ((i (1- (length expand-list))))
440 (while (>= i 0)
441 (aset expand-pos i (copy-marker (- p (aref expand-list i))))
442 (setq i (1- i))))
443 (setq expand-list nil))))
445 (defun expand-clear-markers ()
446 "Make the markers point nowhere."
447 (if expand-pos
448 (progn
449 (let ((i (1- (length expand-pos))))
450 (while (>= i 0)
451 (set-marker (aref expand-pos i) nil)
452 (setq i (1- i))))
453 (setq expand-pos nil))))
455 (defun expand-in-literal ()
456 "Test if we are in a comment or in a string."
457 (save-excursion
458 (let* ((lim (or (save-excursion
459 (beginning-of-defun)
460 (point))
461 (point-min)))
462 (here (point))
463 (state (parse-partial-sexp lim (point))))
464 (cond
465 ((nth 3 state) 'string)
466 ((nth 4 state) 'comment)
467 (t nil)))))
469 ;; support functions to add marks to jump from outside function
471 (defun expand-list-to-markers (l)
472 "Transform a list of markers in reverse order into a vector in the correct order."
473 (let* ((len (1- (length l)))
474 (loop len)
475 (v (make-vector (+ len 1) nil)))
476 (while (>= loop 0)
477 (aset v loop (if (markerp (car l)) (car l) (copy-marker (car l))))
478 (setq l (cdr l)
479 loop (1- loop)))
482 ;; integration with skeleton.el
483 ;; Used in `skeleton-end-hook' to fetch the positions for @ skeleton tags.
484 ;; See `skeleton-insert'.
485 (defun expand-skeleton-end-hook ()
486 (if skeleton-positions
487 (setq expand-list skeleton-positions)))
489 (add-hook 'skeleton-end-hook (function expand-skeleton-end-hook))
491 (provide 'expand)
493 ;; run load hooks
494 (run-hooks 'expand-load-hook)
496 ;;; expand.el ends here