1 /* Primitives for word-abbrev mode.
2 Copyright (C) 1985, 1986, 1993, 1996, 1998, 2001
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
30 #include "character.h"
33 /* An abbrev table is an obarray.
34 Each defined abbrev is represented by a symbol in that obarray
35 whose print name is the abbreviation.
36 The symbol's value is a string which is the expansion.
37 If its function definition is non-nil, it is called
38 after the expansion is done.
39 The plist slot of the abbrev symbol is its usage count. */
41 /* List of all abbrev-table name symbols:
42 symbols whose values are abbrev tables. */
44 Lisp_Object Vabbrev_table_name_list
;
46 /* The table of global abbrevs. These are in effect
47 in any buffer in which abbrev mode is turned on. */
49 Lisp_Object Vglobal_abbrev_table
;
51 /* The local abbrev table used by default (in Fundamental Mode buffers) */
53 Lisp_Object Vfundamental_mode_abbrev_table
;
55 /* Set nonzero when an abbrev definition is changed */
61 /* Non-nil => use this location as the start of abbrev to expand
62 (rather than taking the word before point as the abbrev) */
64 Lisp_Object Vabbrev_start_location
;
66 /* Buffer that Vabbrev_start_location applies to */
67 Lisp_Object Vabbrev_start_location_buffer
;
69 /* The symbol representing the abbrev most recently expanded */
71 Lisp_Object Vlast_abbrev
;
73 /* A string for the actual text of the abbrev most recently expanded.
74 This has more info than Vlast_abbrev since case is significant. */
76 Lisp_Object Vlast_abbrev_text
;
78 /* Character address of start of last abbrev expanded */
80 EMACS_INT last_abbrev_point
;
82 /* Hook to run before expanding any abbrev. */
84 Lisp_Object Vpre_abbrev_expand_hook
, Qpre_abbrev_expand_hook
;
86 Lisp_Object Qsystem_type
, Qcount
;
88 DEFUN ("make-abbrev-table", Fmake_abbrev_table
, Smake_abbrev_table
, 0, 0, 0,
89 doc
: /* Create a new, empty abbrev table object. */)
92 /* The value 59 is arbitrary chosen prime number. */
93 return Fmake_vector (make_number (59), make_number (0));
96 DEFUN ("clear-abbrev-table", Fclear_abbrev_table
, Sclear_abbrev_table
, 1, 1, 0,
97 doc
: /* Undefine all abbrevs in abbrev table TABLE, leaving it empty. */)
103 CHECK_VECTOR (table
);
104 size
= XVECTOR (table
)->size
;
106 for (i
= 0; i
< size
; i
++)
107 XVECTOR (table
)->contents
[i
] = make_number (0);
111 DEFUN ("define-abbrev", Fdefine_abbrev
, Sdefine_abbrev
, 3, 6, 0,
112 doc
: /* Define an abbrev in TABLE named NAME, to expand to EXPANSION and call HOOK.
113 NAME must be a string.
114 EXPANSION should usually be a string.
115 To undefine an abbrev, define it with EXPANSION = nil.
116 If HOOK is non-nil, it should be a function of no arguments;
117 it is called after EXPANSION is inserted.
118 If EXPANSION is not a string, the abbrev is a special one,
119 which does not expand in the usual way but only runs HOOK.
121 COUNT, if specified, gives the initial value for the abbrev's
122 usage-count, which is incremented each time the abbrev is used.
123 \(The default is zero.)
125 SYSTEM-FLAG, if non-nil, says that this is a "system" abbreviation
126 which should not be saved in the user's abbreviation file. */)
127 (table
, name
, expansion
, hook
, count
, system_flag
)
128 Lisp_Object table
, name
, expansion
, hook
, count
, system_flag
;
130 Lisp_Object sym
, oexp
, ohook
, tem
;
131 CHECK_VECTOR (table
);
135 count
= make_number (0);
137 CHECK_NUMBER (count
);
139 sym
= Fintern (name
, table
);
141 oexp
= SYMBOL_VALUE (sym
);
142 ohook
= XSYMBOL (sym
)->function
;
143 if (!((EQ (oexp
, expansion
)
144 || (STRINGP (oexp
) && STRINGP (expansion
)
145 && (tem
= Fstring_equal (oexp
, expansion
), !NILP (tem
))))
148 || (tem
= Fequal (ohook
, hook
), !NILP (tem
))))
149 && NILP (system_flag
))
152 Fset (sym
, expansion
);
155 if (! NILP (system_flag
))
156 Fsetplist (sym
, list4 (Qcount
, count
, Qsystem_type
, system_flag
));
158 Fsetplist (sym
, count
);
163 DEFUN ("define-global-abbrev", Fdefine_global_abbrev
, Sdefine_global_abbrev
, 2, 2,
164 "sDefine global abbrev: \nsExpansion for %s: ",
165 doc
: /* Define ABBREV as a global abbreviation for EXPANSION. */)
167 Lisp_Object abbrev
, expansion
;
169 Fdefine_abbrev (Vglobal_abbrev_table
, Fdowncase (abbrev
),
170 expansion
, Qnil
, make_number (0), Qnil
);
174 DEFUN ("define-mode-abbrev", Fdefine_mode_abbrev
, Sdefine_mode_abbrev
, 2, 2,
175 "sDefine mode abbrev: \nsExpansion for %s: ",
176 doc
: /* Define ABBREV as a mode-specific abbreviation for EXPANSION. */)
178 Lisp_Object abbrev
, expansion
;
180 if (NILP (current_buffer
->abbrev_table
))
181 error ("Major mode has no abbrev table");
183 Fdefine_abbrev (current_buffer
->abbrev_table
, Fdowncase (abbrev
),
184 expansion
, Qnil
, make_number (0), Qnil
);
188 DEFUN ("abbrev-symbol", Fabbrev_symbol
, Sabbrev_symbol
, 1, 2, 0,
189 doc
: /* Return the symbol representing abbrev named ABBREV.
190 This symbol's name is ABBREV, but it is not the canonical symbol of that name;
191 it is interned in an abbrev-table rather than the normal obarray.
192 The value is nil if that abbrev is not defined.
193 Optional second arg TABLE is abbrev table to look it up in.
194 The default is to try buffer's mode-specific abbrev table, then global table. */)
196 Lisp_Object abbrev
, table
;
199 CHECK_STRING (abbrev
);
201 sym
= Fintern_soft (abbrev
, table
);
205 if (!NILP (current_buffer
->abbrev_table
))
206 sym
= Fintern_soft (abbrev
, current_buffer
->abbrev_table
);
207 if (NILP (SYMBOL_VALUE (sym
)))
210 sym
= Fintern_soft (abbrev
, Vglobal_abbrev_table
);
212 if (NILP (SYMBOL_VALUE (sym
)))
217 DEFUN ("abbrev-expansion", Fabbrev_expansion
, Sabbrev_expansion
, 1, 2, 0,
218 doc
: /* Return the string that ABBREV expands into in the current buffer.
219 Optionally specify an abbrev table as second arg;
220 then ABBREV is looked up in that table only. */)
222 Lisp_Object abbrev
, table
;
225 sym
= Fabbrev_symbol (abbrev
, table
);
226 if (NILP (sym
)) return sym
;
227 return Fsymbol_value (sym
);
230 /* Expand the word before point, if it is an abbrev.
231 Returns 1 if an expansion is done. */
233 DEFUN ("expand-abbrev", Fexpand_abbrev
, Sexpand_abbrev
, 0, 0, "",
234 doc
: /* Expand the abbrev before point, if there is an abbrev there.
235 Effective when explicitly called even when `abbrev-mode' is nil.
236 Returns the abbrev symbol, if expansion took place. */)
239 register char *buffer
, *p
;
240 int wordstart
, wordend
;
241 register int wordstart_byte
, wordend_byte
, idx
, idx_byte
;
243 int uccount
= 0, lccount
= 0;
244 register Lisp_Object sym
;
245 Lisp_Object expansion
, hook
, tem
;
247 int multibyte
= ! NILP (current_buffer
->enable_multibyte_characters
);
251 Frun_hooks (1, &Qpre_abbrev_expand_hook
);
254 if (!(BUFFERP (Vabbrev_start_location_buffer
)
255 && XBUFFER (Vabbrev_start_location_buffer
) == current_buffer
))
256 Vabbrev_start_location
= Qnil
;
257 if (!NILP (Vabbrev_start_location
))
259 tem
= Vabbrev_start_location
;
260 CHECK_NUMBER_COERCE_MARKER (tem
);
261 wordstart
= XINT (tem
);
262 Vabbrev_start_location
= Qnil
;
263 if (wordstart
< BEGV
|| wordstart
> ZV
)
265 if (wordstart
&& wordstart
!= ZV
)
267 wordstart_byte
= CHAR_TO_BYTE (wordstart
);
268 if (FETCH_BYTE (wordstart_byte
) == '-')
269 del_range (wordstart
, wordstart
+ 1);
273 wordstart
= scan_words (PT
, -1);
278 wordstart_byte
= CHAR_TO_BYTE (wordstart
);
279 wordend
= scan_words (wordstart
, 1);
286 wordend_byte
= CHAR_TO_BYTE (wordend
);
287 whitecnt
= PT
- wordend
;
288 if (wordend
<= wordstart
)
291 p
= buffer
= (char *) alloca (wordend_byte
- wordstart_byte
);
293 for (idx
= wordstart
, idx_byte
= wordstart_byte
; idx
< wordend
; )
299 FETCH_CHAR_ADVANCE (c
, idx
, idx_byte
);
303 c
= FETCH_BYTE (idx_byte
);
308 c
= DOWNCASE (c
), uccount
++;
309 else if (! NOCASEP (c
))
312 p
+= CHAR_STRING (c
, p
);
317 if (VECTORP (current_buffer
->abbrev_table
))
318 sym
= oblookup (current_buffer
->abbrev_table
, buffer
,
319 wordend
- wordstart
, p
- buffer
);
321 XSETFASTINT (sym
, 0);
323 if (INTEGERP (sym
) || NILP (SYMBOL_VALUE (sym
)))
324 sym
= oblookup (Vglobal_abbrev_table
, buffer
,
325 wordend
- wordstart
, p
- buffer
);
326 if (INTEGERP (sym
) || NILP (SYMBOL_VALUE (sym
)))
329 if (INTERACTIVE
&& !EQ (minibuf_window
, selected_window
))
331 /* Add an undo boundary, in case we are doing this for
332 a self-inserting command which has avoided making one so far. */
338 = Fbuffer_substring (make_number (wordstart
), make_number (wordend
));
340 /* Now sym is the abbrev symbol. */
343 last_abbrev_point
= wordstart
;
345 /* Increment use count. */
346 if (INTEGERP (XSYMBOL (sym
)->plist
))
347 XSETINT (XSYMBOL (sym
)->plist
,
348 XINT (XSYMBOL (sym
)->plist
) + 1);
349 else if (INTEGERP (tem
= Fget (sym
, Qcount
)))
350 Fput (sym
, Qcount
, make_number (XINT (tem
) + 1));
352 /* If this abbrev has an expansion, delete the abbrev
353 and insert the expansion. */
354 expansion
= SYMBOL_VALUE (sym
);
355 if (STRINGP (expansion
))
359 del_range_both (wordstart
, wordstart_byte
, wordend
, wordend_byte
, 1);
361 insert_from_string (expansion
, 0, 0, SCHARS (expansion
),
362 SBYTES (expansion
), 1);
363 SET_PT (PT
+ whitecnt
);
365 if (uccount
&& !lccount
)
367 /* Abbrev was all caps */
368 /* If expansion is multiple words, normally capitalize each word */
369 /* This used to be if (!... && ... >= ...) Fcapitalize; else Fupcase
370 but Megatest 68000 compiler can't handle that */
371 if (!abbrev_all_caps
)
372 if (scan_words (PT
, -1) > scan_words (wordstart
, 1))
374 Fupcase_initials_region (make_number (wordstart
),
378 /* If expansion is one word, or if user says so, upcase it all. */
379 Fupcase_region (make_number (wordstart
), make_number (PT
));
384 /* Abbrev included some caps. Cap first initial of expansion */
385 int pos
= wordstart_byte
;
387 /* Find the initial. */
390 && SYNTAX (FETCH_MULTIBYTE_CHAR (pos
)) != Sword
)
394 && (SYNTAX (*BUF_BYTE_ADDRESS (current_buffer
, pos
))
398 /* Change just that. */
399 pos
= BYTE_TO_CHAR (pos
);
400 Fupcase_initials_region (make_number (pos
), make_number (pos
+ 1));
404 hook
= XSYMBOL (sym
)->function
;
407 Lisp_Object expanded
, prop
;
409 /* If the abbrev has a hook function, run it. */
410 expanded
= call0 (hook
);
412 /* In addition, if the hook function is a symbol with
413 a non-nil `no-self-insert' property, let the value it returned
414 specify whether we consider that an expansion took place. If
415 it returns nil, no expansion has been done. */
419 && (prop
= Fget (hook
, intern ("no-self-insert")),
427 DEFUN ("unexpand-abbrev", Funexpand_abbrev
, Sunexpand_abbrev
, 0, 0, "",
428 doc
: /* Undo the expansion of the last abbrev that expanded.
429 This differs from ordinary undo in that other editing done since then
435 if (last_abbrev_point
< BEGV
436 || last_abbrev_point
> ZV
)
438 SET_PT (last_abbrev_point
);
439 if (STRINGP (Vlast_abbrev_text
))
441 /* This isn't correct if Vlast_abbrev->function was used
442 to do the expansion */
446 val
= SYMBOL_VALUE (Vlast_abbrev
);
448 error ("value of abbrev-symbol must be a string");
450 del_range_byte (PT_BYTE
, PT_BYTE
+ SBYTES (val
), 1);
451 /* Don't inherit properties here; just copy from old contents. */
452 insert_from_string (Vlast_abbrev_text
, 0, 0,
453 SCHARS (Vlast_abbrev_text
),
454 SBYTES (Vlast_abbrev_text
), 0);
455 Vlast_abbrev_text
= Qnil
;
456 /* Total number of characters deleted. */
457 adjust
= ZV
- zv_before
;
459 SET_PT (last_abbrev_point
< opoint
? opoint
+ adjust
: opoint
);
464 write_abbrev (sym
, stream
)
465 Lisp_Object sym
, stream
;
467 Lisp_Object name
, count
, system_flag
;
469 if (INTEGERP (XSYMBOL (sym
)->plist
))
471 count
= XSYMBOL (sym
)->plist
;
476 count
= Fget (sym
, Qcount
);
477 system_flag
= Fget (sym
, Qsystem_type
);
480 if (NILP (SYMBOL_VALUE (sym
)) || ! NILP (system_flag
))
484 name
= SYMBOL_NAME (sym
);
485 Fprin1 (name
, stream
);
487 Fprin1 (SYMBOL_VALUE (sym
), stream
);
489 Fprin1 (XSYMBOL (sym
)->function
, stream
);
491 Fprin1 (count
, stream
);
496 describe_abbrev (sym
, stream
)
497 Lisp_Object sym
, stream
;
499 Lisp_Object one
, count
, system_flag
;
501 if (INTEGERP (XSYMBOL (sym
)->plist
))
503 count
= XSYMBOL (sym
)->plist
;
508 count
= Fget (sym
, Qcount
);
509 system_flag
= Fget (sym
, Qsystem_type
);
512 if (NILP (SYMBOL_VALUE (sym
)))
515 one
= make_number (1);
516 Fprin1 (Fsymbol_name (sym
), stream
);
518 if (!NILP (system_flag
))
520 insert_string (" (sys)");
521 Findent_to (make_number (20), one
);
524 Findent_to (make_number (15), one
);
526 Fprin1 (count
, stream
);
527 Findent_to (make_number (20), one
);
528 Fprin1 (SYMBOL_VALUE (sym
), stream
);
529 if (!NILP (XSYMBOL (sym
)->function
))
531 Findent_to (make_number (45), one
);
532 Fprin1 (XSYMBOL (sym
)->function
, stream
);
537 DEFUN ("insert-abbrev-table-description", Finsert_abbrev_table_description
,
538 Sinsert_abbrev_table_description
, 1, 2, 0,
539 doc
: /* Insert before point a full description of abbrev table named NAME.
540 NAME is a symbol whose value is an abbrev table.
541 If optional 2nd arg READABLE is non-nil, a human-readable description
542 is inserted. Otherwise the description is an expression,
543 a call to `define-abbrev-table', which would
544 define the abbrev table NAME exactly as it is currently defined.
546 Abbrevs marked as "system abbrevs" are omitted. */)
548 Lisp_Object name
, readable
;
554 table
= Fsymbol_value (name
);
555 CHECK_VECTOR (table
);
557 XSETBUFFER (stream
, current_buffer
);
559 if (!NILP (readable
))
562 Fprin1 (name
, stream
);
563 insert_string (")\n\n");
564 map_obarray (table
, describe_abbrev
, stream
);
565 insert_string ("\n\n");
569 insert_string ("(define-abbrev-table '");
570 Fprin1 (name
, stream
);
571 insert_string (" '(\n");
572 map_obarray (table
, write_abbrev
, stream
);
573 insert_string (" ))\n\n");
579 DEFUN ("define-abbrev-table", Fdefine_abbrev_table
, Sdefine_abbrev_table
,
581 doc
: /* Define TABLENAME (a symbol) as an abbrev table name.
582 Define abbrevs in it according to DEFINITIONS, which is a list of elements
583 of the form (ABBREVNAME EXPANSION HOOK USECOUNT SYSTEMFLAG).
584 \(If the list is shorter than that, omitted elements default to nil). */)
585 (tablename
, definitions
)
586 Lisp_Object tablename
, definitions
;
588 Lisp_Object name
, exp
, hook
, count
;
589 Lisp_Object table
, elt
, sys
;
591 CHECK_SYMBOL (tablename
);
592 table
= Fboundp (tablename
);
593 if (NILP (table
) || (table
= Fsymbol_value (tablename
), NILP (table
)))
595 table
= Fmake_abbrev_table ();
596 Fset (tablename
, table
);
597 Vabbrev_table_name_list
= Fcons (tablename
, Vabbrev_table_name_list
);
599 CHECK_VECTOR (table
);
601 for (; CONSP (definitions
); definitions
= XCDR (definitions
))
603 elt
= XCAR (definitions
);
604 name
= Fcar (elt
); elt
= Fcdr (elt
);
605 exp
= Fcar (elt
); elt
= Fcdr (elt
);
606 hook
= Fcar (elt
); elt
= Fcdr (elt
);
607 count
= Fcar (elt
); elt
= Fcdr (elt
);
609 Fdefine_abbrev (table
, name
, exp
, hook
, count
, sys
);
617 Qsystem_type
= intern ("system-type");
618 staticpro (&Qsystem_type
);
620 Qcount
= intern ("count");
623 DEFVAR_LISP ("abbrev-table-name-list", &Vabbrev_table_name_list
,
624 doc
: /* List of symbols whose values are abbrev tables. */);
625 Vabbrev_table_name_list
= Fcons (intern ("fundamental-mode-abbrev-table"),
626 Fcons (intern ("global-abbrev-table"),
629 DEFVAR_LISP ("global-abbrev-table", &Vglobal_abbrev_table
,
630 doc
: /* The abbrev table whose abbrevs affect all buffers.
631 Each buffer may also have a local abbrev table.
632 If it does, the local table overrides the global one
633 for any particular abbrev defined in both. */);
634 Vglobal_abbrev_table
= Fmake_abbrev_table ();
636 DEFVAR_LISP ("fundamental-mode-abbrev-table", &Vfundamental_mode_abbrev_table
,
637 doc
: /* The abbrev table of mode-specific abbrevs for Fundamental Mode. */);
638 Vfundamental_mode_abbrev_table
= Fmake_abbrev_table ();
639 current_buffer
->abbrev_table
= Vfundamental_mode_abbrev_table
;
640 buffer_defaults
.abbrev_table
= Vfundamental_mode_abbrev_table
;
642 DEFVAR_LISP ("last-abbrev", &Vlast_abbrev
,
643 doc
: /* The abbrev-symbol of the last abbrev expanded. See `abbrev-symbol'. */);
645 DEFVAR_LISP ("last-abbrev-text", &Vlast_abbrev_text
,
646 doc
: /* The exact text of the last abbrev expanded.
647 nil if the abbrev has already been unexpanded. */);
649 DEFVAR_INT ("last-abbrev-location", &last_abbrev_point
,
650 doc
: /* The location of the start of the last abbrev expanded. */);
653 Vlast_abbrev_text
= Qnil
;
654 last_abbrev_point
= 0;
656 DEFVAR_LISP ("abbrev-start-location", &Vabbrev_start_location
,
657 doc
: /* Buffer position for `expand-abbrev' to use as the start of the abbrev.
658 When nil, use the word before point as the abbrev.
659 Calling `expand-abbrev' sets this to nil. */);
660 Vabbrev_start_location
= Qnil
;
662 DEFVAR_LISP ("abbrev-start-location-buffer", &Vabbrev_start_location_buffer
,
663 doc
: /* Buffer that `abbrev-start-location' has been set for.
664 Trying to expand an abbrev in any other buffer clears `abbrev-start-location'. */);
665 Vabbrev_start_location_buffer
= Qnil
;
667 DEFVAR_PER_BUFFER ("local-abbrev-table", ¤t_buffer
->abbrev_table
, Qnil
,
668 doc
: /* Local (mode-specific) abbrev table of current buffer. */);
670 DEFVAR_BOOL ("abbrevs-changed", &abbrevs_changed
,
671 doc
: /* Set non-nil by defining or altering any word abbrevs.
672 This causes `save-some-buffers' to offer to save the abbrevs. */);
675 DEFVAR_BOOL ("abbrev-all-caps", &abbrev_all_caps
,
676 doc
: /* *Set non-nil means expand multi-word abbrevs all caps if abbrev was so. */);
679 DEFVAR_LISP ("pre-abbrev-expand-hook", &Vpre_abbrev_expand_hook
,
680 doc
: /* Function or functions to be called before abbrev expansion is done.
681 This is the first thing that `expand-abbrev' does, and so this may change
682 the current abbrev table before abbrev lookup happens. */);
683 Vpre_abbrev_expand_hook
= Qnil
;
684 Qpre_abbrev_expand_hook
= intern ("pre-abbrev-expand-hook");
685 staticpro (&Qpre_abbrev_expand_hook
);
687 defsubr (&Smake_abbrev_table
);
688 defsubr (&Sclear_abbrev_table
);
689 defsubr (&Sdefine_abbrev
);
690 defsubr (&Sdefine_global_abbrev
);
691 defsubr (&Sdefine_mode_abbrev
);
692 defsubr (&Sabbrev_expansion
);
693 defsubr (&Sabbrev_symbol
);
694 defsubr (&Sexpand_abbrev
);
695 defsubr (&Sunexpand_abbrev
);
696 defsubr (&Sinsert_abbrev_table_description
);
697 defsubr (&Sdefine_abbrev_table
);