X-Git-Url: https://git.hcoop.net/bpt/emacs.git/blobdiff_plain/a0d76c279ecb62448cee5a54672264e4399dc518..204b78de1b66429250e18785a65392b5027ef103:/src/abbrev.c diff --git a/src/abbrev.c b/src/abbrev.c index 240f668d09..e7dcec3a43 100644 --- a/src/abbrev.c +++ b/src/abbrev.c @@ -1,5 +1,6 @@ /* Primitives for word-abbrev mode. - Copyright (C) 1985, 1986, 1993 Free Software Foundation, Inc. + Copyright (C) 1985, 1986, 1993, 1996, 1998, 2001, 2002, 2003, 2004, + 2005, 2006 Free Software Foundation, Inc. This file is part of GNU Emacs. @@ -15,16 +16,18 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU Emacs; see the file COPYING. If not, write to -the Free Software Foundation, Inc., 59 Temple Place - Suite 330, -Boston, MA 02111-1307, USA. */ +the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, +Boston, MA 02110-1301, USA. */ #include #include + #include "lisp.h" #include "commands.h" #include "buffer.h" #include "window.h" +#include "charset.h" #include "syntax.h" /* An abbrev table is an obarray. @@ -74,27 +77,30 @@ Lisp_Object Vlast_abbrev_text; /* Character address of start of last abbrev expanded */ -int last_abbrev_point; +EMACS_INT last_abbrev_point; /* Hook to run before expanding any abbrev. */ Lisp_Object Vpre_abbrev_expand_hook, Qpre_abbrev_expand_hook; + +Lisp_Object Qsystem_type, Qcount; DEFUN ("make-abbrev-table", Fmake_abbrev_table, Smake_abbrev_table, 0, 0, 0, - "Create a new, empty abbrev table object.") - () + doc: /* Create a new, empty abbrev table object. */) + () { + /* The value 59 is arbitrary chosen prime number. */ return Fmake_vector (make_number (59), make_number (0)); } DEFUN ("clear-abbrev-table", Fclear_abbrev_table, Sclear_abbrev_table, 1, 1, 0, - "Undefine all abbrevs in abbrev table TABLE, leaving it empty.") - (table) + doc: /* Undefine all abbrevs in abbrev table TABLE, leaving it empty. */) + (table) Lisp_Object table; { int i, size; - CHECK_VECTOR (table, 0); + CHECK_VECTOR (table); size = XVECTOR (table)->size; abbrevs_changed = 1; for (i = 0; i < size; i++) @@ -102,81 +108,95 @@ DEFUN ("clear-abbrev-table", Fclear_abbrev_table, Sclear_abbrev_table, 1, 1, 0, return Qnil; } -DEFUN ("define-abbrev", Fdefine_abbrev, Sdefine_abbrev, 3, 5, 0, - "Define an abbrev in TABLE named NAME, to expand to EXPANSION and call HOOK.\n\ -NAME and EXPANSION are strings.\n\ -To undefine an abbrev, define it with EXPANSION = nil.\n\ -If HOOK is non-nil, it should be a function of no arguments;\n\ -it is called after EXPANSION is inserted.") - (table, name, expansion, hook, count) - Lisp_Object table, name, expansion, hook, count; +DEFUN ("define-abbrev", Fdefine_abbrev, Sdefine_abbrev, 3, 6, 0, + doc: /* Define an abbrev in TABLE named NAME, to expand to EXPANSION and call HOOK. +NAME must be a string. +EXPANSION should usually be a string. +To undefine an abbrev, define it with EXPANSION = nil. +If HOOK is non-nil, it should be a function of no arguments; +it is called after EXPANSION is inserted. +If EXPANSION is not a string, the abbrev is a special one, + which does not expand in the usual way but only runs HOOK. + +COUNT, if specified, gives the initial value for the abbrev's +usage-count, which is incremented each time the abbrev is used. +\(The default is zero.) + +SYSTEM-FLAG, if non-nil, says that this is a "system" abbreviation +which should not be saved in the user's abbreviation file. */) + (table, name, expansion, hook, count, system_flag) + Lisp_Object table, name, expansion, hook, count, system_flag; { Lisp_Object sym, oexp, ohook, tem; - CHECK_VECTOR (table, 0); - CHECK_STRING (name, 1); - if (!NILP (expansion)) - CHECK_STRING (expansion, 2); + CHECK_VECTOR (table); + CHECK_STRING (name); + if (NILP (count)) count = make_number (0); else - CHECK_NUMBER (count, 0); + CHECK_NUMBER (count); sym = Fintern (name, table); - oexp = XSYMBOL (sym)->value; + oexp = SYMBOL_VALUE (sym); ohook = XSYMBOL (sym)->function; if (!((EQ (oexp, expansion) || (STRINGP (oexp) && STRINGP (expansion) && (tem = Fstring_equal (oexp, expansion), !NILP (tem)))) && (EQ (ohook, hook) - || (tem = Fequal (ohook, hook), !NILP (tem))))) + || (tem = Fequal (ohook, hook), !NILP (tem)))) + && NILP (system_flag)) abbrevs_changed = 1; Fset (sym, expansion); Ffset (sym, hook); - Fsetplist (sym, count); + + if (! NILP (system_flag)) + Fsetplist (sym, list4 (Qcount, count, Qsystem_type, system_flag)); + else + Fsetplist (sym, count); return name; } DEFUN ("define-global-abbrev", Fdefine_global_abbrev, Sdefine_global_abbrev, 2, 2, - "sDefine global abbrev: \nsExpansion for %s: ", - "Define ABBREV as a global abbreviation for EXPANSION.") - (abbrev, expansion) + "sDefine global abbrev: \nsExpansion for %s: ", + doc: /* Define ABBREV as a global abbreviation for EXPANSION. */) + (abbrev, expansion) Lisp_Object abbrev, expansion; { Fdefine_abbrev (Vglobal_abbrev_table, Fdowncase (abbrev), - expansion, Qnil, make_number (0)); + expansion, Qnil, make_number (0), Qnil); return abbrev; } DEFUN ("define-mode-abbrev", Fdefine_mode_abbrev, Sdefine_mode_abbrev, 2, 2, - "sDefine mode abbrev: \nsExpansion for %s: ", - "Define ABBREV as a mode-specific abbreviation for EXPANSION.") - (abbrev, expansion) + "sDefine mode abbrev: \nsExpansion for %s: ", + doc: /* Define ABBREV as a mode-specific abbreviation for EXPANSION. */) + (abbrev, expansion) Lisp_Object abbrev, expansion; { if (NILP (current_buffer->abbrev_table)) error ("Major mode has no abbrev table"); Fdefine_abbrev (current_buffer->abbrev_table, Fdowncase (abbrev), - expansion, Qnil, make_number (0)); + expansion, Qnil, make_number (0), Qnil); return abbrev; } DEFUN ("abbrev-symbol", Fabbrev_symbol, Sabbrev_symbol, 1, 2, 0, - "Return the symbol representing abbrev named ABBREV.\n\ -This symbol's name is ABBREV, but it is not the canonical symbol of that name;\n\ -it is interned in an abbrev-table rather than the normal obarray.\n\ -The value is nil if that abbrev is not defined.\n\ -Optional second arg TABLE is abbrev table to look it up in.\n\ -The default is to try buffer's mode-specific abbrev table, then global table.") - (abbrev, table) + doc: /* Return the symbol representing abbrev named ABBREV. +This symbol's name is ABBREV, but it is not the canonical symbol of that name; +it is interned in an abbrev-table rather than the normal obarray. +The value is nil if that abbrev is not defined. +Optional second arg TABLE is abbrev table to look it up in. +The default is to try buffer's mode-specific abbrev table, then global table. */) + (abbrev, table) Lisp_Object abbrev, table; { Lisp_Object sym; - CHECK_STRING (abbrev, 0); + CHECK_STRING (abbrev); if (!NILP (table)) sym = Fintern_soft (abbrev, table); else @@ -184,20 +204,21 @@ The default is to try buffer's mode-specific abbrev table, then global table.") sym = Qnil; if (!NILP (current_buffer->abbrev_table)) sym = Fintern_soft (abbrev, current_buffer->abbrev_table); - if (NILP (XSYMBOL (sym)->value)) + if (NILP (SYMBOL_VALUE (sym))) sym = Qnil; if (NILP (sym)) sym = Fintern_soft (abbrev, Vglobal_abbrev_table); } - if (NILP (XSYMBOL (sym)->value)) return Qnil; + if (NILP (SYMBOL_VALUE (sym))) + return Qnil; return sym; } DEFUN ("abbrev-expansion", Fabbrev_expansion, Sabbrev_expansion, 1, 2, 0, - "Return the string that ABBREV expands into in the current buffer.\n\ -Optionally specify an abbrev table as second arg;\n\ -then ABBREV is looked up in that table only.") - (abbrev, table) + doc: /* Return the string that ABBREV expands into in the current buffer. +Optionally specify an abbrev table as second arg; +then ABBREV is looked up in that table only. */) + (abbrev, table) Lisp_Object abbrev, table; { Lisp_Object sym; @@ -210,40 +231,43 @@ then ABBREV is looked up in that table only.") Returns 1 if an expansion is done. */ DEFUN ("expand-abbrev", Fexpand_abbrev, Sexpand_abbrev, 0, 0, "", - "Expand the abbrev before point, if there is an abbrev there.\n\ -Effective when explicitly called even when `abbrev-mode' is nil.\n\ -Returns t if expansion took place.") - () + doc: /* Expand the abbrev before point, if there is an abbrev there. +Effective when explicitly called even when `abbrev-mode' is nil. +Returns the abbrev symbol, if expansion took place. */) + () { register char *buffer, *p; - register int wordstart, wordend, idx; + int wordstart, wordend; + register int wordstart_byte, wordend_byte, idx, idx_byte; int whitecnt; int uccount = 0, lccount = 0; register Lisp_Object sym; Lisp_Object expansion, hook, tem; - int oldmodiff = MODIFF; Lisp_Object value; + int multibyte = ! NILP (current_buffer->enable_multibyte_characters); - if (!NILP (Vrun_hooks)) - call1 (Vrun_hooks, Qpre_abbrev_expand_hook); - /* If the hook changes the buffer, treat that as having "done an - expansion". */ - value = (MODIFF != oldmodiff ? Qt : Qnil); + value = Qnil; + + Frun_hooks (1, &Qpre_abbrev_expand_hook); wordstart = 0; - if (!(BUFFERP (Vabbrev_start_location_buffer) && - XBUFFER (Vabbrev_start_location_buffer) == current_buffer)) + if (!(BUFFERP (Vabbrev_start_location_buffer) + && XBUFFER (Vabbrev_start_location_buffer) == current_buffer)) Vabbrev_start_location = Qnil; if (!NILP (Vabbrev_start_location)) { tem = Vabbrev_start_location; - CHECK_NUMBER_COERCE_MARKER (tem, 0); + CHECK_NUMBER_COERCE_MARKER (tem); wordstart = XINT (tem); Vabbrev_start_location = Qnil; if (wordstart < BEGV || wordstart > ZV) wordstart = 0; - if (wordstart && wordstart != ZV && FETCH_CHAR (wordstart) == '-') - del_range (wordstart, wordstart + 1); + if (wordstart && wordstart != ZV) + { + wordstart_byte = CHAR_TO_BYTE (wordstart); + if (FETCH_BYTE (wordstart_byte) == '-') + del_range (wordstart, wordstart + 1); + } } if (!wordstart) wordstart = scan_words (PT, -1); @@ -251,35 +275,55 @@ Returns t if expansion took place.") if (!wordstart) return value; + wordstart_byte = CHAR_TO_BYTE (wordstart); wordend = scan_words (wordstart, 1); if (!wordend) return value; if (wordend > PT) wordend = PT; + + wordend_byte = CHAR_TO_BYTE (wordend); whitecnt = PT - wordend; if (wordend <= wordstart) return value; - p = buffer = (char *) alloca (wordend - wordstart); + p = buffer = (char *) alloca (wordend_byte - wordstart_byte); - for (idx = wordstart; idx < wordend; idx++) + for (idx = wordstart, idx_byte = wordstart_byte; idx < wordend; ) { - register int c = FETCH_CHAR (idx); + register int c; + + if (multibyte) + { + FETCH_CHAR_ADVANCE (c, idx, idx_byte); + } + else + { + c = FETCH_BYTE (idx_byte); + idx++, idx_byte++; + } + if (UPPERCASEP (c)) c = DOWNCASE (c), uccount++; else if (! NOCASEP (c)) lccount++; - *p++ = c; + if (multibyte) + p += CHAR_STRING (c, p); + else + *p++ = c; } if (VECTORP (current_buffer->abbrev_table)) - sym = oblookup (current_buffer->abbrev_table, buffer, p - buffer); + sym = oblookup (current_buffer->abbrev_table, buffer, + wordend - wordstart, p - buffer); else XSETFASTINT (sym, 0); - if (INTEGERP (sym) || NILP (XSYMBOL (sym)->value)) - sym = oblookup (Vglobal_abbrev_table, buffer, p - buffer); - if (INTEGERP (sym) || NILP (XSYMBOL (sym)->value)) + + if (INTEGERP (sym) || NILP (SYMBOL_VALUE (sym))) + sym = oblookup (Vglobal_abbrev_table, buffer, + wordend - wordstart, p - buffer); + if (INTEGERP (sym) || NILP (SYMBOL_VALUE (sym))) return value; if (INTERACTIVE && !EQ (minibuf_window, selected_window)) @@ -289,66 +333,99 @@ Returns t if expansion took place.") SET_PT (wordend); Fundo_boundary (); } - SET_PT (wordstart); + Vlast_abbrev_text = Fbuffer_substring (make_number (wordstart), make_number (wordend)); - del_range (wordstart, wordend); - /* Now sym is the abbrev symbol. */ + /* Now sym is the abbrev symbol. */ Vlast_abbrev = sym; + value = sym; last_abbrev_point = wordstart; + /* Increment use count. */ if (INTEGERP (XSYMBOL (sym)->plist)) XSETINT (XSYMBOL (sym)->plist, - XINT (XSYMBOL (sym)->plist) + 1); /* Increment use count */ - - expansion = XSYMBOL (sym)->value; - insert_from_string (expansion, 0, XSTRING (expansion)->size, 1); - SET_PT (PT + whitecnt); - - if (uccount && !lccount) + XINT (XSYMBOL (sym)->plist) + 1); + else if (INTEGERP (tem = Fget (sym, Qcount))) + Fput (sym, Qcount, make_number (XINT (tem) + 1)); + + /* If this abbrev has an expansion, delete the abbrev + and insert the expansion. */ + expansion = SYMBOL_VALUE (sym); + if (STRINGP (expansion)) { - /* Abbrev was all caps */ - /* If expansion is multiple words, normally capitalize each word */ - /* This used to be if (!... && ... >= ...) Fcapitalize; else Fupcase - but Megatest 68000 compiler can't handle that */ - if (!abbrev_all_caps) - if (scan_words (PT, -1) > scan_words (wordstart, 1)) - { - Fupcase_initials_region (make_number (wordstart), - make_number (PT)); - goto caped; - } - /* If expansion is one word, or if user says so, upcase it all. */ - Fupcase_region (make_number (wordstart), make_number (PT)); - caped: ; + SET_PT (wordstart); + + insert_from_string (expansion, 0, 0, SCHARS (expansion), + SBYTES (expansion), 1); + del_range_both (PT, PT_BYTE, + wordend + (PT - wordstart), + wordend_byte + (PT_BYTE - wordstart_byte), + 1); + + SET_PT (PT + whitecnt); + + if (uccount && !lccount) + { + /* Abbrev was all caps */ + /* If expansion is multiple words, normally capitalize each word */ + /* This used to be if (!... && ... >= ...) Fcapitalize; else Fupcase + but Megatest 68000 compiler can't handle that */ + if (!abbrev_all_caps) + if (scan_words (PT, -1) > scan_words (wordstart, 1)) + { + Fupcase_initials_region (make_number (wordstart), + make_number (PT)); + goto caped; + } + /* If expansion is one word, or if user says so, upcase it all. */ + Fupcase_region (make_number (wordstart), make_number (PT)); + caped: ; + } + else if (uccount) + { + /* Abbrev included some caps. Cap first initial of expansion */ + int pos = wordstart_byte; + + /* Find the initial. */ + while (pos < PT_BYTE + && SYNTAX (*BUF_BYTE_ADDRESS (current_buffer, pos)) != Sword) + pos++; + + /* Change just that. */ + pos = BYTE_TO_CHAR (pos); + Fupcase_initials_region (make_number (pos), make_number (pos + 1)); + } } - else if (uccount) + + hook = XSYMBOL (sym)->function; + if (!NILP (hook)) { - /* Abbrev included some caps. Cap first initial of expansion */ - int pos = wordstart; + Lisp_Object expanded, prop; - /* Find the initial. */ - while (pos < PT - && SYNTAX (*BUF_CHAR_ADDRESS (current_buffer, pos)) != Sword) - pos++; + /* If the abbrev has a hook function, run it. */ + expanded = call0 (hook); - /* Change just that. */ - Fupcase_initials_region (make_number (pos), make_number (pos + 1)); - } + /* In addition, if the hook function is a symbol with + a non-nil `no-self-insert' property, let the value it returned + specify whether we consider that an expansion took place. If + it returns nil, no expansion has been done. */ - hook = XSYMBOL (sym)->function; - if (!NILP (hook)) - call0 (hook); + if (SYMBOLP (hook) + && NILP (expanded) + && (prop = Fget (hook, intern ("no-self-insert")), + !NILP (prop))) + value = Qnil; + } - return Qt; + return value; } DEFUN ("unexpand-abbrev", Funexpand_abbrev, Sunexpand_abbrev, 0, 0, "", - "Undo the expansion of the last abbrev that expanded.\n\ -This differs from ordinary undo in that other editing done since then\n\ -is not undone.") - () + doc: /* Undo the expansion of the last abbrev that expanded. +This differs from ordinary undo in that other editing done since then +is not undone. */) + () { int opoint = PT; int adjust = 0; @@ -361,54 +438,91 @@ is not undone.") /* This isn't correct if Vlast_abbrev->function was used to do the expansion */ Lisp_Object val; - val = XSYMBOL (Vlast_abbrev)->value; + int zv_before; + + val = SYMBOL_VALUE (Vlast_abbrev); if (!STRINGP (val)) - error ("value of abbrev-symbol must be a string"); - adjust = XSTRING (val)->size; - del_range (PT, PT + adjust); + error ("Value of `abbrev-symbol' must be a string"); + zv_before = ZV; + del_range_byte (PT_BYTE, PT_BYTE + SBYTES (val), 1); /* Don't inherit properties here; just copy from old contents. */ - insert_from_string (Vlast_abbrev_text, 0, - XSTRING (Vlast_abbrev_text)->size, 0); - adjust -= XSTRING (Vlast_abbrev_text)->size; + insert_from_string (Vlast_abbrev_text, 0, 0, + SCHARS (Vlast_abbrev_text), + SBYTES (Vlast_abbrev_text), 0); Vlast_abbrev_text = Qnil; + /* Total number of characters deleted. */ + adjust = ZV - zv_before; } - SET_PT (last_abbrev_point < opoint ? opoint - adjust : opoint); + SET_PT (last_abbrev_point < opoint ? opoint + adjust : opoint); return Qnil; } -static +static void write_abbrev (sym, stream) Lisp_Object sym, stream; { - Lisp_Object name; - if (NILP (XSYMBOL (sym)->value)) + Lisp_Object name, count, system_flag; + + if (INTEGERP (XSYMBOL (sym)->plist)) + { + count = XSYMBOL (sym)->plist; + system_flag = Qnil; + } + else + { + count = Fget (sym, Qcount); + system_flag = Fget (sym, Qsystem_type); + } + + if (NILP (SYMBOL_VALUE (sym)) || ! NILP (system_flag)) return; + insert (" (", 5); - XSETSTRING (name, XSYMBOL (sym)->name); + name = SYMBOL_NAME (sym); Fprin1 (name, stream); insert (" ", 1); - Fprin1 (XSYMBOL (sym)->value, stream); + Fprin1 (SYMBOL_VALUE (sym), stream); insert (" ", 1); Fprin1 (XSYMBOL (sym)->function, stream); insert (" ", 1); - Fprin1 (XSYMBOL (sym)->plist, stream); + Fprin1 (count, stream); insert (")\n", 2); } -static +static void describe_abbrev (sym, stream) Lisp_Object sym, stream; { - Lisp_Object one; + Lisp_Object one, count, system_flag; - if (NILP (XSYMBOL (sym)->value)) + if (INTEGERP (XSYMBOL (sym)->plist)) + { + count = XSYMBOL (sym)->plist; + system_flag = Qnil; + } + else + { + count = Fget (sym, Qcount); + system_flag = Fget (sym, Qsystem_type); + } + + if (NILP (SYMBOL_VALUE (sym))) return; + one = make_number (1); Fprin1 (Fsymbol_name (sym), stream); - Findent_to (make_number (15), one); - Fprin1 (XSYMBOL (sym)->plist, stream); + + if (!NILP (system_flag)) + { + insert_string (" (sys)"); + Findent_to (make_number (20), one); + } + else + Findent_to (make_number (15), one); + + Fprin1 (count, stream); Findent_to (make_number (20), one); - Fprin1 (XSYMBOL (sym)->value, stream); + Fprin1 (SYMBOL_VALUE (sym), stream); if (!NILP (XSYMBOL (sym)->function)) { Findent_to (make_number (45), one); @@ -418,22 +532,25 @@ describe_abbrev (sym, stream) } DEFUN ("insert-abbrev-table-description", Finsert_abbrev_table_description, - Sinsert_abbrev_table_description, 1, 2, 0, - "Insert before point a full description of abbrev table named NAME.\n\ -NAME is a symbol whose value is an abbrev table.\n\ -If optional 2nd arg READABLE is non-nil, a human-readable description\n\ -is inserted. Otherwise the description is an expression,\n\ -a call to `define-abbrev-table', which would\n\ -define the abbrev table NAME exactly as it is currently defined.") - (name, readable) + Sinsert_abbrev_table_description, 1, 2, 0, + doc: /* Insert before point a full description of abbrev table named NAME. +NAME is a symbol whose value is an abbrev table. +If optional 2nd arg READABLE is non-nil, a human-readable description +is inserted. Otherwise the description is an expression, +a call to `define-abbrev-table', which would +define the abbrev table NAME exactly as it is currently defined. + +Abbrevs marked as "system abbrevs" are normally omitted. However, if +READABLE is non-nil, they are listed. */) + (name, readable) Lisp_Object name, readable; { Lisp_Object table; Lisp_Object stream; - CHECK_SYMBOL (name, 0); + CHECK_SYMBOL (name); table = Fsymbol_value (name); - CHECK_VECTOR (table, 0); + CHECK_VECTOR (table); XSETBUFFER (stream, current_buffer); @@ -459,16 +576,17 @@ define the abbrev table NAME exactly as it is currently defined.") DEFUN ("define-abbrev-table", Fdefine_abbrev_table, Sdefine_abbrev_table, 2, 2, 0, - "Define TABLENAME (a symbol) as an abbrev table name.\n\ -Define abbrevs in it according to DEFINITIONS, which is a list of elements\n\ -of the form (ABBREVNAME EXPANSION HOOK USECOUNT).") - (tablename, definitions) + doc: /* Define TABLENAME (a symbol) as an abbrev table name. +Define abbrevs in it according to DEFINITIONS, which is a list of elements +of the form (ABBREVNAME EXPANSION HOOK USECOUNT SYSTEMFLAG). +\(If the list is shorter than that, omitted elements default to nil). */) + (tablename, definitions) Lisp_Object tablename, definitions; { Lisp_Object name, exp, hook, count; - Lisp_Object table, elt; + Lisp_Object table, elt, sys; - CHECK_SYMBOL (tablename, 0); + CHECK_SYMBOL (tablename); table = Fboundp (tablename); if (NILP (table) || (table = Fsymbol_value (tablename), NILP (table))) { @@ -476,81 +594,90 @@ of the form (ABBREVNAME EXPANSION HOOK USECOUNT).") Fset (tablename, table); Vabbrev_table_name_list = Fcons (tablename, Vabbrev_table_name_list); } - CHECK_VECTOR (table, 0); + CHECK_VECTOR (table); - for (; !NILP (definitions); definitions = Fcdr (definitions)) + for (; CONSP (definitions); definitions = XCDR (definitions)) { - elt = Fcar (definitions); + elt = XCAR (definitions); name = Fcar (elt); elt = Fcdr (elt); exp = Fcar (elt); elt = Fcdr (elt); hook = Fcar (elt); elt = Fcdr (elt); - count = Fcar (elt); - Fdefine_abbrev (table, name, exp, hook, count); + count = Fcar (elt); elt = Fcdr (elt); + sys = Fcar (elt); + Fdefine_abbrev (table, name, exp, hook, count, sys); } return Qnil; } +void syms_of_abbrev () { + Qsystem_type = intern ("system-type"); + staticpro (&Qsystem_type); + + Qcount = intern ("count"); + staticpro (&Qcount); + DEFVAR_LISP ("abbrev-table-name-list", &Vabbrev_table_name_list, - "List of symbols whose values are abbrev tables."); + doc: /* List of symbols whose values are abbrev tables. */); Vabbrev_table_name_list = Fcons (intern ("fundamental-mode-abbrev-table"), Fcons (intern ("global-abbrev-table"), Qnil)); DEFVAR_LISP ("global-abbrev-table", &Vglobal_abbrev_table, - "The abbrev table whose abbrevs affect all buffers.\n\ -Each buffer may also have a local abbrev table.\n\ -If it does, the local table overrides the global one\n\ -for any particular abbrev defined in both."); + doc: /* The abbrev table whose abbrevs affect all buffers. +Each buffer may also have a local abbrev table. +If it does, the local table overrides the global one +for any particular abbrev defined in both. */); Vglobal_abbrev_table = Fmake_abbrev_table (); DEFVAR_LISP ("fundamental-mode-abbrev-table", &Vfundamental_mode_abbrev_table, - "The abbrev table of mode-specific abbrevs for Fundamental Mode."); + doc: /* The abbrev table of mode-specific abbrevs for Fundamental Mode. */); Vfundamental_mode_abbrev_table = Fmake_abbrev_table (); current_buffer->abbrev_table = Vfundamental_mode_abbrev_table; + buffer_defaults.abbrev_table = Vfundamental_mode_abbrev_table; DEFVAR_LISP ("last-abbrev", &Vlast_abbrev, - "The abbrev-symbol of the last abbrev expanded. See `abbrev-symbol'."); + doc: /* The abbrev-symbol of the last abbrev expanded. See `abbrev-symbol'. */); DEFVAR_LISP ("last-abbrev-text", &Vlast_abbrev_text, - "The exact text of the last abbrev expanded.\n\ -nil if the abbrev has already been unexpanded."); + doc: /* The exact text of the last abbrev expanded. +nil if the abbrev has already been unexpanded. */); DEFVAR_INT ("last-abbrev-location", &last_abbrev_point, - "The location of the start of the last abbrev expanded."); + doc: /* The location of the start of the last abbrev expanded. */); Vlast_abbrev = Qnil; Vlast_abbrev_text = Qnil; last_abbrev_point = 0; DEFVAR_LISP ("abbrev-start-location", &Vabbrev_start_location, - "Buffer position for `expand-abbrev' to use as the start of the abbrev.\n\ -nil means use the word before point as the abbrev.\n\ -Calling `expand-abbrev' sets this to nil."); + doc: /* Buffer position for `expand-abbrev' to use as the start of the abbrev. +When nil, use the word before point as the abbrev. +Calling `expand-abbrev' sets this to nil. */); Vabbrev_start_location = Qnil; DEFVAR_LISP ("abbrev-start-location-buffer", &Vabbrev_start_location_buffer, - "Buffer that `abbrev-start-location' has been set for.\n\ -Trying to expand an abbrev in any other buffer clears `abbrev-start-location'."); + doc: /* Buffer that `abbrev-start-location' has been set for. +Trying to expand an abbrev in any other buffer clears `abbrev-start-location'. */); Vabbrev_start_location_buffer = Qnil; DEFVAR_PER_BUFFER ("local-abbrev-table", ¤t_buffer->abbrev_table, Qnil, - "Local (mode-specific) abbrev table of current buffer."); + doc: /* Local (mode-specific) abbrev table of current buffer. */); DEFVAR_BOOL ("abbrevs-changed", &abbrevs_changed, - "Set non-nil by defining or altering any word abbrevs.\n\ -This causes `save-some-buffers' to offer to save the abbrevs."); + doc: /* Set non-nil by defining or altering any word abbrevs. +This causes `save-some-buffers' to offer to save the abbrevs. */); abbrevs_changed = 0; DEFVAR_BOOL ("abbrev-all-caps", &abbrev_all_caps, - "*Set non-nil means expand multi-word abbrevs all caps if abbrev was so."); + doc: /* *Set non-nil means expand multi-word abbrevs all caps if abbrev was so. */); abbrev_all_caps = 0; DEFVAR_LISP ("pre-abbrev-expand-hook", &Vpre_abbrev_expand_hook, - "Function or functions to be called before abbrev expansion is done.\n\ -This is the first thing that `expand-abbrev' does, and so this may change\n\ -the current abbrev table before abbrev lookup happens."); + doc: /* Function or functions to be called before abbrev expansion is done. +This is the first thing that `expand-abbrev' does, and so this may change +the current abbrev table before abbrev lookup happens. */); Vpre_abbrev_expand_hook = Qnil; Qpre_abbrev_expand_hook = intern ("pre-abbrev-expand-hook"); staticpro (&Qpre_abbrev_expand_hook); @@ -567,3 +694,6 @@ the current abbrev table before abbrev lookup happens."); defsubr (&Sinsert_abbrev_table_description); defsubr (&Sdefine_abbrev_table); } + +/* arch-tag: b721db69-f633-44a8-a361-c275acbdad7d + (do not change this comment) */