ChangeLog fix
[emacs.git] / lisp / abbrev.el
blob27cd7089a073eb679810b361e66c6194ae0432fd
1 ;;; abbrev.el --- abbrev mode commands for Emacs -*- lexical-binding: t -*-
3 ;; Copyright (C) 1985-1987, 1992, 2001-2013 Free Software Foundation,
4 ;; Inc.
6 ;; Maintainer: FSF
7 ;; Keywords: abbrev convenience
8 ;; Package: emacs
10 ;; This file is part of GNU Emacs.
12 ;; GNU Emacs is free software: you can redistribute it and/or modify
13 ;; it under the terms of the GNU General Public License as published by
14 ;; the Free Software Foundation, either version 3 of the License, or
15 ;; (at your option) any later version.
17 ;; GNU Emacs is distributed in the hope that it will be useful,
18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 ;; GNU General Public License for more details.
22 ;; You should have received a copy of the GNU General Public License
23 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
25 ;;; Commentary:
27 ;; This facility is documented in the Emacs Manual.
29 ;; Todo:
31 ;; - Cleanup name space.
33 ;;; Code:
35 (eval-when-compile (require 'cl-lib))
37 (defgroup abbrev-mode nil
38 "Word abbreviations mode."
39 :link '(custom-manual "(emacs)Abbrevs")
40 :group 'abbrev)
42 (defcustom abbrev-file-name
43 (locate-user-emacs-file "abbrev_defs" ".abbrev_defs")
44 "Default name of file from which to read abbrevs."
45 :initialize 'custom-initialize-delay
46 :type 'file)
48 (defcustom only-global-abbrevs nil
49 "Non-nil means user plans to use global abbrevs only.
50 This makes the commands that normally define mode-specific abbrevs
51 define global abbrevs instead."
52 :type 'boolean
53 :group 'abbrev-mode
54 :group 'convenience)
56 (define-minor-mode abbrev-mode
57 "Toggle Abbrev mode in the current buffer.
58 With a prefix argument ARG, enable Abbrev mode if ARG is
59 positive, and disable it otherwise. If called from Lisp, enable
60 Abbrev mode if ARG is omitted or nil.
62 In Abbrev mode, inserting an abbreviation causes it to expand and
63 be replaced by its expansion."
64 ;; It's defined in C, this stops the d-m-m macro defining it again.
65 :variable abbrev-mode)
67 (put 'abbrev-mode 'safe-local-variable 'booleanp)
70 (defvar edit-abbrevs-map
71 (let ((map (make-sparse-keymap)))
72 (define-key map "\C-x\C-s" 'abbrev-edit-save-buffer)
73 (define-key map "\C-x\C-w" 'abbrev-edit-save-to-file)
74 (define-key map "\C-c\C-c" 'edit-abbrevs-redefine)
75 map)
76 "Keymap used in `edit-abbrevs'.")
78 (defun kill-all-abbrevs ()
79 "Undefine all defined abbrevs."
80 (interactive)
81 (dolist (tablesym abbrev-table-name-list)
82 (clear-abbrev-table (symbol-value tablesym))))
84 (defun copy-abbrev-table (table)
85 "Make a new abbrev-table with the same abbrevs as TABLE.
86 Does not copy property lists."
87 (let ((new-table (make-abbrev-table)))
88 (mapatoms
89 (lambda (symbol)
90 (define-abbrev new-table
91 (symbol-name symbol)
92 (symbol-value symbol)
93 (symbol-function symbol)))
94 table)
95 new-table))
97 (defun insert-abbrevs ()
98 "Insert after point a description of all defined abbrevs.
99 Mark is set after the inserted text."
100 (interactive)
101 (push-mark
102 (save-excursion
103 (dolist (tablesym abbrev-table-name-list)
104 (insert-abbrev-table-description tablesym t))
105 (point))))
107 (defun list-abbrevs (&optional local)
108 "Display a list of defined abbrevs.
109 If LOCAL is non-nil, interactively when invoked with a
110 prefix arg, display only local, i.e. mode-specific, abbrevs.
111 Otherwise display all abbrevs."
112 (interactive "P")
113 (display-buffer (prepare-abbrev-list-buffer local)))
115 (defun abbrev-table-name (table)
116 "Value is the name of abbrev table TABLE."
117 (let ((tables abbrev-table-name-list)
118 found)
119 (while (and (not found) tables)
120 (when (eq (symbol-value (car tables)) table)
121 (setq found (car tables)))
122 (setq tables (cdr tables)))
123 found))
125 (defun prepare-abbrev-list-buffer (&optional local)
126 (let ((local-table local-abbrev-table))
127 (with-current-buffer (get-buffer-create "*Abbrevs*")
128 (erase-buffer)
129 (if local
130 (insert-abbrev-table-description
131 (abbrev-table-name local-table) t)
132 (let (empty-tables)
133 (dolist (table abbrev-table-name-list)
134 (if (abbrev-table-empty-p (symbol-value table))
135 (push table empty-tables)
136 (insert-abbrev-table-description table t)))
137 (dolist (table (nreverse empty-tables))
138 (insert-abbrev-table-description table t)))
139 ;; Note: `list-abbrevs' can display only local abbrevs, in
140 ;; which case editing could lose abbrevs of other tables. Thus
141 ;; enter `edit-abbrevs-mode' only if LOCAL is nil.
142 (edit-abbrevs-mode))
143 (goto-char (point-min))
144 (set-buffer-modified-p nil)
145 (current-buffer))))
147 (defun edit-abbrevs-mode ()
148 "Major mode for editing the list of abbrev definitions.
149 \\{edit-abbrevs-map}"
150 (interactive)
151 (kill-all-local-variables)
152 (setq major-mode 'edit-abbrevs-mode)
153 (setq mode-name "Edit-Abbrevs")
154 (use-local-map edit-abbrevs-map)
155 (run-mode-hooks 'edit-abbrevs-mode-hook))
157 (defun edit-abbrevs ()
158 "Alter abbrev definitions by editing a list of them.
159 Selects a buffer containing a list of abbrev definitions with
160 point located in the abbrev table of current buffer.
161 You can edit them and type \\<edit-abbrevs-map>\\[edit-abbrevs-redefine] to redefine abbrevs
162 according to your editing.
163 Buffer contains a header line for each abbrev table,
164 which is the abbrev table name in parentheses.
165 This is followed by one line per abbrev in that table:
166 NAME USECOUNT EXPANSION HOOK
167 where NAME and EXPANSION are strings with quotes,
168 USECOUNT is an integer, and HOOK is any valid function
169 or may be omitted (it is usually omitted)."
170 (interactive)
171 (let ((table-name (abbrev-table-name local-abbrev-table)))
172 (switch-to-buffer (prepare-abbrev-list-buffer))
173 (when (and table-name
174 (search-forward
175 (concat "(" (symbol-name table-name) ")\n\n") nil t))
176 (goto-char (match-end 0)))))
178 (defun edit-abbrevs-redefine ()
179 "Redefine abbrevs according to current buffer contents."
180 (interactive)
181 (save-restriction
182 (widen)
183 (define-abbrevs t)
184 (set-buffer-modified-p nil)))
186 (defun define-abbrevs (&optional arg)
187 "Define abbrevs according to current visible buffer contents.
188 See documentation of `edit-abbrevs' for info on the format of the
189 text you must have in the buffer.
190 With argument, eliminate all abbrev definitions except
191 the ones defined from the buffer now."
192 (interactive "P")
193 (if arg (kill-all-abbrevs))
194 (save-excursion
195 (goto-char (point-min))
196 (while (and (not (eobp)) (re-search-forward "^(" nil t))
197 (let* ((buf (current-buffer))
198 (table (read buf))
199 abbrevs name hook exp count sys)
200 (forward-line 1)
201 (while (progn (forward-line 1)
202 (not (eolp)))
203 (setq name (read buf) count (read buf))
204 (if (equal count '(sys))
205 (setq sys t count (read buf))
206 (setq sys nil))
207 (setq exp (read buf))
208 (skip-chars-backward " \t\n\f")
209 (setq hook (if (not (eolp)) (read buf)))
210 (skip-chars-backward " \t\n\f")
211 (setq abbrevs (cons (list name exp hook count sys) abbrevs)))
212 (define-abbrev-table table abbrevs)))))
214 (defun read-abbrev-file (&optional file quietly)
215 "Read abbrev definitions from file written with `write-abbrev-file'.
216 Optional argument FILE is the name of the file to read;
217 it defaults to the value of `abbrev-file-name'.
218 Optional second argument QUIETLY non-nil means don't display a message."
219 (interactive
220 (list
221 (read-file-name (format "Read abbrev file (default %s): "
222 abbrev-file-name)
223 nil abbrev-file-name t)))
224 (load (or file abbrev-file-name) nil quietly)
225 (setq abbrevs-changed nil))
227 (defun quietly-read-abbrev-file (&optional file)
228 "Read abbrev definitions from file written with `write-abbrev-file'.
229 Optional argument FILE is the name of the file to read;
230 it defaults to the value of `abbrev-file-name'.
231 Does not display any message."
232 ;(interactive "fRead abbrev file: ")
233 (read-abbrev-file file t))
235 (defun write-abbrev-file (&optional file verbose)
236 "Write all user-level abbrev definitions to a file of Lisp code.
237 This does not include system abbrevs; it includes only the abbrev tables
238 listed in listed in `abbrev-table-name-list'.
239 The file written can be loaded in another session to define the same abbrevs.
240 The argument FILE is the file name to write. If omitted or nil, the file
241 specified in `abbrev-file-name' is used.
242 If VERBOSE is non-nil, display a message indicating where abbrevs
243 have been saved."
244 (interactive
245 (list
246 (read-file-name "Write abbrev file: "
247 (file-name-directory (expand-file-name abbrev-file-name))
248 abbrev-file-name)))
249 (or (and file (> (length file) 0))
250 (setq file abbrev-file-name))
251 (let ((coding-system-for-write 'utf-8))
252 (with-temp-buffer
253 (dolist (table
254 ;; We sort the table in order to ease the automatic
255 ;; merging of different versions of the user's abbrevs
256 ;; file. This is useful, for example, for when the
257 ;; user keeps their home directory in a revision
258 ;; control system, and is therefore keeping multiple
259 ;; slightly-differing copies loosely synchronized.
260 (sort (copy-sequence abbrev-table-name-list)
261 (lambda (s1 s2)
262 (string< (symbol-name s1)
263 (symbol-name s2)))))
264 (insert-abbrev-table-description table nil))
265 (when (unencodable-char-position (point-min) (point-max) 'utf-8)
266 (setq coding-system-for-write
267 (if (> emacs-major-version 24)
268 'utf-8-emacs
269 ;; For compatibility with Emacs 22 (See Bug#8308)
270 'emacs-mule)))
271 (goto-char (point-min))
272 (insert (format ";;-*-coding: %s;-*-\n" coding-system-for-write))
273 (write-region nil nil file nil (and (not verbose) 0)))))
275 (defun abbrev-edit-save-to-file (file)
276 "Save all user-level abbrev definitions in current buffer to FILE."
277 (interactive
278 (list (read-file-name "Save abbrevs to file: "
279 (file-name-directory
280 (expand-file-name abbrev-file-name))
281 abbrev-file-name)))
282 (edit-abbrevs-redefine)
283 (write-abbrev-file file t))
285 (defun abbrev-edit-save-buffer ()
286 "Save all user-level abbrev definitions in current buffer.
287 The saved abbrevs are written to the file specified by
288 `abbrev-file-name'."
289 (interactive)
290 (abbrev-edit-save-to-file abbrev-file-name))
293 (defun add-mode-abbrev (arg)
294 "Define mode-specific abbrev for last word(s) before point.
295 Argument is how many words before point form the expansion;
296 or zero means the region is the expansion.
297 A negative argument means to undefine the specified abbrev.
298 Reads the abbreviation in the minibuffer.
300 Don't use this function in a Lisp program; use `define-abbrev' instead."
301 (interactive "p")
302 (add-abbrev
303 (if only-global-abbrevs
304 global-abbrev-table
305 (or local-abbrev-table
306 (error "No per-mode abbrev table")))
307 "Mode" arg))
309 (defun add-global-abbrev (arg)
310 "Define global (all modes) abbrev for last word(s) before point.
311 The prefix argument specifies the number of words before point that form the
312 expansion; or zero means the region is the expansion.
313 A negative argument means to undefine the specified abbrev.
314 This command uses the minibuffer to read the abbreviation.
316 Don't use this function in a Lisp program; use `define-abbrev' instead."
317 (interactive "p")
318 (add-abbrev global-abbrev-table "Global" arg))
320 (defun add-abbrev (table type arg)
321 (let ((exp (and (>= arg 0)
322 (buffer-substring-no-properties
323 (point)
324 (if (= arg 0) (mark)
325 (save-excursion (forward-word (- arg)) (point))))))
326 name)
327 (setq name
328 (read-string (format (if exp "%s abbrev for \"%s\": "
329 "Undefine %s abbrev: ")
330 type exp)))
331 (set-text-properties 0 (length name) nil name)
332 (if (or (null exp)
333 (not (abbrev-expansion name table))
334 (y-or-n-p (format "%s expands to \"%s\"; redefine? "
335 name (abbrev-expansion name table))))
336 (define-abbrev table (downcase name) exp))))
338 (defun inverse-add-mode-abbrev (n)
339 "Define last word before point as a mode-specific abbrev.
340 With prefix argument N, defines the Nth word before point.
341 This command uses the minibuffer to read the expansion.
342 Expands the abbreviation after defining it."
343 (interactive "p")
344 (inverse-add-abbrev
345 (if only-global-abbrevs
346 global-abbrev-table
347 (or local-abbrev-table
348 (error "No per-mode abbrev table")))
349 "Mode" n))
351 (defun inverse-add-global-abbrev (n)
352 "Define last word before point as a global (mode-independent) abbrev.
353 With prefix argument N, defines the Nth word before point.
354 This command uses the minibuffer to read the expansion.
355 Expands the abbreviation after defining it."
356 (interactive "p")
357 (inverse-add-abbrev global-abbrev-table "Global" n))
359 (defun inverse-add-abbrev (table type arg)
360 (let (name exp start end)
361 (save-excursion
362 (forward-word (1+ (- arg)))
363 (setq end (point))
364 (backward-word 1)
365 (setq start (point)
366 name (buffer-substring-no-properties start end)))
368 (setq exp (read-string (format "%s expansion for \"%s\": " type name)
369 nil nil nil t))
370 (when (or (not (abbrev-expansion name table))
371 (y-or-n-p (format "%s expands to \"%s\"; redefine? "
372 name (abbrev-expansion name table))))
373 (define-abbrev table (downcase name) exp)
374 (save-excursion
375 (goto-char end)
376 (expand-abbrev)))))
378 (defun abbrev-prefix-mark (&optional arg)
379 "Mark current point as the beginning of an abbrev.
380 Abbrev to be expanded starts here rather than at beginning of word.
381 This way, you can expand an abbrev with a prefix: insert the prefix,
382 use this command, then insert the abbrev. This command inserts a
383 temporary hyphen after the prefix (until the intended abbrev
384 expansion occurs).
385 If the prefix is itself an abbrev, this command expands it, unless
386 ARG is non-nil. Interactively, ARG is the prefix argument."
387 (interactive "P")
388 (or arg (expand-abbrev))
389 (setq abbrev-start-location (point-marker)
390 abbrev-start-location-buffer (current-buffer))
391 (insert "-"))
393 (defun expand-region-abbrevs (start end &optional noquery)
394 "For abbrev occurrence in the region, offer to expand it.
395 The user is asked to type `y' or `n' for each occurrence.
396 A prefix argument means don't query; expand all abbrevs."
397 (interactive "r\nP")
398 (save-excursion
399 (goto-char start)
400 (let ((lim (- (point-max) end))
401 pnt string)
402 (while (and (not (eobp))
403 (progn (forward-word 1)
404 (<= (setq pnt (point)) (- (point-max) lim))))
405 (if (abbrev-expansion
406 (setq string
407 (buffer-substring-no-properties
408 (save-excursion (forward-word -1) (point))
409 pnt)))
410 (if (or noquery (y-or-n-p (format "Expand `%s'? " string)))
411 (expand-abbrev)))))))
413 ;;; Abbrev properties.
415 (defun abbrev-table-get (table prop)
416 "Get the PROP property of abbrev table TABLE."
417 (let ((sym (intern-soft "" table)))
418 (if sym (get sym prop))))
420 (defun abbrev-table-put (table prop val)
421 "Set the PROP property of abbrev table TABLE to VAL."
422 (let ((sym (intern "" table)))
423 (set sym nil) ; Make sure it won't be confused for an abbrev.
424 (put sym prop val)))
426 (defalias 'abbrev-get 'get
427 "Get the property PROP of abbrev ABBREV
429 \(fn ABBREV PROP)")
431 (defalias 'abbrev-put 'put
432 "Set the property PROP of abbrev ABREV to value VAL.
433 See `define-abbrev' for the effect of some special properties.
435 \(fn ABBREV PROP VAL)")
437 ;;; Code that used to be implemented in src/abbrev.c
439 (defvar abbrev-table-name-list '(fundamental-mode-abbrev-table
440 global-abbrev-table)
441 "List of symbols whose values are abbrev tables.")
443 (defun make-abbrev-table (&optional props)
444 "Create a new, empty abbrev table object.
445 PROPS is a list of properties."
446 ;; The value 59 is an arbitrary prime number.
447 (let ((table (make-vector 59 0)))
448 ;; Each abbrev-table has a `modiff' counter which can be used to detect
449 ;; when an abbreviation was added. An example of use would be to
450 ;; construct :regexp dynamically as the union of all abbrev names, so
451 ;; `modiff' can let us detect that an abbrev was added and hence :regexp
452 ;; needs to be refreshed.
453 ;; The presence of `modiff' entry is also used as a tag indicating this
454 ;; vector is really an abbrev-table.
455 (abbrev-table-put table :abbrev-table-modiff 0)
456 (while (consp props)
457 (abbrev-table-put table (pop props) (pop props)))
458 table))
460 (defun abbrev-table-p (object)
461 "Return non-nil if OBJECT is an abbrev table."
462 (and (vectorp object)
463 (numberp (abbrev-table-get object :abbrev-table-modiff))))
465 (defun abbrev-table-empty-p (object &optional ignore-system)
466 "Return nil if there are no abbrev symbols in OBJECT.
467 If IGNORE-SYSTEM is non-nil, system definitions are ignored."
468 (unless (abbrev-table-p object)
469 (error "Non abbrev table object"))
470 (not (catch 'some
471 (mapatoms (lambda (abbrev)
472 (unless (or (zerop (length (symbol-name abbrev)))
473 (and ignore-system
474 (abbrev-get abbrev :system)))
475 (throw 'some t)))
476 object))))
478 (defvar global-abbrev-table (make-abbrev-table)
479 "The abbrev table whose abbrevs affect all buffers.
480 Each buffer may also have a local abbrev table.
481 If it does, the local table overrides the global one
482 for any particular abbrev defined in both.")
484 (defvar abbrev-minor-mode-table-alist nil
485 "Alist of abbrev tables to use for minor modes.
486 Each element looks like (VARIABLE . ABBREV-TABLE);
487 ABBREV-TABLE is active whenever VARIABLE's value is non-nil.
488 ABBREV-TABLE can also be a list of abbrev tables.")
490 (defvar fundamental-mode-abbrev-table
491 (let ((table (make-abbrev-table)))
492 ;; Set local-abbrev-table's default to be fundamental-mode-abbrev-table.
493 (setq-default local-abbrev-table table)
494 table)
495 "The abbrev table of mode-specific abbrevs for Fundamental Mode.")
497 (defvar abbrevs-changed nil
498 "Set non-nil by defining or altering any word abbrevs.
499 This causes `save-some-buffers' to offer to save the abbrevs.")
501 (defcustom abbrev-all-caps nil
502 "Non-nil means expand multi-word abbrevs all caps if abbrev was so."
503 :type 'boolean
504 :group 'abbrev-mode)
506 (defvar abbrev-start-location nil
507 "Buffer position for `expand-abbrev' to use as the start of the abbrev.
508 When nil, use the word before point as the abbrev.
509 Calling `expand-abbrev' sets this to nil.")
511 (defvar abbrev-start-location-buffer nil
512 "Buffer that `abbrev-start-location' has been set for.
513 Trying to expand an abbrev in any other buffer clears `abbrev-start-location'.")
515 (defvar last-abbrev nil
516 "The abbrev-symbol of the last abbrev expanded. See `abbrev-symbol'.")
518 (defvar last-abbrev-text nil
519 "The exact text of the last abbrev expanded.
520 It is nil if the abbrev has already been unexpanded.")
522 (defvar last-abbrev-location 0
523 "The location of the start of the last abbrev expanded.")
525 ;; (defvar local-abbrev-table fundamental-mode-abbrev-table
526 ;; "Local (mode-specific) abbrev table of current buffer.")
527 ;; (make-variable-buffer-local 'local-abbrev-table)
529 (defcustom pre-abbrev-expand-hook nil
530 "Function or functions to be called before abbrev expansion is done.
531 This is the first thing that `expand-abbrev' does, and so this may change
532 the current abbrev table before abbrev lookup happens."
533 :type 'hook
534 :group 'abbrev-mode)
535 (make-obsolete-variable 'pre-abbrev-expand-hook 'abbrev-expand-function "23.1")
537 (defun clear-abbrev-table (table)
538 "Undefine all abbrevs in abbrev table TABLE, leaving it empty."
539 (setq abbrevs-changed t)
540 (let* ((sym (intern-soft "" table)))
541 (dotimes (i (length table))
542 (aset table i 0))
543 ;; Preserve the table's properties.
544 (cl-assert sym)
545 (let ((newsym (intern "" table)))
546 (set newsym nil) ; Make sure it won't be confused for an abbrev.
547 (setplist newsym (symbol-plist sym)))
548 (abbrev-table-put table :abbrev-table-modiff
549 (1+ (abbrev-table-get table :abbrev-table-modiff))))
550 ;; For backward compatibility, always return nil.
551 nil)
553 (defun define-abbrev (table name expansion &optional hook &rest props)
554 "Define an abbrev in TABLE named NAME, to expand to EXPANSION and call HOOK.
555 NAME must be a string, and should be lower-case.
556 EXPANSION should usually be a string.
557 To undefine an abbrev, define it with EXPANSION = nil.
558 If HOOK is non-nil, it should be a function of no arguments;
559 it is called after EXPANSION is inserted.
560 If EXPANSION is not a string (and not nil), the abbrev is a
561 special one, which does not expand in the usual way but only
562 runs HOOK.
564 If HOOK is a non-nil symbol with a non-nil `no-self-insert' property,
565 it can control whether the character that triggered abbrev expansion
566 is inserted. If such a HOOK returns non-nil, the character is not
567 inserted. If such a HOOK returns nil, then so does `abbrev-insert'
568 \(and `expand-abbrev'), as if no abbrev expansion had taken place.
570 PROPS is a property list. The following properties are special:
571 - `:count': the value for the abbrev's usage-count, which is incremented each
572 time the abbrev is used (the default is zero).
573 - `:system': if non-nil, says that this is a \"system\" abbreviation
574 which should not be saved in the user's abbreviation file.
575 Unless `:system' is `force', a system abbreviation will not
576 overwrite a non-system abbreviation of the same name.
577 - `:case-fixed': non-nil means that abbreviations are looked up without
578 case-folding, and the expansion is not capitalized/upcased.
579 - `:enable-function': a function of no argument which returns non-nil if the
580 abbrev should be used for a particular call of `expand-abbrev'.
582 An obsolete but still supported calling form is:
584 \(define-abbrev TABLE NAME EXPANSION &optional HOOK COUNT SYSTEM)."
585 (when (and (consp props) (or (null (car props)) (numberp (car props))))
586 ;; Old-style calling convention.
587 (setq props `(:count ,(car props)
588 ,@(if (cadr props) (list :system (cadr props))))))
589 (unless (plist-get props :count)
590 (setq props (plist-put props :count 0)))
591 (let ((system-flag (plist-get props :system))
592 (sym (intern name table)))
593 ;; Don't override a prior user-defined abbrev with a system abbrev,
594 ;; unless system-flag is `force'.
595 (unless (and (not (memq system-flag '(nil force)))
596 (boundp sym) (symbol-value sym)
597 (not (abbrev-get sym :system)))
598 (unless (or system-flag
599 (and (boundp sym) (fboundp sym)
600 ;; load-file-name
601 (equal (symbol-value sym) expansion)
602 (equal (symbol-function sym) hook)))
603 (setq abbrevs-changed t))
604 (set sym expansion)
605 (fset sym hook)
606 (setplist sym
607 ;; Don't store the `force' value of `system-flag' into
608 ;; the :system property.
609 (if (eq 'force system-flag) (plist-put props :system t) props))
610 (abbrev-table-put table :abbrev-table-modiff
611 (1+ (abbrev-table-get table :abbrev-table-modiff))))
612 name))
614 (defun abbrev--check-chars (abbrev global)
615 "Check if the characters in ABBREV have word syntax in either the
616 current (if global is nil) or standard syntax table."
617 (with-syntax-table
618 (cond ((null global) (standard-syntax-table))
619 ;; ((syntax-table-p global) global)
620 (t (syntax-table)))
621 (when (string-match "\\W" abbrev)
622 (let ((badchars ())
623 (pos 0))
624 (while (string-match "\\W" abbrev pos)
625 (cl-pushnew (aref abbrev (match-beginning 0)) badchars)
626 (setq pos (1+ pos)))
627 (error "Some abbrev characters (%s) are not word constituents %s"
628 (apply 'string (nreverse badchars))
629 (if global "in the standard syntax" "in this mode"))))))
631 (defun define-global-abbrev (abbrev expansion)
632 "Define ABBREV as a global abbreviation for EXPANSION.
633 The characters in ABBREV must all be word constituents in the standard
634 syntax table."
635 (interactive "sDefine global abbrev: \nsExpansion for %s: ")
636 (abbrev--check-chars abbrev 'global)
637 (define-abbrev global-abbrev-table (downcase abbrev) expansion))
639 (defun define-mode-abbrev (abbrev expansion)
640 "Define ABBREV as a mode-specific abbreviation for EXPANSION.
641 The characters in ABBREV must all be word-constituents in the current mode."
642 (interactive "sDefine mode abbrev: \nsExpansion for %s: ")
643 (unless local-abbrev-table
644 (error "Major mode has no abbrev table"))
645 (abbrev--check-chars abbrev nil)
646 (define-abbrev local-abbrev-table (downcase abbrev) expansion))
648 (defun abbrev--active-tables (&optional tables)
649 "Return the list of abbrev tables currently active.
650 TABLES if non-nil overrides the usual rules. It can hold
651 either a single abbrev table or a list of abbrev tables."
652 ;; We could just remove the `tables' arg and let callers use
653 ;; (or table (abbrev--active-tables)) but then they'd have to be careful
654 ;; to treat the distinction between a single table and a list of tables.
655 (cond
656 ((consp tables) tables)
657 ((vectorp tables) (list tables))
659 (let ((tables (if (listp local-abbrev-table)
660 (append local-abbrev-table
661 (list global-abbrev-table))
662 (list local-abbrev-table global-abbrev-table))))
663 ;; Add the minor-mode abbrev tables.
664 (dolist (x abbrev-minor-mode-table-alist)
665 (when (and (symbolp (car x)) (boundp (car x)) (symbol-value (car x)))
666 (setq tables
667 (if (listp (cdr x))
668 (append (cdr x) tables) (cons (cdr x) tables)))))
669 tables))))
672 (defun abbrev--symbol (abbrev table)
673 "Return the symbol representing abbrev named ABBREV in TABLE.
674 This symbol's name is ABBREV, but it is not the canonical symbol of that name;
675 it is interned in the abbrev-table TABLE rather than the normal obarray.
676 The value is nil if that abbrev is not defined."
677 (let* ((case-fold (not (abbrev-table-get table :case-fixed)))
678 ;; In case the table doesn't set :case-fixed but some of the
679 ;; abbrevs do, we have to be careful.
680 (sym
681 ;; First try without case-folding.
682 (or (intern-soft abbrev table)
683 (when case-fold
684 ;; We didn't find any abbrev, try case-folding.
685 (let ((sym (intern-soft (downcase abbrev) table)))
686 ;; Only use it if it doesn't require :case-fixed.
687 (and sym (not (abbrev-get sym :case-fixed))
688 sym))))))
689 (if (symbol-value sym)
690 sym)))
692 (defun abbrev-symbol (abbrev &optional table)
693 "Return the symbol representing abbrev named ABBREV.
694 This symbol's name is ABBREV, but it is not the canonical symbol of that name;
695 it is interned in an abbrev-table rather than the normal obarray.
696 The value is nil if that abbrev is not defined.
697 Optional second arg TABLE is abbrev table to look it up in.
698 The default is to try buffer's mode-specific abbrev table, then global table."
699 (let ((tables (abbrev--active-tables table))
700 sym)
701 (while (and tables (not sym))
702 (let* ((table (pop tables)))
703 (setq tables (append (abbrev-table-get table :parents) tables))
704 (setq sym (abbrev--symbol abbrev table))))
705 sym))
708 (defun abbrev-expansion (abbrev &optional table)
709 "Return the string that ABBREV expands into in the current buffer.
710 Optionally specify an abbrev table as second arg;
711 then ABBREV is looked up in that table only."
712 (symbol-value (abbrev-symbol abbrev table)))
715 (defun abbrev--before-point ()
716 "Try and find an abbrev before point. Return it if found, nil otherwise."
717 (unless (eq abbrev-start-location-buffer (current-buffer))
718 (setq abbrev-start-location nil))
720 (let ((tables (abbrev--active-tables))
721 (pos (point))
722 start end name res)
724 (if abbrev-start-location
725 (progn
726 (setq start abbrev-start-location)
727 (setq abbrev-start-location nil)
728 ;; Remove the hyphen inserted by `abbrev-prefix-mark'.
729 (if (and (< start (point-max))
730 (eq (char-after start) ?-))
731 (delete-region start (1+ start)))
732 (skip-syntax-backward " ")
733 (setq end (point))
734 (when (> end start)
735 (setq name (buffer-substring start end))
736 (goto-char pos) ; Restore point.
737 (list (abbrev-symbol name tables) name start end)))
739 (while (and tables (not (car res)))
740 (let* ((table (pop tables))
741 (enable-fun (abbrev-table-get table :enable-function)))
742 (setq tables (append (abbrev-table-get table :parents) tables))
743 (setq res
744 (and (or (not enable-fun) (funcall enable-fun))
745 (let ((re (abbrev-table-get table :regexp)))
746 (if (null re)
747 ;; We used to default `re' to "\\<\\(\\w+\\)\\W*"
748 ;; but when words-include-escapes is set, that
749 ;; is not right and fixing it is boring.
750 (let ((lim (point)))
751 (backward-word 1)
752 (setq start (point))
753 (forward-word 1)
754 (setq end (min (point) lim)))
755 (when (looking-back re (line-beginning-position))
756 (setq start (match-beginning 1))
757 (setq end (match-end 1)))))
758 (setq name (buffer-substring start end))
759 (let ((abbrev (abbrev--symbol name table)))
760 (when abbrev
761 (setq enable-fun (abbrev-get abbrev :enable-function))
762 (and (or (not enable-fun) (funcall enable-fun))
763 ;; This will also look it up in parent tables.
764 ;; This is not on purpose, but it seems harmless.
765 (list abbrev name start end))))))
766 ;; Restore point.
767 (goto-char pos)))
768 res)))
770 (defun abbrev-insert (abbrev &optional name wordstart wordend)
771 "Insert abbrev ABBREV at point.
772 If non-nil, NAME is the name by which this abbrev was found.
773 If non-nil, WORDSTART is the place where to insert the abbrev.
774 If WORDEND is non-nil, the abbrev replaces the previous text between
775 WORDSTART and WORDEND.
776 Return ABBREV if the expansion should be considered as having taken place.
777 The return value can be influenced by a `no-self-insert' property;
778 see `define-abbrev' for details."
779 (unless name (setq name (symbol-name abbrev)))
780 (unless wordstart (setq wordstart (point)))
781 (unless wordend (setq wordend wordstart))
782 ;; Increment use count.
783 (abbrev-put abbrev :count (1+ (abbrev-get abbrev :count)))
784 (let ((value abbrev))
785 ;; If this abbrev has an expansion, delete the abbrev
786 ;; and insert the expansion.
787 (when (stringp (symbol-value abbrev))
788 (goto-char wordstart)
789 ;; Insert at beginning so that markers at the end (e.g. point)
790 ;; are preserved.
791 (insert (symbol-value abbrev))
792 (delete-char (- wordend wordstart))
793 (let ((case-fold-search nil))
794 ;; If the abbrev's name is different from the buffer text (the
795 ;; only difference should be capitalization), then we may want
796 ;; to adjust the capitalization of the expansion.
797 (when (and (not (equal name (symbol-name abbrev)))
798 (string-match "[[:upper:]]" name))
799 (if (not (string-match "[[:lower:]]" name))
800 ;; Abbrev was all caps. If expansion is multiple words,
801 ;; normally capitalize each word.
802 (if (and (not abbrev-all-caps)
803 (save-excursion
804 (> (progn (backward-word 1) (point))
805 (progn (goto-char wordstart)
806 (forward-word 1) (point)))))
807 (upcase-initials-region wordstart (point))
808 (upcase-region wordstart (point)))
809 ;; Abbrev included some caps. Cap first initial of expansion.
810 (let ((end (point)))
811 ;; Find the initial.
812 (goto-char wordstart)
813 (skip-syntax-forward "^w" (1- end))
814 ;; Change just that.
815 (upcase-initials-region (point) (1+ (point)))
816 (goto-char end))))))
817 ;; Now point is at the end of the expansion and the beginning is
818 ;; in last-abbrev-location.
819 (when (symbol-function abbrev)
820 (let* ((hook (symbol-function abbrev))
821 (expanded
822 ;; If the abbrev has a hook function, run it.
823 (funcall hook)))
824 ;; In addition, if the hook function is a symbol with
825 ;; a non-nil `no-self-insert' property, let the value it
826 ;; returned specify whether we consider that an expansion took
827 ;; place. If it returns nil, no expansion has been done.
828 (if (and (symbolp hook)
829 (null expanded)
830 (get hook 'no-self-insert))
831 (setq value nil))))
832 value))
834 (defvar abbrev-expand-functions nil
835 "Wrapper hook around `expand-abbrev'.")
836 (make-obsolete-variable 'abbrev-expand-functions 'abbrev-expand-function "24.4")
838 (defvar abbrev-expand-function #'abbrev--default-expand
839 "Function to perform abbrev expansion.
840 Takes no argument and should return the abbrev symbol if expansion took place.")
842 (defun expand-abbrev ()
843 "Expand the abbrev before point, if there is an abbrev there.
844 Effective when explicitly called even when `abbrev-mode' is nil.
845 Returns the abbrev symbol, if expansion took place. (The actual
846 return value is that of `abbrev-insert'.)"
847 (interactive)
848 (run-hooks 'pre-abbrev-expand-hook)
849 (funcall abbrev-expand-function))
851 (defun abbrev--default-expand ()
852 (with-wrapper-hook abbrev-expand-functions ()
853 (pcase-let ((`(,sym ,name ,wordstart ,wordend) (abbrev--before-point)))
854 (when sym
855 (let ((startpos (copy-marker (point) t))
856 (endmark (copy-marker wordend t)))
857 (unless (or ;; executing-kbd-macro
858 noninteractive
859 (window-minibuffer-p (selected-window)))
860 ;; Add an undo boundary, in case we are doing this for
861 ;; a self-inserting command which has avoided making one so far.
862 (undo-boundary))
863 ;; Now sym is the abbrev symbol.
864 (setq last-abbrev-text name)
865 (setq last-abbrev sym)
866 (setq last-abbrev-location wordstart)
867 ;; If this abbrev has an expansion, delete the abbrev
868 ;; and insert the expansion.
869 (prog1
870 (abbrev-insert sym name wordstart wordend)
871 ;; Yuck!! If expand-abbrev is called with point slightly
872 ;; further than the end of the abbrev, move point back to
873 ;; where it started.
874 (if (and (> startpos endmark)
875 (= (point) endmark)) ;Obey skeletons that move point.
876 (goto-char startpos))))))))
878 (defun unexpand-abbrev ()
879 "Undo the expansion of the last abbrev that expanded.
880 This differs from ordinary undo in that other editing done since then
881 is not undone."
882 (interactive)
883 (save-excursion
884 (unless (or (< last-abbrev-location (point-min))
885 (> last-abbrev-location (point-max)))
886 (goto-char last-abbrev-location)
887 (when (stringp last-abbrev-text)
888 ;; This isn't correct if last-abbrev's hook was used
889 ;; to do the expansion.
890 (let ((val (symbol-value last-abbrev)))
891 (unless (stringp val)
892 (error "Value of abbrev-symbol must be a string"))
893 ;; Don't inherit properties here; just copy from old contents.
894 (insert last-abbrev-text)
895 ;; Delete after inserting, to better preserve markers.
896 (delete-region (point) (+ (point) (length val)))
897 (setq last-abbrev-text nil))))))
899 (defun abbrev--write (sym)
900 "Write the abbrev in a `read'able form.
901 Only writes the non-system abbrevs.
902 Presumes that `standard-output' points to `current-buffer'."
903 (unless (or (null (symbol-value sym)) (abbrev-get sym :system))
904 (insert " (")
905 (prin1 (symbol-name sym))
906 (insert " ")
907 (prin1 (symbol-value sym))
908 (insert " ")
909 (prin1 (symbol-function sym))
910 (insert " ")
911 (prin1 (abbrev-get sym :count))
912 (insert ")\n")))
914 (defun abbrev--describe (sym)
915 (when (symbol-value sym)
916 (prin1 (symbol-name sym))
917 (if (null (abbrev-get sym :system))
918 (indent-to 15 1)
919 (insert " (sys)")
920 (indent-to 20 1))
921 (prin1 (abbrev-get sym :count))
922 (indent-to 20 1)
923 (prin1 (symbol-value sym))
924 (when (symbol-function sym)
925 (indent-to 45 1)
926 (prin1 (symbol-function sym)))
927 (terpri)))
929 (defun insert-abbrev-table-description (name &optional readable)
930 "Insert before point a full description of abbrev table named NAME.
931 NAME is a symbol whose value is an abbrev table.
932 If optional 2nd arg READABLE is non-nil, a human-readable description
933 is inserted. Otherwise the description is an expression,
934 a call to `define-abbrev-table', which would
935 define the abbrev table NAME exactly as it is currently defined.
937 Abbrevs marked as \"system abbrevs\" are omitted."
938 (let ((table (symbol-value name))
939 (symbols ()))
940 (mapatoms (lambda (sym) (if (symbol-value sym) (push sym symbols))) table)
941 (setq symbols (sort symbols 'string-lessp))
942 (let ((standard-output (current-buffer)))
943 (if readable
944 (progn
945 (insert "(")
946 (prin1 name)
947 (insert ")\n\n")
948 (mapc 'abbrev--describe symbols)
949 (insert "\n\n"))
950 (insert "(define-abbrev-table '")
951 (prin1 name)
952 (if (null symbols)
953 (insert " '())\n\n")
954 (insert "\n '(\n")
955 (mapc 'abbrev--write symbols)
956 (insert " ))\n\n")))
957 nil)))
959 (put 'define-abbrev-table 'doc-string-elt 3)
960 (defun define-abbrev-table (tablename definitions
961 &optional docstring &rest props)
962 "Define TABLENAME (a symbol) as an abbrev table name.
963 Define abbrevs in it according to DEFINITIONS, which is a list of elements
964 of the form (ABBREVNAME EXPANSION ...) that are passed to `define-abbrev'.
965 PROPS is a property list to apply to the table.
966 Properties with special meaning:
967 - `:parents' contains a list of abbrev tables from which this table inherits
968 abbreviations.
969 - `:case-fixed' non-nil means that abbreviations are looked up without
970 case-folding, and the expansion is not capitalized/upcased.
971 - `:regexp' is a regular expression that specifies how to extract the
972 name of the abbrev before point. The submatch 1 is treated
973 as the potential name of an abbrev. If :regexp is nil, the default
974 behavior uses `backward-word' and `forward-word' to extract the name
975 of the abbrev, which can therefore only be a single word.
976 - `:enable-function' can be set to a function of no argument which returns
977 non-nil if and only if the abbrevs in this table should be used for this
978 instance of `expand-abbrev'."
979 ;; We used to manually add the docstring, but we also want to record this
980 ;; location as the definition of the variable (in load-history), so we may
981 ;; as well just use `defvar'.
982 (eval `(defvar ,tablename nil ,@(if (stringp docstring) (list docstring))))
983 (let ((table (if (boundp tablename) (symbol-value tablename))))
984 (unless table
985 (setq table (make-abbrev-table))
986 (set tablename table)
987 (unless (memq tablename abbrev-table-name-list)
988 (push tablename abbrev-table-name-list)))
989 ;; We used to just pass them to `make-abbrev-table', but that fails
990 ;; if the table was pre-existing as is the case if it was created by
991 ;; loading the user's abbrev file.
992 (while (consp props)
993 (abbrev-table-put table (pop props) (pop props)))
994 (dolist (elt definitions)
995 (apply 'define-abbrev table elt))))
997 (defun abbrev-table-menu (table &optional prompt sortfun)
998 "Return a menu that shows all abbrevs in TABLE.
999 Selecting an entry runs `abbrev-insert'.
1000 PROMPT is the prompt to use for the keymap.
1001 SORTFUN is passed to `sort' to change the default ordering."
1002 (unless sortfun (setq sortfun 'string-lessp))
1003 (let ((entries ()))
1004 (mapatoms (lambda (abbrev)
1005 (when (symbol-value abbrev)
1006 (let ((name (symbol-name abbrev)))
1007 (push `(,(intern name) menu-item ,name
1008 (lambda () (interactive)
1009 (abbrev-insert ',abbrev)))
1010 entries))))
1011 table)
1012 (nconc (make-sparse-keymap prompt)
1013 (sort entries (lambda (x y)
1014 (funcall sortfun (nth 2 x) (nth 2 y)))))))
1016 (provide 'abbrev)
1018 ;;; abbrev.el ends here