src/abbrev.c

   1 /* Primitives for word-abbrev mode.
   2    Copyright (C) 1985, 1986, 1993, 1996, 1998, 2001, 2002, 2003, 2004,
   3                  2005, 2006, 2007 Free Software Foundation, Inc.
   4
   5 This file is part of GNU Emacs.
   6
   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.
  11
  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.
  16
  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., 51 Franklin Street, Fifth Floor,
  20 Boston, MA 02110-1301, USA.  */
  21
  22
  23 #include <config.h>
  24 #include <stdio.h>
  25
  26 #include "lisp.h"
  27 #include "commands.h"
  28 #include "buffer.h"
  29 #include "window.h"
  30 #include "charset.h"
  31 #include "syntax.h"
  32
  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. */
  40
  41 /* List of all abbrev-table name symbols:
  42  symbols whose values are abbrev tables.  */
  43
  44 Lisp_Object Vabbrev_table_name_list;
  45
  46 /* The table of global abbrevs.  These are in effect
  47  in any buffer in which abbrev mode is turned on. */
  48
  49 Lisp_Object Vglobal_abbrev_table;
  50
  51 /* The local abbrev table used by default (in Fundamental Mode buffers) */
  52
  53 Lisp_Object Vfundamental_mode_abbrev_table;
  54
  55 /* Set nonzero when an abbrev definition is changed */
  56
  57 int abbrevs_changed;
  58
  59 int abbrev_all_caps;
  60
  61 /* Non-nil => use this location as the start of abbrev to expand
  62  (rather than taking the word before point as the abbrev) */
  63
  64 Lisp_Object Vabbrev_start_location;
  65
  66 /* Buffer that Vabbrev_start_location applies to */
  67 Lisp_Object Vabbrev_start_location_buffer;
  68
  69 /* The symbol representing the abbrev most recently expanded */
  70
  71 Lisp_Object Vlast_abbrev;
  72
  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.  */
  75
  76 Lisp_Object Vlast_abbrev_text;
  77
  78 /* Character address of start of last abbrev expanded */
  79
  80 EMACS_INT last_abbrev_point;
  81
  82 /* Hook to run before expanding any abbrev.  */
  83
  84 Lisp_Object Vpre_abbrev_expand_hook, Qpre_abbrev_expand_hook;
  85
  86 Lisp_Object Qsystem_type, Qcount, Qforce;
  87 \f
  88 DEFUN ("make-abbrev-table", Fmake_abbrev_table, Smake_abbrev_table, 0, 0, 0,
  89        doc: /* Create a new, empty abbrev table object.  */)
  90      ()
  91 {
  92   /* The value 59 is arbitrary chosen prime number.  */
  93   return Fmake_vector (make_number (59), make_number (0));
  94 }
  95
  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;
 100 {
 101   int i, size;
 102
 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;
 109 }
 110
 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.
 120
 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.)
 124
 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 Unless SYSTEM-FLAG is `force', a system abbreviation will not
 128 overwrite a non-system abbreviation of the same name.  */)
 129      (table, name, expansion, hook, count, system_flag)
 130      Lisp_Object table, name, expansion, hook, count, system_flag;
 131 {
 132   Lisp_Object sym, oexp, ohook, tem;
 133   CHECK_VECTOR (table);
 134   CHECK_STRING (name);
 135
 136   /* If defining a system abbrev, do not overwrite a non-system abbrev
 137      of the same name, unless 'force is used. */
 138   if (!NILP (system_flag) && !EQ (system_flag, Qforce))
 139     {
 140       sym = Fintern_soft (name, table);
 141
 142       if (!NILP (SYMBOL_VALUE (sym)) &&
 143           NILP (Fplist_get (XSYMBOL (sym)->plist, Qsystem_type))) return Qnil;
 144     }
 145
 146   if (NILP (count))
 147     count = make_number (0);
 148   else
 149     CHECK_NUMBER (count);
 150
 151   sym = Fintern (name, table);
 152
 153   oexp = SYMBOL_VALUE (sym);
 154   ohook = XSYMBOL (sym)->function;
 155   if (!((EQ (oexp, expansion)
 156          || (STRINGP (oexp) && STRINGP (expansion)
 157              && (tem = Fstring_equal (oexp, expansion), !NILP (tem))))
 158         &&
 159         (EQ (ohook, hook)
 160          || (tem = Fequal (ohook, hook), !NILP (tem))))
 161       && NILP (system_flag))
 162     abbrevs_changed = 1;
 163
 164   Fset (sym, expansion);
 165   Ffset (sym, hook);
 166
 167   if (! NILP (system_flag))
 168     Fsetplist (sym, list4 (Qcount, count, Qsystem_type, system_flag));
 169   else
 170     Fsetplist (sym, count);
 171
 172   return name;
 173 }
 174
 175 DEFUN ("define-global-abbrev", Fdefine_global_abbrev, Sdefine_global_abbrev, 2, 2,
 176        "sDefine global abbrev: \nsExpansion for %s: ",
 177        doc: /* Define ABBREV as a global abbreviation for EXPANSION.  */)
 178      (abbrev, expansion)
 179      Lisp_Object abbrev, expansion;
 180 {
 181   Fdefine_abbrev (Vglobal_abbrev_table, Fdowncase (abbrev),
 182                   expansion, Qnil, make_number (0), Qnil);
 183   return abbrev;
 184 }
 185
 186 DEFUN ("define-mode-abbrev", Fdefine_mode_abbrev, Sdefine_mode_abbrev, 2, 2,
 187        "sDefine mode abbrev: \nsExpansion for %s: ",
 188        doc: /* Define ABBREV as a mode-specific abbreviation for EXPANSION.  */)
 189      (abbrev, expansion)
 190      Lisp_Object abbrev, expansion;
 191 {
 192   if (NILP (current_buffer->abbrev_table))
 193     error ("Major mode has no abbrev table");
 194
 195   Fdefine_abbrev (current_buffer->abbrev_table, Fdowncase (abbrev),
 196                   expansion, Qnil, make_number (0), Qnil);
 197   return abbrev;
 198 }
 199
 200 DEFUN ("abbrev-symbol", Fabbrev_symbol, Sabbrev_symbol, 1, 2, 0,
 201        doc: /* Return the symbol representing abbrev named ABBREV.
 202 This symbol's name is ABBREV, but it is not the canonical symbol of that name;
 203 it is interned in an abbrev-table rather than the normal obarray.
 204 The value is nil if that abbrev is not defined.
 205 Optional second arg TABLE is abbrev table to look it up in.
 206 The default is to try buffer's mode-specific abbrev table, then global table.  */)
 207      (abbrev, table)
 208      Lisp_Object abbrev, table;
 209 {
 210   Lisp_Object sym;
 211   CHECK_STRING (abbrev);
 212   if (!NILP (table))
 213     sym = Fintern_soft (abbrev, table);
 214   else
 215     {
 216       sym = Qnil;
 217       if (!NILP (current_buffer->abbrev_table))
 218         sym = Fintern_soft (abbrev, current_buffer->abbrev_table);
 219       if (NILP (SYMBOL_VALUE (sym)))
 220         sym = Qnil;
 221       if (NILP (sym))
 222         sym = Fintern_soft (abbrev, Vglobal_abbrev_table);
 223     }
 224   if (NILP (SYMBOL_VALUE (sym)))
 225     return Qnil;
 226   return sym;
 227 }
 228
 229 DEFUN ("abbrev-expansion", Fabbrev_expansion, Sabbrev_expansion, 1, 2, 0,
 230        doc: /* Return the string that ABBREV expands into in the current buffer.
 231 Optionally specify an abbrev table as second arg;
 232 then ABBREV is looked up in that table only.  */)
 233      (abbrev, table)
 234      Lisp_Object abbrev, table;
 235 {
 236   Lisp_Object sym;
 237   sym = Fabbrev_symbol (abbrev, table);
 238   if (NILP (sym)) return sym;
 239   return Fsymbol_value (sym);
 240 }
 241 \f
 242 /* Expand the word before point, if it is an abbrev.
 243   Returns 1 if an expansion is done. */
 244
 245 DEFUN ("expand-abbrev", Fexpand_abbrev, Sexpand_abbrev, 0, 0, "",
 246        doc: /* Expand the abbrev before point, if there is an abbrev there.
 247 Effective when explicitly called even when `abbrev-mode' is nil.
 248 Returns the abbrev symbol, if expansion took place.  */)
 249      ()
 250 {
 251   register char *buffer, *p;
 252   int wordstart, wordend;
 253   register int wordstart_byte, wordend_byte, idx, idx_byte;
 254   int whitecnt;
 255   int uccount = 0, lccount = 0;
 256   register Lisp_Object sym;
 257   Lisp_Object expansion, hook, tem;
 258   Lisp_Object value;
 259   int multibyte = ! NILP (current_buffer->enable_multibyte_characters);
 260
 261   value = Qnil;
 262
 263   Frun_hooks (1, &Qpre_abbrev_expand_hook);
 264
 265   wordstart = 0;
 266   if (!(BUFFERP (Vabbrev_start_location_buffer)
 267         && XBUFFER (Vabbrev_start_location_buffer) == current_buffer))
 268     Vabbrev_start_location = Qnil;
 269   if (!NILP (Vabbrev_start_location))
 270     {
 271       tem = Vabbrev_start_location;
 272       CHECK_NUMBER_COERCE_MARKER (tem);
 273       wordstart = XINT (tem);
 274       Vabbrev_start_location = Qnil;
 275       if (wordstart < BEGV || wordstart > ZV)
 276         wordstart = 0;
 277       if (wordstart && wordstart != ZV)
 278         {
 279           wordstart_byte = CHAR_TO_BYTE (wordstart);
 280           if (FETCH_BYTE (wordstart_byte) == '-')
 281             del_range (wordstart, wordstart + 1);
 282         }
 283     }
 284   if (!wordstart)
 285     wordstart = scan_words (PT, -1);
 286
 287   if (!wordstart)
 288     return value;
 289
 290   wordstart_byte = CHAR_TO_BYTE (wordstart);
 291   wordend = scan_words (wordstart, 1);
 292   if (!wordend)
 293     return value;
 294
 295   if (wordend > PT)
 296     wordend = PT;
 297
 298   wordend_byte = CHAR_TO_BYTE (wordend);
 299   whitecnt = PT - wordend;
 300   if (wordend <= wordstart)
 301     return value;
 302
 303   p = buffer = (char *) alloca (wordend_byte - wordstart_byte);
 304
 305   for (idx = wordstart, idx_byte = wordstart_byte; idx < wordend; )
 306     {
 307       register int c;
 308
 309       if (multibyte)
 310         {
 311           FETCH_CHAR_ADVANCE (c, idx, idx_byte);
 312         }
 313       else
 314         {
 315           c = FETCH_BYTE (idx_byte);
 316           idx++, idx_byte++;
 317         }
 318
 319       if (UPPERCASEP (c))
 320         c = DOWNCASE (c), uccount++;
 321       else if (! NOCASEP (c))
 322         lccount++;
 323       if (multibyte)
 324         p += CHAR_STRING (c, p);
 325       else
 326         *p++ = c;
 327     }
 328
 329   if (VECTORP (current_buffer->abbrev_table))
 330     sym = oblookup (current_buffer->abbrev_table, buffer,
 331                     wordend - wordstart, p - buffer);
 332   else
 333     XSETFASTINT (sym, 0);
 334
 335   if (INTEGERP (sym) || NILP (SYMBOL_VALUE (sym)))
 336     sym = oblookup (Vglobal_abbrev_table, buffer,
 337                     wordend - wordstart, p - buffer);
 338   if (INTEGERP (sym) || NILP (SYMBOL_VALUE (sym)))
 339     return value;
 340
 341   if (INTERACTIVE && !EQ (minibuf_window, selected_window))
 342     {
 343       /* Add an undo boundary, in case we are doing this for
 344          a self-inserting command which has avoided making one so far.  */
 345       SET_PT (wordend);
 346       Fundo_boundary ();
 347     }
 348
 349   Vlast_abbrev_text
 350     = Fbuffer_substring (make_number (wordstart), make_number (wordend));
 351
 352   /* Now sym is the abbrev symbol.  */
 353   Vlast_abbrev = sym;
 354   value = sym;
 355   last_abbrev_point = wordstart;
 356
 357   /* Increment use count.  */
 358   if (INTEGERP (XSYMBOL (sym)->plist))
 359     XSETINT (XSYMBOL (sym)->plist,
 360              XINT (XSYMBOL (sym)->plist) + 1);
 361   else if (INTEGERP (tem = Fget (sym, Qcount)))
 362     Fput (sym, Qcount, make_number (XINT (tem) + 1));
 363
 364   /* If this abbrev has an expansion, delete the abbrev
 365      and insert the expansion.  */
 366   expansion = SYMBOL_VALUE (sym);
 367   if (STRINGP (expansion))
 368     {
 369       SET_PT (wordstart);
 370
 371       insert_from_string (expansion, 0, 0, SCHARS (expansion),
 372                           SBYTES (expansion), 1);
 373       del_range_both (PT, PT_BYTE,
 374                       wordend + (PT - wordstart),
 375                       wordend_byte + (PT_BYTE - wordstart_byte),
 376                       1);
 377
 378       SET_PT (PT + whitecnt);
 379
 380       if (uccount && !lccount)
 381         {
 382           /* Abbrev was all caps */
 383           /* If expansion is multiple words, normally capitalize each word */
 384           /* This used to be if (!... && ... >= ...) Fcapitalize; else Fupcase
 385              but Megatest 68000 compiler can't handle that */
 386           if (!abbrev_all_caps)
 387             if (scan_words (PT, -1) > scan_words (wordstart, 1))
 388               {
 389                 Fupcase_initials_region (make_number (wordstart),
 390                                          make_number (PT));
 391                 goto caped;
 392               }
 393           /* If expansion is one word, or if user says so, upcase it all. */
 394           Fupcase_region (make_number (wordstart), make_number (PT));
 395         caped: ;
 396         }
 397       else if (uccount)
 398         {
 399           /* Abbrev included some caps.  Cap first initial of expansion */
 400           int pos = wordstart_byte;
 401
 402           /* Find the initial.  */
 403           while (pos < PT_BYTE
 404                  && SYNTAX (*BUF_BYTE_ADDRESS (current_buffer, pos)) != Sword)
 405             pos++;
 406
 407           /* Change just that.  */
 408           pos = BYTE_TO_CHAR (pos);
 409           Fupcase_initials_region (make_number (pos), make_number (pos + 1));
 410         }
 411     }
 412
 413   hook = XSYMBOL (sym)->function;
 414   if (!NILP (hook))
 415     {
 416       Lisp_Object expanded, prop;
 417
 418       /* If the abbrev has a hook function, run it.  */
 419       expanded = call0 (hook);
 420
 421       /* In addition, if the hook function is a symbol with
 422          a non-nil `no-self-insert' property, let the value it returned
 423          specify whether we consider that an expansion took place.  If
 424          it returns nil, no expansion has been done.  */
 425
 426       if (SYMBOLP (hook)
 427           && NILP (expanded)
 428           && (prop = Fget (hook, intern ("no-self-insert")),
 429               !NILP (prop)))
 430         value = Qnil;
 431     }
 432
 433   return value;
 434 }
 435
 436 DEFUN ("unexpand-abbrev", Funexpand_abbrev, Sunexpand_abbrev, 0, 0, "",
 437        doc: /* Undo the expansion of the last abbrev that expanded.
 438 This differs from ordinary undo in that other editing done since then
 439 is not undone.  */)
 440      ()
 441 {
 442   int opoint = PT;
 443   int adjust = 0;
 444   if (last_abbrev_point < BEGV
 445       || last_abbrev_point > ZV)
 446     return Qnil;
 447   SET_PT (last_abbrev_point);
 448   if (STRINGP (Vlast_abbrev_text))
 449     {
 450       /* This isn't correct if Vlast_abbrev->function was used
 451          to do the expansion */
 452       Lisp_Object val;
 453       int zv_before;
 454
 455       val = SYMBOL_VALUE (Vlast_abbrev);
 456       if (!STRINGP (val))
 457         error ("Value of `abbrev-symbol' must be a string");
 458       zv_before = ZV;
 459       del_range_byte (PT_BYTE, PT_BYTE + SBYTES (val), 1);
 460       /* Don't inherit properties here; just copy from old contents.  */
 461       insert_from_string (Vlast_abbrev_text, 0, 0,
 462                           SCHARS (Vlast_abbrev_text),
 463                           SBYTES (Vlast_abbrev_text), 0);
 464       Vlast_abbrev_text = Qnil;
 465       /* Total number of characters deleted.  */
 466       adjust = ZV - zv_before;
 467     }
 468   SET_PT (last_abbrev_point < opoint ? opoint + adjust : opoint);
 469   return Qnil;
 470 }
 471 \f
 472 static void
 473 write_abbrev (sym, stream)
 474      Lisp_Object sym, stream;
 475 {
 476   Lisp_Object name, count, system_flag;
 477
 478   if (INTEGERP (XSYMBOL (sym)->plist))
 479     {
 480       count = XSYMBOL (sym)->plist;
 481       system_flag = Qnil;
 482     }
 483   else
 484     {
 485       count = Fget (sym, Qcount);
 486       system_flag = Fget (sym, Qsystem_type);
 487     }
 488
 489   if (NILP (SYMBOL_VALUE (sym)) || ! NILP (system_flag))
 490     return;
 491
 492   insert ("    (", 5);
 493   name = SYMBOL_NAME (sym);
 494   Fprin1 (name, stream);
 495   insert (" ", 1);
 496   Fprin1 (SYMBOL_VALUE (sym), stream);
 497   insert (" ", 1);
 498   Fprin1 (XSYMBOL (sym)->function, stream);
 499   insert (" ", 1);
 500   Fprin1 (count, stream);
 501   insert (")\n", 2);
 502 }
 503
 504 static void
 505 describe_abbrev (sym, stream)
 506      Lisp_Object sym, stream;
 507 {
 508   Lisp_Object one, count, system_flag;
 509
 510   if (INTEGERP (XSYMBOL (sym)->plist))
 511     {
 512       count = XSYMBOL (sym)->plist;
 513       system_flag = Qnil;
 514     }
 515   else
 516     {
 517       count = Fget (sym, Qcount);
 518       system_flag = Fget (sym, Qsystem_type);
 519     }
 520
 521   if (NILP (SYMBOL_VALUE (sym)))
 522     return;
 523
 524   one = make_number (1);
 525   Fprin1 (Fsymbol_name (sym), stream);
 526
 527   if (!NILP (system_flag))
 528     {
 529       insert_string (" (sys)");
 530       Findent_to (make_number (20), one);
 531     }
 532   else
 533     Findent_to (make_number (15), one);
 534
 535   Fprin1 (count, stream);
 536   Findent_to (make_number (20), one);
 537   Fprin1 (SYMBOL_VALUE (sym), stream);
 538   if (!NILP (XSYMBOL (sym)->function))
 539     {
 540       Findent_to (make_number (45), one);
 541       Fprin1 (XSYMBOL (sym)->function, stream);
 542     }
 543   Fterpri (stream);
 544 }
 545
 546 static void
 547 record_symbol (sym, list)
 548      Lisp_Object sym, list;
 549 {
 550   XSETCDR (list, Fcons (sym, XCDR (list)));
 551 }
 552
 553 DEFUN ("insert-abbrev-table-description", Finsert_abbrev_table_description,
 554        Sinsert_abbrev_table_description, 1, 2, 0,
 555        doc: /* Insert before point a full description of abbrev table named NAME.
 556 NAME is a symbol whose value is an abbrev table.
 557 If optional 2nd arg READABLE is non-nil, a human-readable description
 558 is inserted.  Otherwise the description is an expression,
 559 a call to `define-abbrev-table', which would
 560 define the abbrev table NAME exactly as it is currently defined.
 561
 562 Abbrevs marked as "system abbrevs" are normally omitted.  However, if
 563 READABLE is non-nil, they are listed.  */)
 564      (name, readable)
 565      Lisp_Object name, readable;
 566 {
 567   Lisp_Object table;
 568   Lisp_Object symbols;
 569   Lisp_Object stream;
 570
 571   CHECK_SYMBOL (name);
 572   table = Fsymbol_value (name);
 573   CHECK_VECTOR (table);
 574
 575   XSETBUFFER (stream, current_buffer);
 576
 577   symbols = Fcons (Qnil, Qnil);
 578   map_obarray (table, record_symbol, symbols);
 579   symbols = XCDR (symbols);
 580   symbols = Fsort (symbols, Qstring_lessp);
 581
 582   if (!NILP (readable))
 583     {
 584       insert_string ("(");
 585       Fprin1 (name, stream);
 586       insert_string (")\n\n");
 587       while (! NILP (symbols))
 588         {
 589           describe_abbrev (XCAR (symbols), stream);
 590           symbols = XCDR (symbols);
 591         }
 592
 593       insert_string ("\n\n");
 594     }
 595   else
 596     {
 597       insert_string ("(define-abbrev-table '");
 598       Fprin1 (name, stream);
 599       insert_string (" '(\n");
 600       while (! NILP (symbols))
 601         {
 602           write_abbrev (XCAR (symbols), stream);
 603           symbols = XCDR (symbols);
 604         }
 605       insert_string ("    ))\n\n");
 606     }
 607
 608   return Qnil;
 609 }
 610 \f
 611 DEFUN ("define-abbrev-table", Fdefine_abbrev_table, Sdefine_abbrev_table,
 612        2, 2, 0,
 613        doc: /* Define TABLENAME (a symbol) as an abbrev table name.
 614 Define abbrevs in it according to DEFINITIONS, which is a list of elements
 615 of the form (ABBREVNAME EXPANSION HOOK USECOUNT SYSTEMFLAG).
 616 \(If the list is shorter than that, omitted elements default to nil).  */)
 617      (tablename, definitions)
 618      Lisp_Object tablename, definitions;
 619 {
 620   Lisp_Object name, exp, hook, count;
 621   Lisp_Object table, elt, sys;
 622
 623   CHECK_SYMBOL (tablename);
 624   table = Fboundp (tablename);
 625   if (NILP (table) || (table = Fsymbol_value (tablename), NILP (table)))
 626     {
 627       table = Fmake_abbrev_table ();
 628       Fset (tablename, table);
 629       Vabbrev_table_name_list = Fcons (tablename, Vabbrev_table_name_list);
 630     }
 631   CHECK_VECTOR (table);
 632
 633   for (; CONSP (definitions); definitions = XCDR (definitions))
 634     {
 635       elt = XCAR (definitions);
 636       name  = Fcar (elt);       elt = Fcdr (elt);
 637       exp   = Fcar (elt);       elt = Fcdr (elt);
 638       hook  = Fcar (elt);       elt = Fcdr (elt);
 639       count = Fcar (elt);       elt = Fcdr (elt);
 640       sys   = Fcar (elt);
 641       Fdefine_abbrev (table, name, exp, hook, count, sys);
 642     }
 643   return Qnil;
 644 }
 645 \f
 646 void
 647 syms_of_abbrev ()
 648 {
 649   Qsystem_type = intern ("system-type");
 650   staticpro (&Qsystem_type);
 651
 652   Qcount = intern ("count");
 653   staticpro (&Qcount);
 654
 655   Qforce = intern ("force");
 656   staticpro (&Qforce);
 657
 658   DEFVAR_LISP ("abbrev-table-name-list", &Vabbrev_table_name_list,
 659                doc: /* List of symbols whose values are abbrev tables.  */);
 660   Vabbrev_table_name_list = Fcons (intern ("fundamental-mode-abbrev-table"),
 661                                    Fcons (intern ("global-abbrev-table"),
 662                                           Qnil));
 663
 664   DEFVAR_LISP ("global-abbrev-table", &Vglobal_abbrev_table,
 665                doc: /* The abbrev table whose abbrevs affect all buffers.
 666 Each buffer may also have a local abbrev table.
 667 If it does, the local table overrides the global one
 668 for any particular abbrev defined in both.  */);
 669   Vglobal_abbrev_table = Fmake_abbrev_table ();
 670
 671   DEFVAR_LISP ("fundamental-mode-abbrev-table", &Vfundamental_mode_abbrev_table,
 672                doc: /* The abbrev table of mode-specific abbrevs for Fundamental Mode.  */);
 673   Vfundamental_mode_abbrev_table = Fmake_abbrev_table ();
 674   current_buffer->abbrev_table = Vfundamental_mode_abbrev_table;
 675   buffer_defaults.abbrev_table = Vfundamental_mode_abbrev_table;
 676
 677   DEFVAR_LISP ("last-abbrev", &Vlast_abbrev,
 678                doc: /* The abbrev-symbol of the last abbrev expanded.  See `abbrev-symbol'.  */);
 679
 680   DEFVAR_LISP ("last-abbrev-text", &Vlast_abbrev_text,
 681                doc: /* The exact text of the last abbrev expanded.
 682 A value of nil means the abbrev has already been unexpanded.  */);
 683
 684   DEFVAR_INT ("last-abbrev-location", &last_abbrev_point,
 685               doc: /* The location of the start of the last abbrev expanded.  */);
 686
 687   Vlast_abbrev = Qnil;
 688   Vlast_abbrev_text = Qnil;
 689   last_abbrev_point = 0;
 690
 691   DEFVAR_LISP ("abbrev-start-location", &Vabbrev_start_location,
 692                doc: /* Buffer position for `expand-abbrev' to use as the start of the abbrev.
 693 When nil, use the word before point as the abbrev.
 694 Calling `expand-abbrev' sets this to nil.  */);
 695   Vabbrev_start_location = Qnil;
 696
 697   DEFVAR_LISP ("abbrev-start-location-buffer", &Vabbrev_start_location_buffer,
 698                doc: /* Buffer that `abbrev-start-location' has been set for.
 699 Trying to expand an abbrev in any other buffer clears `abbrev-start-location'.  */);
 700   Vabbrev_start_location_buffer = Qnil;
 701
 702   DEFVAR_PER_BUFFER ("local-abbrev-table", &current_buffer->abbrev_table, Qnil,
 703                      doc: /* Local (mode-specific) abbrev table of current buffer.  */);
 704
 705   DEFVAR_BOOL ("abbrevs-changed", &abbrevs_changed,
 706                doc: /* Set non-nil by defining or altering any word abbrevs.
 707 This causes `save-some-buffers' to offer to save the abbrevs.  */);
 708   abbrevs_changed = 0;
 709
 710   DEFVAR_BOOL ("abbrev-all-caps", &abbrev_all_caps,
 711                doc: /* *Set non-nil means expand multi-word abbrevs all caps if abbrev was so.  */);
 712   abbrev_all_caps = 0;
 713
 714   DEFVAR_LISP ("pre-abbrev-expand-hook", &Vpre_abbrev_expand_hook,
 715                doc: /* Function or functions to be called before abbrev expansion is done.
 716 This is the first thing that `expand-abbrev' does, and so this may change
 717 the current abbrev table before abbrev lookup happens.  */);
 718   Vpre_abbrev_expand_hook = Qnil;
 719   Qpre_abbrev_expand_hook = intern ("pre-abbrev-expand-hook");
 720   staticpro (&Qpre_abbrev_expand_hook);
 721
 722   defsubr (&Smake_abbrev_table);
 723   defsubr (&Sclear_abbrev_table);
 724   defsubr (&Sdefine_abbrev);
 725   defsubr (&Sdefine_global_abbrev);
 726   defsubr (&Sdefine_mode_abbrev);
 727   defsubr (&Sabbrev_expansion);
 728   defsubr (&Sabbrev_symbol);
 729   defsubr (&Sexpand_abbrev);
 730   defsubr (&Sunexpand_abbrev);
 731   defsubr (&Sinsert_abbrev_table_description);
 732   defsubr (&Sdefine_abbrev_table);
 733 }
 734
 735 /* arch-tag: b721db69-f633-44a8-a361-c275acbdad7d
 736    (do not change this comment) */