*** empty log message ***
[emacs.git] / src / abbrev.c
blobdabc03b2a556f915693caf7971b4f19c39a77543
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)
10 any later version.
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. */
23 #include <config.h>
24 #include <stdio.h>
26 #include "lisp.h"
27 #include "commands.h"
28 #include "buffer.h"
29 #include "window.h"
30 #include "charset.h"
31 #include "syntax.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 */
57 int abbrevs_changed;
59 int abbrev_all_caps;
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. */)
98 (table)
99 Lisp_Object table;
101 int i, size;
103 CHECK_VECTOR (table);
104 size = XVECTOR (table)->size;
105 abbrevs_changed = 1;
106 for (i = 0; i < size; i++)
107 XVECTOR (table)->contents[i] = make_number (0);
108 return Qnil;
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);
132 CHECK_STRING (name);
134 if (NILP (count))
135 count = make_number (0);
136 else
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))))
147 (EQ (ohook, hook)
148 || (tem = Fequal (ohook, hook), !NILP (tem))))
149 && NILP (system_flag))
150 abbrevs_changed = 1;
152 Fset (sym, expansion);
153 Ffset (sym, hook);
155 if (! NILP (system_flag))
156 Fsetplist (sym, list4 (Qcount, count, Qsystem_type, system_flag));
157 else
158 Fsetplist (sym, count);
160 return name;
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. */)
166 (abbrev, expansion)
167 Lisp_Object abbrev, expansion;
169 Fdefine_abbrev (Vglobal_abbrev_table, Fdowncase (abbrev),
170 expansion, Qnil, make_number (0), Qnil);
171 return abbrev;
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. */)
177 (abbrev, 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);
185 return abbrev;
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. */)
195 (abbrev, table)
196 Lisp_Object abbrev, table;
198 Lisp_Object sym;
199 CHECK_STRING (abbrev);
200 if (!NILP (table))
201 sym = Fintern_soft (abbrev, table);
202 else
204 sym = Qnil;
205 if (!NILP (current_buffer->abbrev_table))
206 sym = Fintern_soft (abbrev, current_buffer->abbrev_table);
207 if (NILP (SYMBOL_VALUE (sym)))
208 sym = Qnil;
209 if (NILP (sym))
210 sym = Fintern_soft (abbrev, Vglobal_abbrev_table);
212 if (NILP (SYMBOL_VALUE (sym)))
213 return Qnil;
214 return 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. */)
221 (abbrev, table)
222 Lisp_Object abbrev, table;
224 Lisp_Object sym;
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;
242 int whitecnt;
243 int uccount = 0, lccount = 0;
244 register Lisp_Object sym;
245 Lisp_Object expansion, hook, tem;
246 Lisp_Object value;
247 int multibyte = ! NILP (current_buffer->enable_multibyte_characters);
249 value = Qnil;
251 Frun_hooks (1, &Qpre_abbrev_expand_hook);
253 wordstart = 0;
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)
264 wordstart = 0;
265 if (wordstart && wordstart != ZV)
267 wordstart_byte = CHAR_TO_BYTE (wordstart);
268 if (FETCH_BYTE (wordstart_byte) == '-')
269 del_range (wordstart, wordstart + 1);
272 if (!wordstart)
273 wordstart = scan_words (PT, -1);
275 if (!wordstart)
276 return value;
278 wordstart_byte = CHAR_TO_BYTE (wordstart);
279 wordend = scan_words (wordstart, 1);
280 if (!wordend)
281 return value;
283 if (wordend > PT)
284 wordend = PT;
286 wordend_byte = CHAR_TO_BYTE (wordend);
287 whitecnt = PT - wordend;
288 if (wordend <= wordstart)
289 return value;
291 p = buffer = (char *) alloca (wordend_byte - wordstart_byte);
293 for (idx = wordstart, idx_byte = wordstart_byte; idx < wordend; )
295 register int c;
297 if (multibyte)
299 FETCH_CHAR_ADVANCE (c, idx, idx_byte);
301 else
303 c = FETCH_BYTE (idx_byte);
304 idx++, idx_byte++;
307 if (UPPERCASEP (c))
308 c = DOWNCASE (c), uccount++;
309 else if (! NOCASEP (c))
310 lccount++;
311 if (multibyte)
312 p += CHAR_STRING (c, p);
313 else
314 *p++ = c;
317 if (VECTORP (current_buffer->abbrev_table))
318 sym = oblookup (current_buffer->abbrev_table, buffer,
319 wordend - wordstart, p - buffer);
320 else
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)))
327 return value;
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. */
333 SET_PT (wordend);
334 Fundo_boundary ();
337 Vlast_abbrev_text
338 = Fbuffer_substring (make_number (wordstart), make_number (wordend));
340 /* Now sym is the abbrev symbol. */
341 Vlast_abbrev = sym;
342 value = sym;
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))
357 SET_PT (wordstart);
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),
375 make_number (PT));
376 goto caped;
378 /* If expansion is one word, or if user says so, upcase it all. */
379 Fupcase_region (make_number (wordstart), make_number (PT));
380 caped: ;
382 else if (uccount)
384 /* Abbrev included some caps. Cap first initial of expansion */
385 int pos = wordstart_byte;
387 /* Find the initial. */
388 while (pos < PT_BYTE
389 && SYNTAX (*BUF_BYTE_ADDRESS (current_buffer, pos)) != Sword)
390 pos++;
392 /* Change just that. */
393 pos = BYTE_TO_CHAR (pos);
394 Fupcase_initials_region (make_number (pos), make_number (pos + 1));
398 hook = XSYMBOL (sym)->function;
399 if (!NILP (hook))
401 Lisp_Object expanded, prop;
403 /* If the abbrev has a hook function, run it. */
404 expanded = call0 (hook);
406 /* In addition, if the hook function is a symbol with
407 a non-nil `no-self-insert' property, let the value it returned
408 specify whether we consider that an expansion took place. If
409 it returns nil, no expansion has been done. */
411 if (SYMBOLP (hook)
412 && NILP (expanded)
413 && (prop = Fget (hook, intern ("no-self-insert")),
414 !NILP (prop)))
415 value = Qnil;
418 return value;
421 DEFUN ("unexpand-abbrev", Funexpand_abbrev, Sunexpand_abbrev, 0, 0, "",
422 doc: /* Undo the expansion of the last abbrev that expanded.
423 This differs from ordinary undo in that other editing done since then
424 is not undone. */)
427 int opoint = PT;
428 int adjust = 0;
429 if (last_abbrev_point < BEGV
430 || last_abbrev_point > ZV)
431 return Qnil;
432 SET_PT (last_abbrev_point);
433 if (STRINGP (Vlast_abbrev_text))
435 /* This isn't correct if Vlast_abbrev->function was used
436 to do the expansion */
437 Lisp_Object val;
438 int zv_before;
440 val = SYMBOL_VALUE (Vlast_abbrev);
441 if (!STRINGP (val))
442 error ("value of abbrev-symbol must be a string");
443 zv_before = ZV;
444 del_range_byte (PT_BYTE, PT_BYTE + SBYTES (val), 1);
445 /* Don't inherit properties here; just copy from old contents. */
446 insert_from_string (Vlast_abbrev_text, 0, 0,
447 SCHARS (Vlast_abbrev_text),
448 SBYTES (Vlast_abbrev_text), 0);
449 Vlast_abbrev_text = Qnil;
450 /* Total number of characters deleted. */
451 adjust = ZV - zv_before;
453 SET_PT (last_abbrev_point < opoint ? opoint + adjust : opoint);
454 return Qnil;
457 static void
458 write_abbrev (sym, stream)
459 Lisp_Object sym, stream;
461 Lisp_Object name, count, system_flag;
463 if (INTEGERP (XSYMBOL (sym)->plist))
465 count = XSYMBOL (sym)->plist;
466 system_flag = Qnil;
468 else
470 count = Fget (sym, Qcount);
471 system_flag = Fget (sym, Qsystem_type);
474 if (NILP (SYMBOL_VALUE (sym)) || ! NILP (system_flag))
475 return;
477 insert (" (", 5);
478 name = SYMBOL_NAME (sym);
479 Fprin1 (name, stream);
480 insert (" ", 1);
481 Fprin1 (SYMBOL_VALUE (sym), stream);
482 insert (" ", 1);
483 Fprin1 (XSYMBOL (sym)->function, stream);
484 insert (" ", 1);
485 Fprin1 (count, stream);
486 insert (")\n", 2);
489 static void
490 describe_abbrev (sym, stream)
491 Lisp_Object sym, stream;
493 Lisp_Object one, count, system_flag;
495 if (INTEGERP (XSYMBOL (sym)->plist))
497 count = XSYMBOL (sym)->plist;
498 system_flag = Qnil;
500 else
502 count = Fget (sym, Qcount);
503 system_flag = Fget (sym, Qsystem_type);
506 if (NILP (SYMBOL_VALUE (sym)))
507 return;
509 one = make_number (1);
510 Fprin1 (Fsymbol_name (sym), stream);
512 if (!NILP (system_flag))
514 insert_string (" (sys)");
515 Findent_to (make_number (20), one);
517 else
518 Findent_to (make_number (15), one);
520 Fprin1 (count, stream);
521 Findent_to (make_number (20), one);
522 Fprin1 (SYMBOL_VALUE (sym), stream);
523 if (!NILP (XSYMBOL (sym)->function))
525 Findent_to (make_number (45), one);
526 Fprin1 (XSYMBOL (sym)->function, stream);
528 Fterpri (stream);
531 DEFUN ("insert-abbrev-table-description", Finsert_abbrev_table_description,
532 Sinsert_abbrev_table_description, 1, 2, 0,
533 doc: /* Insert before point a full description of abbrev table named NAME.
534 NAME is a symbol whose value is an abbrev table.
535 If optional 2nd arg READABLE is non-nil, a human-readable description
536 is inserted. Otherwise the description is an expression,
537 a call to `define-abbrev-table', which would
538 define the abbrev table NAME exactly as it is currently defined.
540 Abbrevs marked as "system abbrevs" are omitted. */)
541 (name, readable)
542 Lisp_Object name, readable;
544 Lisp_Object table;
545 Lisp_Object stream;
547 CHECK_SYMBOL (name);
548 table = Fsymbol_value (name);
549 CHECK_VECTOR (table);
551 XSETBUFFER (stream, current_buffer);
553 if (!NILP (readable))
555 insert_string ("(");
556 Fprin1 (name, stream);
557 insert_string (")\n\n");
558 map_obarray (table, describe_abbrev, stream);
559 insert_string ("\n\n");
561 else
563 insert_string ("(define-abbrev-table '");
564 Fprin1 (name, stream);
565 insert_string (" '(\n");
566 map_obarray (table, write_abbrev, stream);
567 insert_string (" ))\n\n");
570 return Qnil;
573 DEFUN ("define-abbrev-table", Fdefine_abbrev_table, Sdefine_abbrev_table,
574 2, 2, 0,
575 doc: /* Define TABLENAME (a symbol) as an abbrev table name.
576 Define abbrevs in it according to DEFINITIONS, which is a list of elements
577 of the form (ABBREVNAME EXPANSION HOOK USECOUNT SYSTEMFLAG).
578 \(If the list is shorter than that, omitted elements default to nil). */)
579 (tablename, definitions)
580 Lisp_Object tablename, definitions;
582 Lisp_Object name, exp, hook, count;
583 Lisp_Object table, elt, sys;
585 CHECK_SYMBOL (tablename);
586 table = Fboundp (tablename);
587 if (NILP (table) || (table = Fsymbol_value (tablename), NILP (table)))
589 table = Fmake_abbrev_table ();
590 Fset (tablename, table);
591 Vabbrev_table_name_list = Fcons (tablename, Vabbrev_table_name_list);
593 CHECK_VECTOR (table);
595 for (; CONSP (definitions); definitions = XCDR (definitions))
597 elt = XCAR (definitions);
598 name = Fcar (elt); elt = Fcdr (elt);
599 exp = Fcar (elt); elt = Fcdr (elt);
600 hook = Fcar (elt); elt = Fcdr (elt);
601 count = Fcar (elt); elt = Fcdr (elt);
602 sys = Fcar (elt);
603 Fdefine_abbrev (table, name, exp, hook, count, sys);
605 return Qnil;
608 void
609 syms_of_abbrev ()
611 Qsystem_type = intern ("system-type");
612 staticpro (&Qsystem_type);
614 Qcount = intern ("count");
615 staticpro (&Qcount);
617 DEFVAR_LISP ("abbrev-table-name-list", &Vabbrev_table_name_list,
618 doc: /* List of symbols whose values are abbrev tables. */);
619 Vabbrev_table_name_list = Fcons (intern ("fundamental-mode-abbrev-table"),
620 Fcons (intern ("global-abbrev-table"),
621 Qnil));
623 DEFVAR_LISP ("global-abbrev-table", &Vglobal_abbrev_table,
624 doc: /* The abbrev table whose abbrevs affect all buffers.
625 Each buffer may also have a local abbrev table.
626 If it does, the local table overrides the global one
627 for any particular abbrev defined in both. */);
628 Vglobal_abbrev_table = Fmake_abbrev_table ();
630 DEFVAR_LISP ("fundamental-mode-abbrev-table", &Vfundamental_mode_abbrev_table,
631 doc: /* The abbrev table of mode-specific abbrevs for Fundamental Mode. */);
632 Vfundamental_mode_abbrev_table = Fmake_abbrev_table ();
633 current_buffer->abbrev_table = Vfundamental_mode_abbrev_table;
634 buffer_defaults.abbrev_table = Vfundamental_mode_abbrev_table;
636 DEFVAR_LISP ("last-abbrev", &Vlast_abbrev,
637 doc: /* The abbrev-symbol of the last abbrev expanded. See `abbrev-symbol'. */);
639 DEFVAR_LISP ("last-abbrev-text", &Vlast_abbrev_text,
640 doc: /* The exact text of the last abbrev expanded.
641 nil if the abbrev has already been unexpanded. */);
643 DEFVAR_INT ("last-abbrev-location", &last_abbrev_point,
644 doc: /* The location of the start of the last abbrev expanded. */);
646 Vlast_abbrev = Qnil;
647 Vlast_abbrev_text = Qnil;
648 last_abbrev_point = 0;
650 DEFVAR_LISP ("abbrev-start-location", &Vabbrev_start_location,
651 doc: /* Buffer position for `expand-abbrev' to use as the start of the abbrev.
652 When nil, use the word before point as the abbrev.
653 Calling `expand-abbrev' sets this to nil. */);
654 Vabbrev_start_location = Qnil;
656 DEFVAR_LISP ("abbrev-start-location-buffer", &Vabbrev_start_location_buffer,
657 doc: /* Buffer that `abbrev-start-location' has been set for.
658 Trying to expand an abbrev in any other buffer clears `abbrev-start-location'. */);
659 Vabbrev_start_location_buffer = Qnil;
661 DEFVAR_PER_BUFFER ("local-abbrev-table", &current_buffer->abbrev_table, Qnil,
662 doc: /* Local (mode-specific) abbrev table of current buffer. */);
664 DEFVAR_BOOL ("abbrevs-changed", &abbrevs_changed,
665 doc: /* Set non-nil by defining or altering any word abbrevs.
666 This causes `save-some-buffers' to offer to save the abbrevs. */);
667 abbrevs_changed = 0;
669 DEFVAR_BOOL ("abbrev-all-caps", &abbrev_all_caps,
670 doc: /* *Set non-nil means expand multi-word abbrevs all caps if abbrev was so. */);
671 abbrev_all_caps = 0;
673 DEFVAR_LISP ("pre-abbrev-expand-hook", &Vpre_abbrev_expand_hook,
674 doc: /* Function or functions to be called before abbrev expansion is done.
675 This is the first thing that `expand-abbrev' does, and so this may change
676 the current abbrev table before abbrev lookup happens. */);
677 Vpre_abbrev_expand_hook = Qnil;
678 Qpre_abbrev_expand_hook = intern ("pre-abbrev-expand-hook");
679 staticpro (&Qpre_abbrev_expand_hook);
681 defsubr (&Smake_abbrev_table);
682 defsubr (&Sclear_abbrev_table);
683 defsubr (&Sdefine_abbrev);
684 defsubr (&Sdefine_global_abbrev);
685 defsubr (&Sdefine_mode_abbrev);
686 defsubr (&Sabbrev_expansion);
687 defsubr (&Sabbrev_symbol);
688 defsubr (&Sexpand_abbrev);
689 defsubr (&Sunexpand_abbrev);
690 defsubr (&Sinsert_abbrev_table_description);
691 defsubr (&Sdefine_abbrev_table);