/* Primitives for word-abbrev mode.
- Copyright (C) 1985, 1986 Free Software Foundation, Inc.
+ Copyright (C) 1985, 1986, 1993 Free Software Foundation, Inc.
This file is part of GNU Emacs.
GNU Emacs is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 1, or (at your option)
+the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Emacs is distributed in the hope that it will be useful,
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, 675 Mass Ave, Cambridge, MA 02139, USA. */
+the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
-#include "config.h"
+#include <config.h>
#include <stdio.h>
-#undef NULL
#include "lisp.h"
#include "commands.h"
#include "buffer.h"
#include "window.h"
+#include "syntax.h"
/* An abbrev table is an obarray.
Each defined abbrev is represented by a symbol in that obarray
int last_abbrev_point;
+/* Hook to run before expanding any abbrev. */
+
+Lisp_Object Vpre_abbrev_expand_hook, Qpre_abbrev_expand_hook;
\f
DEFUN ("make-abbrev-table", Fmake_abbrev_table, Smake_abbrev_table, 0, 0, 0,
"Create a new, empty abbrev table object.")
Lisp_Object sym, oexp, ohook, tem;
CHECK_VECTOR (table, 0);
CHECK_STRING (name, 1);
- if (!NULL (expansion))
+ if (!NILP (expansion))
CHECK_STRING (expansion, 2);
- if (NULL (count))
+ if (NILP (count))
count = make_number (0);
else
CHECK_NUMBER (count, 0);
oexp = XSYMBOL (sym)->value;
ohook = XSYMBOL (sym)->function;
if (!((EQ (oexp, expansion)
- || (XTYPE (oexp) == Lisp_String && XTYPE (expansion) == Lisp_String
- && (tem = Fstring_equal (oexp, expansion), !NULL (tem))))
+ || (STRINGP (oexp) && STRINGP (expansion)
+ && (tem = Fstring_equal (oexp, expansion), !NILP (tem))))
&&
(EQ (ohook, hook)
- || (tem = Fequal (ohook, hook), !NULL (tem)))))
+ || (tem = Fequal (ohook, hook), !NILP (tem)))))
abbrevs_changed = 1;
Fset (sym, expansion);
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.")
- (name, expansion)
- Lisp_Object name, expansion;
+ (abbrev, expansion)
+ Lisp_Object abbrev, expansion;
{
- Fdefine_abbrev (Vglobal_abbrev_table, Fdowncase (name),
+ Fdefine_abbrev (Vglobal_abbrev_table, Fdowncase (abbrev),
expansion, Qnil, make_number (0));
- return name;
+ 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.")
- (name, expansion)
- Lisp_Object name, expansion;
+ (abbrev, expansion)
+ Lisp_Object abbrev, expansion;
{
- if (NULL (current_buffer->abbrev_table))
+ if (NILP (current_buffer->abbrev_table))
error ("Major mode has no abbrev table");
- Fdefine_abbrev (current_buffer->abbrev_table, Fdowncase (name),
+ Fdefine_abbrev (current_buffer->abbrev_table, Fdowncase (abbrev),
expansion, Qnil, make_number (0));
- return name;
+ return abbrev;
}
DEFUN ("abbrev-symbol", Fabbrev_symbol, Sabbrev_symbol, 1, 2, 0,
{
Lisp_Object sym;
CHECK_STRING (abbrev, 0);
- if (!NULL (table))
+ if (!NILP (table))
sym = Fintern_soft (abbrev, table);
else
{
sym = Qnil;
- if (!NULL (current_buffer->abbrev_table))
+ if (!NILP (current_buffer->abbrev_table))
sym = Fintern_soft (abbrev, current_buffer->abbrev_table);
- if (NULL (XSYMBOL (sym)->value))
+ if (NILP (XSYMBOL (sym)->value))
sym = Qnil;
- if (NULL (sym))
+ if (NILP (sym))
sym = Fintern_soft (abbrev, Vglobal_abbrev_table);
}
- if (NULL (XSYMBOL (sym)->value)) return Qnil;
+ if (NILP (XSYMBOL (sym)->value)) return Qnil;
return sym;
}
{
Lisp_Object sym;
sym = Fabbrev_symbol (abbrev, table);
- if (NULL (sym)) return sym;
+ if (NILP (sym)) return sym;
return Fsymbol_value (sym);
}
\f
int uccount = 0, lccount = 0;
register Lisp_Object sym;
Lisp_Object expansion, hook, tem;
-
- if (XBUFFER (Vabbrev_start_location_buffer) != current_buffer)
+ int oldmodiff = MODIFF;
+ Lisp_Object value;
+
+ 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);
+
+ wordstart = 0;
+ if (!(BUFFERP (Vabbrev_start_location_buffer) &&
+ XBUFFER (Vabbrev_start_location_buffer) == current_buffer))
Vabbrev_start_location = Qnil;
- if (!NULL (Vabbrev_start_location))
+ if (!NILP (Vabbrev_start_location))
{
tem = Vabbrev_start_location;
CHECK_NUMBER_COERCE_MARKER (tem, 0);
wordstart = XINT (tem);
Vabbrev_start_location = Qnil;
- if (FETCH_CHAR (wordstart) == '-')
+ if (wordstart < BEGV || wordstart > ZV)
+ wordstart = 0;
+ if (wordstart && wordstart != ZV && FETCH_CHAR (wordstart) == '-')
del_range (wordstart, wordstart + 1);
}
- else
+ if (!wordstart)
wordstart = scan_words (point, -1);
if (!wordstart)
- return Qnil;
+ return value;
wordend = scan_words (wordstart, 1);
if (!wordend)
- return Qnil;
+ return value;
if (wordend > point)
wordend = point;
whitecnt = point - wordend;
if (wordend <= wordstart)
- return Qnil;
+ return value;
p = buffer = (char *) alloca (wordend - wordstart);
- for (idx = wordstart; idx < point; idx++)
+ for (idx = wordstart; idx < wordend; idx++)
{
register int c = FETCH_CHAR (idx);
if (UPPERCASEP (c))
*p++ = c;
}
- if (XTYPE (current_buffer->abbrev_table) == Lisp_Vector)
+ if (VECTORP (current_buffer->abbrev_table))
sym = oblookup (current_buffer->abbrev_table, buffer, p - buffer);
else
- XFASTINT (sym) = 0;
- if (XTYPE (sym) == Lisp_Int || NULL (XSYMBOL (sym)->value))
+ XSETFASTINT (sym, 0);
+ if (INTEGERP (sym) || NILP (XSYMBOL (sym)->value))
sym = oblookup (Vglobal_abbrev_table, buffer, p - buffer);
- if (XTYPE (sym) == Lisp_Int || NULL (XSYMBOL (sym)->value))
- return Qnil;
+ if (INTEGERP (sym) || NILP (XSYMBOL (sym)->value))
+ return value;
if (INTERACTIVE && !EQ (minibuf_window, selected_window))
{
+ /* Add an undo boundary, in case we are doing this for
+ a self-inserting command which has avoided making one so far. */
SET_PT (wordend);
Fundo_boundary ();
}
Vlast_abbrev = sym;
last_abbrev_point = wordstart;
- if (XTYPE (XSYMBOL (sym)->plist) == Lisp_Int)
+ 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);
+ insert_from_string (expansion, 0, XSTRING (expansion)->size, 1);
SET_PT (point + whitecnt);
if (uccount && !lccount)
if (!abbrev_all_caps)
if (scan_words (point, -1) > scan_words (wordstart, 1))
{
- upcase_initials_region (make_number (wordstart),
- make_number (point));
+ Fupcase_initials_region (make_number (wordstart),
+ make_number (point));
goto caped;
}
/* If expansion is one word, or if user says so, upcase it all. */
else if (uccount)
{
/* Abbrev included some caps. Cap first initial of expansion */
- int old_zv = ZV;
- int old_pt = point;
+ int pos = wordstart;
- /* Don't let Fcapitalize_word operate on text after point. */
- ZV = point;
- SET_PT (wordstart);
- Fcapitalize_word (make_number (1));
+ /* Find the initial. */
+ while (pos < point
+ && SYNTAX (*BUF_CHAR_ADDRESS (current_buffer, pos)) != Sword)
+ pos++;
- SET_PT (old_pt);
- ZV = old_zv;
+ /* Change just that. */
+ Fupcase_initials_region (make_number (pos), make_number (pos + 1));
}
hook = XSYMBOL (sym)->function;
- if (!NULL (hook))
+ if (!NILP (hook))
call0 (hook);
return Qt;
|| last_abbrev_point > ZV)
return Qnil;
SET_PT (last_abbrev_point);
- if (XTYPE (Vlast_abbrev_text) == Lisp_String)
+ if (STRINGP (Vlast_abbrev_text))
{
/* This isn't correct if Vlast_abbrev->function was used
to do the expansion */
Lisp_Object val;
- XSET (val, Lisp_String, XSYMBOL (Vlast_abbrev)->value);
+ val = XSYMBOL (Vlast_abbrev)->value;
+ if (!STRINGP (val))
+ error ("value of abbrev-symbol must be a string");
adjust = XSTRING (val)->size;
del_range (point, point + adjust);
+ /* Don't inherit properties here; just copy from old contents. */
insert_from_string (Vlast_abbrev_text, 0,
- XSTRING (Vlast_abbrev_text)->size);
+ XSTRING (Vlast_abbrev_text)->size, 0);
adjust -= XSTRING (Vlast_abbrev_text)->size;
Vlast_abbrev_text = Qnil;
}
Lisp_Object sym, stream;
{
Lisp_Object name;
- if (NULL (XSYMBOL (sym)->value))
+ if (NILP (XSYMBOL (sym)->value))
return;
insert (" (", 5);
- XSET (name, Lisp_String, XSYMBOL (sym)->name);
+ XSETSTRING (name, XSYMBOL (sym)->name);
Fprin1 (name, stream);
insert (" ", 1);
Fprin1 (XSYMBOL (sym)->value, stream);
{
Lisp_Object one;
- if (NULL (XSYMBOL (sym)->value))
+ if (NILP (XSYMBOL (sym)->value))
return;
one = make_number (1);
Fprin1 (Fsymbol_name (sym), stream);
Fprin1 (XSYMBOL (sym)->plist, stream);
Findent_to (make_number (20), one);
Fprin1 (XSYMBOL (sym)->value, stream);
- if (!NULL (XSYMBOL (sym)->function))
+ if (!NILP (XSYMBOL (sym)->function))
{
Findent_to (make_number (45), one);
Fprin1 (XSYMBOL (sym)->function, stream);
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 HUMAN is non-nil, a human-readable description is inserted.\n\
-Otherwise the description is an expression,\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)
table = Fsymbol_value (name);
CHECK_VECTOR (table, 0);
- XSET (stream, Lisp_Buffer, current_buffer);
+ XSETBUFFER (stream, current_buffer);
- if (!NULL (readable))
+ if (!NILP (readable))
{
insert_string ("(");
Fprin1 (name, stream);
\f
DEFUN ("define-abbrev-table", Fdefine_abbrev_table, Sdefine_abbrev_table,
2, 2, 0,
- "Define TABNAME (a symbol) as an abbrev table name.\n\
+ "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).")
- (tabname, defns)
- Lisp_Object tabname, defns;
+ (tablename, definitions)
+ Lisp_Object tablename, definitions;
{
Lisp_Object name, exp, hook, count;
Lisp_Object table, elt;
- CHECK_SYMBOL (tabname, 0);
- table = Fboundp (tabname);
- if (NULL (table) || (table = Fsymbol_value (tabname), NULL (table)))
+ CHECK_SYMBOL (tablename, 0);
+ table = Fboundp (tablename);
+ if (NILP (table) || (table = Fsymbol_value (tablename), NILP (table)))
{
table = Fmake_abbrev_table ();
- Fset (tabname, table);
- Vabbrev_table_name_list =
- Fcons (tabname, Vabbrev_table_name_list);
+ Fset (tablename, table);
+ Vabbrev_table_name_list = Fcons (tablename, Vabbrev_table_name_list);
}
CHECK_VECTOR (table, 0);
- for (;!NULL (defns); defns = Fcdr (defns))
+ for (; !NILP (definitions); definitions = Fcdr (definitions))
{
- elt = Fcar (defns);
- name = Fcar (elt);
- elt = Fcdr (elt);
- exp = Fcar (elt);
- elt = Fcdr (elt);
- hook = Fcar (elt);
- elt = Fcdr (elt);
+ elt = Fcar (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);
}
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,
+ DEFVAR_PER_BUFFER ("local-abbrev-table", ¤t_buffer->abbrev_table, Qnil,
"Local (mode-specific) abbrev table of current buffer.");
DEFVAR_BOOL ("abbrevs-changed", &abbrevs_changed,
"*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.");
+ Vpre_abbrev_expand_hook = Qnil;
+ Qpre_abbrev_expand_hook = intern ("pre-abbrev-expand-hook");
+ staticpro (&Qpre_abbrev_expand_hook);
+
defsubr (&Smake_abbrev_table);
defsubr (&Sclear_abbrev_table);
defsubr (&Sdefine_abbrev);