1 /* Primitives for word-abbrev mode.
2 Copyright (C) 1985, 1986, 1992, 1993 Free Software Foundation, Inc.
4 This file is part of XEmacs.
6 XEmacs is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 2, or (at your option) any
11 XEmacs is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with XEmacs; 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. */
21 /* Synched up with: FSF 19.30. Note that there are many more functions in
22 FSF's abbrev.c. These have been moved into Lisp in XEmacs. */
26 FSF: Original version; a long time ago.
27 JWZ or Mly: Mostly moved into Lisp; maybe 1992.
28 Ben Wing: Some changes for Mule for 19.12.
29 Hrvoje Niksic: Largely rewritten in June 1997.
32 /* This file has been Mule-ized. */
43 /* An abbrev table is an obarray.
44 Each defined abbrev is represented by a symbol in that obarray
45 whose print name is the abbreviation.
46 The symbol's value is a string which is the expansion.
47 If its function definition is non-nil, it is called
48 after the expansion is done.
49 The plist slot of the abbrev symbol is its usage count. */
51 /* The table of global abbrevs. These are in effect
52 in any buffer in which abbrev mode is turned on. */
53 Lisp_Object Vglobal_abbrev_table;
57 /* Non-nil => use this location as the start of abbrev to expand
58 (rather than taking the word before point as the abbrev) */
59 Lisp_Object Vabbrev_start_location;
61 /* Buffer that Vabbrev_start_location applies to */
62 Lisp_Object Vabbrev_start_location_buffer;
64 /* The symbol representing the abbrev most recently expanded */
65 Lisp_Object Vlast_abbrev;
67 /* A string for the actual text of the abbrev most recently expanded.
68 This has more info than Vlast_abbrev since case is significant. */
69 Lisp_Object Vlast_abbrev_text;
71 /* Character address of start of last abbrev expanded */
72 int last_abbrev_location;
74 /* Hook to run before expanding any abbrev. */
75 Lisp_Object Vpre_abbrev_expand_hook, Qpre_abbrev_expand_hook;
78 struct abbrev_match_mapper_closure {
80 Lisp_Char_Table *chartab;
81 Charcount point, maxlen;
85 /* For use by abbrev_match(): Match SYMBOL's name against buffer text
86 before point, case-insensitively. When found, return non-zero, so
87 that map_obarray terminates mapping. */
89 abbrev_match_mapper (Lisp_Object symbol, void *arg)
91 struct abbrev_match_mapper_closure *closure =
92 (struct abbrev_match_mapper_closure *)arg;
93 Charcount abbrev_length;
94 Lisp_Symbol *sym = XSYMBOL (symbol);
97 /* symbol_value should be OK here, because abbrevs are not expected
98 to contain any SYMBOL_MAGIC stuff. */
99 if (UNBOUNDP (symbol_value (sym)) || NILP (symbol_value (sym)))
101 /* The symbol value of nil means that abbrev got undefined. */
104 abbrev = symbol_name (sym);
105 abbrev_length = string_char_length (abbrev);
106 if (abbrev_length > closure->maxlen)
108 /* This abbrev is too large -- it wouldn't fit. */
111 /* If `bar' is an abbrev, and a user presses `fubar<SPC>', we don't
112 normally want to expand it. OTOH, if the abbrev begins with
113 non-word syntax (e.g. `#if'), it is OK to abbreviate it anywhere. */
114 if (abbrev_length < closure->maxlen && abbrev_length > 0
115 && (WORD_SYNTAX_P (closure->chartab, string_char (abbrev, 0)))
116 && (WORD_SYNTAX_P (closure->chartab,
117 BUF_FETCH_CHAR (closure->buf,
118 closure->point - (abbrev_length + 1)))))
122 /* Match abbreviation string against buffer text. */
124 Bufbyte *ptr = string_data (abbrev);
127 for (idx = 0; idx < abbrev_length; idx++)
129 if (DOWNCASE (closure->buf,
130 BUF_FETCH_CHAR (closure->buf,
131 closure->point - abbrev_length + idx))
132 != DOWNCASE (closure->buf, charptr_emchar (ptr)))
138 if (idx == abbrev_length)
140 /* This is the one. */
141 closure->found = sym;
148 /* Match the buffer text against names of symbols in obarray. Returns
149 the matching symbol, or 0 if not found. */
151 abbrev_match (struct buffer *buf, Lisp_Object obarray)
153 struct abbrev_match_mapper_closure closure;
155 /* Precalculate some stuff, so mapper function needn't to it in each
158 closure.point = BUF_PT (buf);
159 closure.maxlen = closure.point - BUF_BEGV (buf);
160 closure.chartab = XCHAR_TABLE (buf->mirror_syntax_table);
163 map_obarray (obarray, abbrev_match_mapper, &closure);
165 return closure.found;
168 /* Take the word before point (or Vabbrev_start_location, if non-nil),
169 and look it up in OBARRAY, and return the symbol (or zero). This
170 used to be the default method of searching, with the obvious
171 limitation that the abbrevs may consist only of word characters.
172 It is an order of magnitude faster than the proper abbrev_match(),
173 but then again, vi is an order of magnitude faster than Emacs.
175 This speed difference should be unnoticeable, though. I have tested
176 the degenerated cases of thousands of abbrevs being defined, and
177 abbrev_match() was still fast enough for normal operation. */
179 abbrev_oblookup (struct buffer *buf, Lisp_Object obarray)
181 Bufpos wordstart, wordend;
186 CHECK_VECTOR (obarray);
188 if (!NILP (Vabbrev_start_location))
190 wordstart = get_buffer_pos_char (buf, Vabbrev_start_location,
192 Vabbrev_start_location = Qnil;
194 /* Previously, abbrev-prefix-mark crockishly inserted a dash to
195 indicate the abbrev start point. It now uses an extent with
196 a begin glyph so there's no dash to remove. */
197 if (wordstart != BUF_ZV (buf)
198 && BUF_FETCH_CHAR (buf, wordstart) == '-')
200 buffer_delete_range (buf, wordstart, wordstart + 1, 0);
203 wordend = BUF_PT (buf);
207 Bufpos point = BUF_PT (buf);
209 wordstart = scan_words (buf, point, -1);
213 wordend = scan_words (buf, wordstart, 1);
216 if (wordend > BUF_ZV (buf))
217 wordend = BUF_ZV (buf);
220 /* Unlike the original function, we allow expansion only after
221 the abbrev, not preceded by a number of spaces. This is
222 because of consistency with abbrev_match. */
227 if (wordend <= wordstart)
230 p = word = (Bufbyte *) alloca (MAX_EMCHAR_LEN * (wordend - wordstart));
231 for (idx = wordstart; idx < wordend; idx++)
233 Emchar c = BUF_FETCH_CHAR (buf, idx);
234 if (UPPERCASEP (buf, c))
235 c = DOWNCASE (buf, c);
236 p += set_charptr_emchar (p, c);
238 lookup = oblookup (obarray, word, p - word);
239 if (SYMBOLP (lookup) && !NILP (symbol_value (XSYMBOL (lookup))))
240 return XSYMBOL (lookup);
245 /* Return non-zero if OBARRAY contains an interned symbol ` '. */
247 obarray_has_blank_p (Lisp_Object obarray)
249 return !ZEROP (oblookup (obarray, (Bufbyte *)" ", 1));
252 /* Analyze case in the buffer substring, and report it. */
254 abbrev_count_case (struct buffer *buf, Bufpos pos, Charcount length,
255 int *lccount, int *uccount)
257 *lccount = *uccount = 0;
260 Emchar c = BUF_FETCH_CHAR (buf, pos);
261 if (UPPERCASEP (buf, c))
263 else if (LOWERCASEP (buf, c))
269 DEFUN ("expand-abbrev", Fexpand_abbrev, 0, 0, "", /*
270 Expand the abbrev before point, if any.
271 Effective when explicitly called even when `abbrev-mode' is nil.
272 Returns the abbrev symbol, if expansion took place.
273 If no abbrev matched, but `pre-abbrev-expand-hook' changed the buffer,
278 /* This function can GC */
279 struct buffer *buf = current_buffer;
280 int oldmodiff = BUF_MODIFF (buf);
281 Lisp_Object pre_modiff_p;
282 Bufpos point; /* position of point */
283 Bufpos abbrev_start; /* position of abbreviation beginning */
285 Lisp_Symbol *(*fun) (struct buffer *, Lisp_Object);
287 Lisp_Symbol *abbrev_symbol;
288 Lisp_String *abbrev_string;
289 Lisp_Object expansion, count, hook;
290 Charcount abbrev_length;
291 int lccount, uccount;
293 run_hook (Qpre_abbrev_expand_hook);
294 /* If the hook changes the buffer, treat that as having "done an
296 pre_modiff_p = (BUF_MODIFF (buf) != oldmodiff ? Qt : Qnil);
298 abbrev_symbol = NULL;
299 if (!BUFFERP (Vabbrev_start_location_buffer) ||
300 XBUFFER (Vabbrev_start_location_buffer) != buf)
301 Vabbrev_start_location = Qnil;
302 /* We use the more general abbrev_match() if the obarray blank flag
303 is not set, and Vabbrev_start_location is nil. Otherwise, use
304 abbrev_oblookup(). */
305 #define MATCHFUN(tbl) ((obarray_has_blank_p (tbl) \
306 && NILP (Vabbrev_start_location)) \
307 ? abbrev_match : abbrev_oblookup)
308 if (!NILP (buf->abbrev_table))
310 fun = MATCHFUN (buf->abbrev_table);
311 abbrev_symbol = fun (buf, buf->abbrev_table);
313 if (!abbrev_symbol && !NILP (Vglobal_abbrev_table))
315 fun = MATCHFUN (Vglobal_abbrev_table);
316 abbrev_symbol = fun (buf, Vglobal_abbrev_table);
321 /* NOTE: we hope that `pre-abbrev-expand-hook' didn't do something
322 nasty, such as changed the buffer. Here we protect against the
323 buffer getting killed. */
324 if (! BUFFER_LIVE_P (buf))
326 point = BUF_PT (buf);
328 /* OK, we're out of the must-be-fast part. An abbreviation matched.
329 Now find the parameters, insert the expansion, and make it all
331 abbrev_string = symbol_name (abbrev_symbol);
332 abbrev_length = string_char_length (abbrev_string);
333 abbrev_start = point - abbrev_length;
335 expansion = symbol_value (abbrev_symbol);
336 CHECK_STRING (expansion);
338 count = symbol_plist (abbrev_symbol); /* Gag */
342 CHECK_NATNUM (count);
343 symbol_plist (abbrev_symbol) = make_int (1 + XINT (count));
345 /* Count the case in the original text. */
346 abbrev_count_case (buf, abbrev_start, abbrev_length, &lccount, &uccount);
348 /* Remember the last abbrev text, location, etc. */
349 XSETSYMBOL (Vlast_abbrev, abbrev_symbol);
351 make_string_from_buffer (buf, abbrev_start, abbrev_length);
352 last_abbrev_location = abbrev_start;
354 /* Add an undo boundary, in case we are doing this for a
355 self-inserting command which has avoided making one so far. */
359 /* Remove the abbrev */
360 buffer_delete_range (buf, abbrev_start, point, 0);
361 /* And insert the expansion. */
362 buffer_insert_lisp_string (buf, expansion);
363 point = BUF_PT (buf);
365 /* Now fiddle with the case. */
366 if (uccount && !lccount)
368 /* Abbrev was all caps */
370 && scan_words (buf, point, -1) > scan_words (buf, abbrev_start, 1))
372 Fupcase_initials_region (make_int (abbrev_start), make_int (point),
377 /* If expansion is one word, or if user says so, upcase it all. */
378 Fupcase_region (make_int (abbrev_start), make_int (point),
384 /* Abbrev included some caps. Cap first initial of expansion */
385 Bufpos pos = abbrev_start;
386 /* Find the initial. */
388 && !WORD_SYNTAX_P (XCHAR_TABLE (buf->mirror_syntax_table),
389 BUF_FETCH_CHAR (buf, pos)))
391 /* Change just that. */
392 Fupcase_initials_region (make_int (pos), make_int (pos + 1),
396 hook = symbol_function (abbrev_symbol);
397 if (!NILP (hook) && !UNBOUNDP (hook))
405 syms_of_abbrev (void)
407 defsymbol (&Qpre_abbrev_expand_hook, "pre-abbrev-expand-hook");
408 DEFSUBR (Fexpand_abbrev);
412 vars_of_abbrev (void)
414 DEFVAR_LISP ("global-abbrev-table", &Vglobal_abbrev_table /*
415 The abbrev table whose abbrevs affect all buffers.
416 Each buffer may also have a local abbrev table.
417 If it does, the local table overrides the global one
418 for any particular abbrev defined in both.
420 Vglobal_abbrev_table = Qnil; /* setup by Lisp code */
422 DEFVAR_LISP ("last-abbrev", &Vlast_abbrev /*
423 The abbrev-symbol of the last abbrev expanded.
424 See the function `abbrev-symbol'.
427 DEFVAR_LISP ("last-abbrev-text", &Vlast_abbrev_text /*
428 The exact text of the last abbrev expanded.
429 nil if the abbrev has already been unexpanded.
432 DEFVAR_INT ("last-abbrev-location", &last_abbrev_location /*
433 The location of the start of the last abbrev expanded.
437 Vlast_abbrev_text = Qnil;
438 last_abbrev_location = 0;
440 DEFVAR_LISP ("abbrev-start-location", &Vabbrev_start_location /*
441 Buffer position for `expand-abbrev' to use as the start of the abbrev.
442 nil means use the word before point as the abbrev.
443 Calling `expand-abbrev' sets this to nil.
445 Vabbrev_start_location = Qnil;
447 DEFVAR_LISP ("abbrev-start-location-buffer", &Vabbrev_start_location_buffer /*
448 Buffer that `abbrev-start-location' has been set for.
449 Trying to expand an abbrev in any other buffer clears `abbrev-start-location'.
451 Vabbrev_start_location_buffer = Qnil;
453 DEFVAR_BOOL ("abbrev-all-caps", &abbrev_all_caps /*
454 *Non-nil means expand multi-word abbrevs all caps if abbrev was so.
458 DEFVAR_LISP ("pre-abbrev-expand-hook", &Vpre_abbrev_expand_hook /*
459 Function or functions to be called before abbrev expansion is done.
460 This is the first thing that `expand-abbrev' does, and so this may change
461 the current abbrev table before abbrev lookup happens.
463 Vpre_abbrev_expand_hook = Qnil;