src/abbrev.c

   1 /* Primitives for word-abbrev mode.
   2    Copyright (C) 1985, 1986, 1993, 1996, 1998 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Emacs.
   5
   6 GNU Emacs is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Emacs is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Emacs; see the file COPYING.  If not, write to
  18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21
  22 #include <config.h>
  23 #include <stdio.h>
  24 #include "lisp.h"
  25 #include "commands.h"
  26 #include "buffer.h"
  27 #include "window.h"
  28 #include "syntax.h"
  29
  30 /* An abbrev table is an obarray.
  31  Each defined abbrev is represented by a symbol in that obarray
  32  whose print name is the abbreviation.
  33  The symbol's value is a string which is the expansion.
  34  If its function definition is non-nil, it is called
  35   after the expansion is done.
  36  The plist slot of the abbrev symbol is its usage count. */
  37
  38 /* List of all abbrev-table name symbols:
  39  symbols whose values are abbrev tables.  */
  40
  41 Lisp_Object Vabbrev_table_name_list;
  42
  43 /* The table of global abbrevs.  These are in effect
  44  in any buffer in which abbrev mode is turned on. */
  45
  46 Lisp_Object Vglobal_abbrev_table;
  47
  48 /* The local abbrev table used by default (in Fundamental Mode buffers) */
  49
  50 Lisp_Object Vfundamental_mode_abbrev_table;
  51
  52 /* Set nonzero when an abbrev definition is changed */
  53
  54 int abbrevs_changed;
  55
  56 int abbrev_all_caps;
  57
  58 /* Non-nil => use this location as the start of abbrev to expand
  59  (rather than taking the word before point as the abbrev) */
  60
  61 Lisp_Object Vabbrev_start_location;
  62
  63 /* Buffer that Vabbrev_start_location applies to */
  64 Lisp_Object Vabbrev_start_location_buffer;
  65
  66 /* The symbol representing the abbrev most recently expanded */
  67
  68 Lisp_Object Vlast_abbrev;
  69
  70 /* A string for the actual text of the abbrev most recently expanded.
  71    This has more info than Vlast_abbrev since case is significant.  */
  72
  73 Lisp_Object Vlast_abbrev_text;
  74
  75 /* Character address of start of last abbrev expanded */
  76
  77 int last_abbrev_point;
  78
  79 /* Hook to run before expanding any abbrev.  */
  80
  81 Lisp_Object Vpre_abbrev_expand_hook, Qpre_abbrev_expand_hook;
  82 \f
  83 DEFUN ("make-abbrev-table", Fmake_abbrev_table, Smake_abbrev_table, 0, 0, 0,
  84   "Create a new, empty abbrev table object.")
  85   ()
  86 {
  87   return Fmake_vector (make_number (59), make_number (0));
  88 }
  89
  90 DEFUN ("clear-abbrev-table", Fclear_abbrev_table, Sclear_abbrev_table, 1, 1, 0,
  91   "Undefine all abbrevs in abbrev table TABLE, leaving it empty.")
  92   (table)
  93      Lisp_Object table;
  94 {
  95   int i, size;
  96
  97   CHECK_VECTOR (table, 0);
  98   size = XVECTOR (table)->size;
  99   abbrevs_changed = 1;
 100   for (i = 0; i < size; i++)
 101     XVECTOR (table)->contents[i] = make_number (0);
 102   return Qnil;
 103 }
 104 \f
 105 DEFUN ("define-abbrev", Fdefine_abbrev, Sdefine_abbrev, 3, 5, 0,
 106   "Define an abbrev in TABLE named NAME, to expand to EXPANSION and call HOOK.\n\
 107 NAME must be a string.\n\
 108 EXPANSION should usually be a string.\n\
 109 To undefine an abbrev, define it with EXPANSION = nil.\n\
 110 If HOOK is non-nil, it should be a function of no arguments;\n\
 111 it is called after EXPANSION is inserted.\n\
 112 If EXPANSION is not a string, the abbrev is a special one,\n\
 113  which does not expand in the usual way but only runs HOOK.")
 114   (table, name, expansion, hook, count)
 115      Lisp_Object table, name, expansion, hook, count;
 116 {
 117   Lisp_Object sym, oexp, ohook, tem;
 118   CHECK_VECTOR (table, 0);
 119   CHECK_STRING (name, 1);
 120
 121   if (NILP (count))
 122     count = make_number (0);
 123   else
 124     CHECK_NUMBER (count, 0);
 125
 126   sym = Fintern (name, table);
 127
 128   oexp = XSYMBOL (sym)->value;
 129   ohook = XSYMBOL (sym)->function;
 130   if (!((EQ (oexp, expansion)
 131          || (STRINGP (oexp) && STRINGP (expansion)
 132              && (tem = Fstring_equal (oexp, expansion), !NILP (tem))))
 133         &&
 134         (EQ (ohook, hook)
 135          || (tem = Fequal (ohook, hook), !NILP (tem)))))
 136     abbrevs_changed = 1;
 137
 138   Fset (sym, expansion);
 139   Ffset (sym, hook);
 140   Fsetplist (sym, count);
 141
 142   return name;
 143 }
 144
 145 DEFUN ("define-global-abbrev", Fdefine_global_abbrev, Sdefine_global_abbrev, 2, 2,
 146   "sDefine global abbrev: \nsExpansion for %s: ",
 147   "Define ABBREV as a global abbreviation for EXPANSION.")
 148   (abbrev, expansion)
 149      Lisp_Object abbrev, expansion;
 150 {
 151   Fdefine_abbrev (Vglobal_abbrev_table, Fdowncase (abbrev),
 152                   expansion, Qnil, make_number (0));
 153   return abbrev;
 154 }
 155
 156 DEFUN ("define-mode-abbrev", Fdefine_mode_abbrev, Sdefine_mode_abbrev, 2, 2,
 157   "sDefine mode abbrev: \nsExpansion for %s: ",
 158   "Define ABBREV as a mode-specific abbreviation for EXPANSION.")
 159   (abbrev, expansion)
 160      Lisp_Object abbrev, expansion;
 161 {
 162   if (NILP (current_buffer->abbrev_table))
 163     error ("Major mode has no abbrev table");
 164
 165   Fdefine_abbrev (current_buffer->abbrev_table, Fdowncase (abbrev),
 166                   expansion, Qnil, make_number (0));
 167   return abbrev;
 168 }
 169
 170 DEFUN ("abbrev-symbol", Fabbrev_symbol, Sabbrev_symbol, 1, 2, 0,
 171   "Return the symbol representing abbrev named ABBREV.\n\
 172 This symbol's name is ABBREV, but it is not the canonical symbol of that name;\n\
 173 it is interned in an abbrev-table rather than the normal obarray.\n\
 174 The value is nil if that abbrev is not defined.\n\
 175 Optional second arg TABLE is abbrev table to look it up in.\n\
 176 The default is to try buffer's mode-specific abbrev table, then global table.")
 177   (abbrev, table)
 178      Lisp_Object abbrev, table;
 179 {
 180   Lisp_Object sym;
 181   CHECK_STRING (abbrev, 0);
 182   if (!NILP (table))
 183     sym = Fintern_soft (abbrev, table);
 184   else
 185     {
 186       sym = Qnil;
 187       if (!NILP (current_buffer->abbrev_table))
 188         sym = Fintern_soft (abbrev, current_buffer->abbrev_table);
 189       if (NILP (XSYMBOL (sym)->value))
 190         sym = Qnil;
 191       if (NILP (sym))
 192         sym = Fintern_soft (abbrev, Vglobal_abbrev_table);
 193     }
 194   if (NILP (XSYMBOL (sym)->value)) return Qnil;
 195   return sym;
 196 }
 197
 198 DEFUN ("abbrev-expansion", Fabbrev_expansion, Sabbrev_expansion, 1, 2, 0,
 199   "Return the string that ABBREV expands into in the current buffer.\n\
 200 Optionally specify an abbrev table as second arg;\n\
 201 then ABBREV is looked up in that table only.")
 202   (abbrev, table)
 203      Lisp_Object abbrev, table;
 204 {
 205   Lisp_Object sym;
 206   sym = Fabbrev_symbol (abbrev, table);
 207   if (NILP (sym)) return sym;
 208   return Fsymbol_value (sym);
 209 }
 210 \f
 211 /* Expand the word before point, if it is an abbrev.
 212   Returns 1 if an expansion is done. */
 213
 214 DEFUN ("expand-abbrev", Fexpand_abbrev, Sexpand_abbrev, 0, 0, "",
 215   "Expand the abbrev before point, if there is an abbrev there.\n\
 216 Effective when explicitly called even when `abbrev-mode' is nil.\n\
 217 Returns the abbrev symbol, if expansion took place.")
 218   ()
 219 {
 220   register char *buffer, *p;
 221   int wordstart, wordend;
 222   register int wordstart_byte, wordend_byte, idx;
 223   int whitecnt;
 224   int uccount = 0, lccount = 0;
 225   register Lisp_Object sym;
 226   Lisp_Object expansion, hook, tem;
 227   int oldmodiff = MODIFF;
 228   Lisp_Object value;
 229
 230   value = Qnil;
 231
 232   if (!NILP (Vrun_hooks))
 233     call1 (Vrun_hooks, Qpre_abbrev_expand_hook);
 234
 235   wordstart = 0;
 236   if (!(BUFFERP (Vabbrev_start_location_buffer)
 237         && XBUFFER (Vabbrev_start_location_buffer) == current_buffer))
 238     Vabbrev_start_location = Qnil;
 239   if (!NILP (Vabbrev_start_location))
 240     {
 241       tem = Vabbrev_start_location;
 242       CHECK_NUMBER_COERCE_MARKER (tem, 0);
 243       wordstart = XINT (tem);
 244       Vabbrev_start_location = Qnil;
 245       if (wordstart < BEGV || wordstart > ZV)
 246         wordstart = 0;
 247       if (wordstart && wordstart != ZV)
 248         {
 249           wordstart_byte = CHAR_TO_BYTE (wordstart);
 250           if (FETCH_BYTE (wordstart_byte) == '-')
 251             del_range (wordstart, wordstart + 1);
 252         }
 253     }
 254   if (!wordstart)
 255     wordstart = scan_words (PT, -1);
 256
 257   if (!wordstart)
 258     return value;
 259
 260   wordstart_byte = CHAR_TO_BYTE (wordstart);
 261   wordend = scan_words (wordstart, 1);
 262   if (!wordend)
 263     return value;
 264
 265   if (wordend > PT)
 266     wordend = PT;
 267
 268   wordend_byte = CHAR_TO_BYTE (wordend);
 269   whitecnt = PT - wordend;
 270   if (wordend <= wordstart)
 271     return value;
 272
 273   p = buffer = (char *) alloca (wordend_byte - wordstart_byte);
 274
 275   for (idx = wordstart_byte; idx < wordend_byte; idx++)
 276     {
 277       /* ??? This loop needs to go by characters!  */
 278       register int c = FETCH_BYTE (idx);
 279       if (UPPERCASEP (c))
 280         c = DOWNCASE (c), uccount++;
 281       else if (! NOCASEP (c))
 282         lccount++;
 283       *p++ = c;
 284     }
 285
 286   if (VECTORP (current_buffer->abbrev_table))
 287     sym = oblookup (current_buffer->abbrev_table, buffer,
 288                     wordend - wordstart, wordend_byte - wordstart_byte);
 289   else
 290     XSETFASTINT (sym, 0);
 291   if (INTEGERP (sym) || NILP (XSYMBOL (sym)->value))
 292     sym = oblookup (Vglobal_abbrev_table, buffer,
 293                     wordend - wordstart, wordend_byte - wordstart_byte);
 294   if (INTEGERP (sym) || NILP (XSYMBOL (sym)->value))
 295     return value;
 296
 297   if (INTERACTIVE && !EQ (minibuf_window, selected_window))
 298     {
 299       /* Add an undo boundary, in case we are doing this for
 300          a self-inserting command which has avoided making one so far.  */
 301       SET_PT (wordend);
 302       Fundo_boundary ();
 303     }
 304
 305   Vlast_abbrev_text
 306     = Fbuffer_substring (make_number (wordstart), make_number (wordend));
 307
 308   /* Now sym is the abbrev symbol.  */
 309   Vlast_abbrev = sym;
 310   value = sym;
 311   last_abbrev_point = wordstart;
 312
 313   if (INTEGERP (XSYMBOL (sym)->plist))
 314     XSETINT (XSYMBOL (sym)->plist,
 315              XINT (XSYMBOL (sym)->plist) + 1);  /* Increment use count */
 316
 317   /* If this abbrev has an expansion, delete the abbrev
 318      and insert the expansion.  */
 319   expansion = XSYMBOL (sym)->value;
 320   if (STRINGP (expansion))
 321     {
 322       SET_PT (wordstart);
 323
 324       del_range_both (wordstart, wordstart_byte, wordend, wordend_byte, 1);
 325
 326       insert_from_string (expansion, 0, 0, XSTRING (expansion)->size,
 327                           STRING_BYTES (XSTRING (expansion)), 1);
 328       SET_PT (PT + whitecnt);
 329
 330       if (uccount && !lccount)
 331         {
 332           /* Abbrev was all caps */
 333           /* If expansion is multiple words, normally capitalize each word */
 334           /* This used to be if (!... && ... >= ...) Fcapitalize; else Fupcase
 335              but Megatest 68000 compiler can't handle that */
 336           if (!abbrev_all_caps)
 337             if (scan_words (PT, -1) > scan_words (wordstart, 1))
 338               {
 339                 Fupcase_initials_region (make_number (wordstart),
 340                                          make_number (PT));
 341                 goto caped;
 342               }
 343           /* If expansion is one word, or if user says so, upcase it all. */
 344           Fupcase_region (make_number (wordstart), make_number (PT));
 345         caped: ;
 346         }
 347       else if (uccount)
 348         {
 349           /* Abbrev included some caps.  Cap first initial of expansion */
 350           int pos = wordstart_byte;
 351
 352           /* Find the initial.  */
 353           while (pos < PT_BYTE
 354                  && SYNTAX (*BUF_BYTE_ADDRESS (current_buffer, pos)) != Sword)
 355             pos++;
 356
 357           /* Change just that.  */
 358           pos = BYTE_TO_CHAR (pos);
 359           Fupcase_initials_region (make_number (pos), make_number (pos + 1));
 360         }
 361     }
 362
 363   hook = XSYMBOL (sym)->function;
 364   if (!NILP (hook))
 365     call0 (hook);
 366
 367   return value;
 368 }
 369
 370 DEFUN ("unexpand-abbrev", Funexpand_abbrev, Sunexpand_abbrev, 0, 0, "",
 371   "Undo the expansion of the last abbrev that expanded.\n\
 372 This differs from ordinary undo in that other editing done since then\n\
 373 is not undone.")
 374   ()
 375 {
 376   int opoint = PT;
 377   int adjust = 0;
 378   if (last_abbrev_point < BEGV
 379       || last_abbrev_point > ZV)
 380     return Qnil;
 381   SET_PT (last_abbrev_point);
 382   if (STRINGP (Vlast_abbrev_text))
 383     {
 384       /* This isn't correct if Vlast_abbrev->function was used
 385          to do the expansion */
 386       Lisp_Object val;
 387       int zv_before;
 388
 389       val = XSYMBOL (Vlast_abbrev)->value;
 390       if (!STRINGP (val))
 391         error ("value of abbrev-symbol must be a string");
 392       zv_before = ZV;
 393       del_range_byte (PT_BYTE, PT_BYTE + STRING_BYTES (XSTRING (val)), 1);
 394       /* Don't inherit properties here; just copy from old contents.  */
 395       insert_from_string (Vlast_abbrev_text, 0, 0,
 396                           XSTRING (Vlast_abbrev_text)->size,
 397                           STRING_BYTES (XSTRING (Vlast_abbrev_text)), 0);
 398       Vlast_abbrev_text = Qnil;
 399       /* Total number of characters deleted.  */
 400       adjust = ZV - zv_before;
 401     }
 402   SET_PT (last_abbrev_point < opoint ? opoint - adjust : opoint);
 403   return Qnil;
 404 }
 405 \f
 406 static void
 407 write_abbrev (sym, stream)
 408      Lisp_Object sym, stream;
 409 {
 410   Lisp_Object name;
 411   if (NILP (XSYMBOL (sym)->value))
 412     return;
 413   insert ("    (", 5);
 414   XSETSTRING (name, XSYMBOL (sym)->name);
 415   Fprin1 (name, stream);
 416   insert (" ", 1);
 417   Fprin1 (XSYMBOL (sym)->value, stream);
 418   insert (" ", 1);
 419   Fprin1 (XSYMBOL (sym)->function, stream);
 420   insert (" ", 1);
 421   Fprin1 (XSYMBOL (sym)->plist, stream);
 422   insert (")\n", 2);
 423 }
 424
 425 static void
 426 describe_abbrev (sym, stream)
 427      Lisp_Object sym, stream;
 428 {
 429   Lisp_Object one;
 430
 431   if (NILP (XSYMBOL (sym)->value))
 432     return;
 433   one = make_number (1);
 434   Fprin1 (Fsymbol_name (sym), stream);
 435   Findent_to (make_number (15), one);
 436   Fprin1 (XSYMBOL (sym)->plist, stream);
 437   Findent_to (make_number (20), one);
 438   Fprin1 (XSYMBOL (sym)->value, stream);
 439   if (!NILP (XSYMBOL (sym)->function))
 440     {
 441       Findent_to (make_number (45), one);
 442       Fprin1 (XSYMBOL (sym)->function, stream);
 443     }
 444   Fterpri (stream);
 445 }
 446
 447 DEFUN ("insert-abbrev-table-description", Finsert_abbrev_table_description,
 448   Sinsert_abbrev_table_description, 1, 2, 0,
 449   "Insert before point a full description of abbrev table named NAME.\n\
 450 NAME is a symbol whose value is an abbrev table.\n\
 451 If optional 2nd arg READABLE is non-nil, a human-readable description\n\
 452 is inserted.  Otherwise the description is an expression,\n\
 453 a call to `define-abbrev-table', which would\n\
 454 define the abbrev table NAME exactly as it is currently defined.")
 455   (name, readable)
 456      Lisp_Object name, readable;
 457 {
 458   Lisp_Object table;
 459   Lisp_Object stream;
 460
 461   CHECK_SYMBOL (name, 0);
 462   table = Fsymbol_value (name);
 463   CHECK_VECTOR (table, 0);
 464
 465   XSETBUFFER (stream, current_buffer);
 466
 467   if (!NILP (readable))
 468     {
 469       insert_string ("(");
 470       Fprin1 (name, stream);
 471       insert_string (")\n\n");
 472       map_obarray (table, describe_abbrev, stream);
 473       insert_string ("\n\n");
 474     }
 475   else
 476     {
 477       insert_string ("(define-abbrev-table '");
 478       Fprin1 (name, stream);
 479       insert_string (" '(\n");
 480       map_obarray (table, write_abbrev, stream);
 481       insert_string ("    ))\n\n");
 482     }
 483
 484   return Qnil;
 485 }
 486 \f
 487 DEFUN ("define-abbrev-table", Fdefine_abbrev_table, Sdefine_abbrev_table,
 488        2, 2, 0,
 489   "Define TABLENAME (a symbol) as an abbrev table name.\n\
 490 Define abbrevs in it according to DEFINITIONS, which is a list of elements\n\
 491 of the form (ABBREVNAME EXPANSION HOOK USECOUNT).")
 492   (tablename, definitions)
 493      Lisp_Object tablename, definitions;
 494 {
 495   Lisp_Object name, exp, hook, count;
 496   Lisp_Object table, elt;
 497
 498   CHECK_SYMBOL (tablename, 0);
 499   table = Fboundp (tablename);
 500   if (NILP (table) || (table = Fsymbol_value (tablename), NILP (table)))
 501     {
 502       table = Fmake_abbrev_table ();
 503       Fset (tablename, table);
 504       Vabbrev_table_name_list = Fcons (tablename, Vabbrev_table_name_list);
 505     }
 506   CHECK_VECTOR (table, 0);
 507
 508   for (; !NILP (definitions); definitions = Fcdr (definitions))
 509     {
 510       elt = Fcar (definitions);
 511       name  = Fcar (elt);       elt = Fcdr (elt);
 512       exp   = Fcar (elt);       elt = Fcdr (elt);
 513       hook  = Fcar (elt);       elt = Fcdr (elt);
 514       count = Fcar (elt);
 515       Fdefine_abbrev (table, name, exp, hook, count);
 516     }
 517   return Qnil;
 518 }
 519 \f
 520 void
 521 syms_of_abbrev ()
 522 {
 523   DEFVAR_LISP ("abbrev-table-name-list", &Vabbrev_table_name_list,
 524     "List of symbols whose values are abbrev tables.");
 525   Vabbrev_table_name_list = Fcons (intern ("fundamental-mode-abbrev-table"),
 526                                    Fcons (intern ("global-abbrev-table"),
 527                                           Qnil));
 528
 529   DEFVAR_LISP ("global-abbrev-table", &Vglobal_abbrev_table,
 530     "The abbrev table whose abbrevs affect all buffers.\n\
 531 Each buffer may also have a local abbrev table.\n\
 532 If it does, the local table overrides the global one\n\
 533 for any particular abbrev defined in both.");
 534   Vglobal_abbrev_table = Fmake_abbrev_table ();
 535
 536   DEFVAR_LISP ("fundamental-mode-abbrev-table", &Vfundamental_mode_abbrev_table,
 537     "The abbrev table of mode-specific abbrevs for Fundamental Mode.");
 538   Vfundamental_mode_abbrev_table = Fmake_abbrev_table ();
 539   current_buffer->abbrev_table = Vfundamental_mode_abbrev_table;
 540
 541   DEFVAR_LISP ("last-abbrev", &Vlast_abbrev,
 542     "The abbrev-symbol of the last abbrev expanded.  See `abbrev-symbol'.");
 543
 544   DEFVAR_LISP ("last-abbrev-text", &Vlast_abbrev_text,
 545     "The exact text of the last abbrev expanded.\n\
 546 nil if the abbrev has already been unexpanded.");
 547
 548   DEFVAR_INT ("last-abbrev-location", &last_abbrev_point,
 549     "The location of the start of the last abbrev expanded.");
 550
 551   Vlast_abbrev = Qnil;
 552   Vlast_abbrev_text = Qnil;
 553   last_abbrev_point = 0;
 554
 555   DEFVAR_LISP ("abbrev-start-location", &Vabbrev_start_location,
 556     "Buffer position for `expand-abbrev' to use as the start of the abbrev.\n\
 557 nil means use the word before point as the abbrev.\n\
 558 Calling `expand-abbrev' sets this to nil.");
 559   Vabbrev_start_location = Qnil;
 560
 561   DEFVAR_LISP ("abbrev-start-location-buffer", &Vabbrev_start_location_buffer,
 562     "Buffer that `abbrev-start-location' has been set for.\n\
 563 Trying to expand an abbrev in any other buffer clears `abbrev-start-location'.");
 564   Vabbrev_start_location_buffer = Qnil;
 565
 566   DEFVAR_PER_BUFFER ("local-abbrev-table", &current_buffer->abbrev_table, Qnil,
 567     "Local (mode-specific) abbrev table of current buffer.");
 568
 569   DEFVAR_BOOL ("abbrevs-changed", &abbrevs_changed,
 570     "Set non-nil by defining or altering any word abbrevs.\n\
 571 This causes `save-some-buffers' to offer to save the abbrevs.");
 572   abbrevs_changed = 0;
 573
 574   DEFVAR_BOOL ("abbrev-all-caps", &abbrev_all_caps,
 575     "*Set non-nil means expand multi-word abbrevs all caps if abbrev was so.");
 576   abbrev_all_caps = 0;
 577
 578   DEFVAR_LISP ("pre-abbrev-expand-hook", &Vpre_abbrev_expand_hook,
 579     "Function or functions to be called before abbrev expansion is done.\n\
 580 This is the first thing that `expand-abbrev' does, and so this may change\n\
 581 the current abbrev table before abbrev lookup happens.");
 582   Vpre_abbrev_expand_hook = Qnil;
 583   Qpre_abbrev_expand_hook = intern ("pre-abbrev-expand-hook");
 584   staticpro (&Qpre_abbrev_expand_hook);
 585
 586   defsubr (&Smake_abbrev_table);
 587   defsubr (&Sclear_abbrev_table);
 588   defsubr (&Sdefine_abbrev);
 589   defsubr (&Sdefine_global_abbrev);
 590   defsubr (&Sdefine_mode_abbrev);
 591   defsubr (&Sabbrev_expansion);
 592   defsubr (&Sabbrev_symbol);
 593   defsubr (&Sexpand_abbrev);
 594   defsubr (&Sunexpand_abbrev);
 595   defsubr (&Sinsert_abbrev_table_description);
 596   defsubr (&Sdefine_abbrev_table);
 597 }