Mercurial > hg > xemacs-beta
annotate src/abbrev.c @ 2367:ecf1ebac70d8
[xemacs-hg @ 2004-11-04 23:05:23 by ben]
commit mega-patch
configure.in: Turn off -Winline and -Wchar-subscripts.
Use the right set of cflags when compiling modules.
Rewrite ldap configuration to separate the inclusion of lber
(needed in recent Cygwin) from the basic checks for the
needed libraries.
add a function for MAKE_JUNK_C; initially code was added to
generate xemacs.def using this, but it will need to be rewritten.
add an rm -f for junk.c to avoid weird Cygwin bug with cp -f onto
an existing file.
Sort list of auto-detected functions and eliminate unused checks for
stpcpy, setlocale and getwd.
Add autodetection of Cygwin scanf problems
BETA: Rewrite section on configure to indicate what flags are important
and what not.
digest-doc.c, make-dump-id.c, profile.c, sorted-doc.c: Add proper decls for main().
make-msgfile.c: Document that this is old junk.
Move proposal to text.c.
make-msgfile.lex: Move proposal to text.c.
make-mswin-unicode.pl: Convert error-generating code so that the entire message will
be seen as a single unrecognized token.
mule/mule-ccl.el: Update docs.
lispref/mule.texi: Update CCL docs.
ldap/eldap.c: Mule-ize.
Use EXTERNAL_LIST_LOOP_2 instead of deleted EXTERNAL_LIST_LOOP.
* XEmacs 21.5.18 "chestnut" is released.
---------------------------------------------------------------
MULE-RELATED WORK:
---------------------------------------------------------------
---------------------------
byte-char conversion
---------------------------
buffer.c, buffer.h, insdel.c, text.c: Port FSF algorithm for byte-char conversion, replacing broken
previous version. Track the char position of the gap. Add
functions to do char-byte conversion downwards as well as upwards.
Move comments about algorithm workings to internals manual.
---------------------------
work on types
---------------------------
alloc.c, console-x-impl.h, dump-data.c, dump-data.h, dumper.c, dialog-msw.c, dired-msw.c, doc.c, editfns.c, esd.c, event-gtk.h, event-msw.c, events.c, file-coding.c, file-coding.h, fns.c, glyphs-eimage.c, glyphs-gtk.c, glyphs-msw.c, glyphs-shared.c, glyphs-x.c, glyphs.c, glyphs.h, gui.c, hpplay.c, imgproc.c, intl-win32.c, lrecord.h, lstream.c, keymap.c, lisp.h, libsst.c, linuxplay.c, miscplay.c, miscplay.h, mule-coding.c, nas.c, nt.c, ntheap.c, ntplay.c, objects-msw.c, objects-tty.c, objects-x.c, print.c, process-nt.c, process.c, redisplay.h, select-common.h, select-gtk.c, select-x.c, sgiplay.c, sound.c, sound.h, sunplay.c, sysfile.h, sysdep.c, syswindows.h, text.c, unexnt.c, win32.c, xgccache.c: Further work on types. This creates a full set of types for all
the basic semantics of `char' that I have so far identified, so that
its semantics can always be identified for the purposes of proper
Mule-safe code, and the raw use of `char' always avoided.
(1) More type renaming, for consistency of naming.
Char_ASCII -> Ascbyte
UChar_ASCII -> UAscbyte
Char_Binary -> CBinbyte
UChar_Binary -> Binbyte
SChar_Binary -> SBinbyte
(2) Introduce Rawbyte, CRawbyte, Boolbyte, Chbyte, UChbyte, and
Bitbyte and use them.
(3) New types Itext, Wexttext and Textcount for separating out
the concepts of bytes and textual units (different under UTF-16
and UTF-32, which are potential internal encodings).
(4) qxestr*_c -> qxestr*_ascii.
lisp.h: New; goes with other qxe() functions. #### Maybe goes in a
different section.
lisp.h: Group generic int-type defs together with EMACS_INT defs.
lisp.h: * lisp.h (WEXTTEXT_IS_WIDE)
New defns.
lisp.h: New type to replace places where int occurs as a boolean.
It's signed because occasionally people may want to use -1 as
an error value, and because unsigned ints are viral -- see comments
in the internals manual against using them.
dynarr.c: int -> Bytecount.
---------------------------
Mule-izing
---------------------------
device-x.c: Partially Mule-ize.
dumper.c, dumper.h: Mule-ize. Use Rawbyte. Use stderr_out not printf. Use wext_*().
sysdep.c, syswindows.h, text.c: New Wexttext API for manipulation of external text that may be
Unicode (e.g. startup code under Windows).
emacs.c: Mule-ize. Properly deal with argv in external encoding.
Use wext_*() and Wexttext. Use Rawbyte.
#if 0 some old junk on SCO that is unlikely to be correct.
Rewrite allocation code in run-temacs.
emacs.c, symsinit.h, win32.c: Rename win32 init function and call it even earlier, to
initialize mswindows_9x_p even earlier, for use in startup code
(XEUNICODE_P).
process.c: Use _wenviron not environ under Windows, to get Unicode environment
variables.
event-Xt.c: Mule-ize drag-n-drop related stuff.
dragdrop.c, dragdrop.h, frame-x.c: Mule-ize.
text.h: Add some more stand-in defines for particular kinds of conversion;
use in Mule-ization work in frame-x.c etc.
---------------------------
Freshening
---------------------------
intl-auto-encap-win32.c, intl-auto-encap-win32.h: Regenerate.
---------------------------
Unicode-work
---------------------------
intl-win32.c, syswindows.h: Factor out common options to MultiByteToWideChar and
WideCharToMultiByte. Add convert_unicode_to_multibyte_malloc()
and convert_unicode_to_multibyte_dynarr() and use. Add stuff for
alloca() conversion of multibyte/unicode.
alloc.c: Use dfc_external_data_len() in case of unicode coding system.
alloc.c, mule-charset.c: Don't zero out and reinit charset Unicode tables. This fucks up
dump-time loading. Anyway, either we load them at dump time or
run time, never both.
unicode.c: Dump the blank tables as well.
---------------------------------------------------------------
DOCUMENTATION, MOSTLY MULE-RELATED:
---------------------------------------------------------------
EmacsFrame.c, emodules.c, event-Xt.c, fileio.c, input-method-xlib.c, mule-wnnfns.c, redisplay-gtk.c, redisplay-tty.c, redisplay-x.c, regex.c, sysdep.c: Add comment about Mule work needed.
text.h: Add more documentation describing why DFC routines were not written
to return their value. Add some other DFC documentation.
console-msw.c, console-msw.h: Add pointer to docs in win32.c.
emacs.c: Add comments on sources of doc info.
text.c, charset.h, unicode.c, intl-win32.c, intl-encap-win32.c, text.h, file-coding.c, mule-coding.c: Collect background comments and related to text matters and
internationalization, and proposals for work to be done, in text.c
or Internals manual, stuff related to specific textual API's in
text.h, and stuff related to internal implementation of Unicode
conversion in unicode.c. Put lots of pointers to the comments to
make them easier to find.
s/mingw32.h, s/win32-common.h, s/win32-native.h, s/windowsnt.h, win32.c: Add bunches of new documentation on the different kinds of
builds and environments under Windows and how they work.
Collect this info in win32.c. Add pointers to these docs in
the relevant s/* files.
emacs.c: Document places with long comments.
Remove comment about exiting, move to internals manual, put
in pointer.
event-stream.c: Move docs about event queues and focus to internals manual, put
in pointer.
events.h: Move docs about event stream callbacks to internals manual, put
in pointer.
profile.c, redisplay.c, signal.c: Move documentation to the Internals manual.
process-nt.c: Add pointer to comment in win32-native.el.
lisp.h: Add comments about some comment conventions.
lisp.h: Add comment about the second argument.
device-msw.c, redisplay-msw.c: @@#### comments are out-of-date.
---------------------------------------------------------------
PDUMP WORK (MOTIVATED BY UNICODE CHANGES)
---------------------------------------------------------------
alloc.c, buffer.c, bytecode.c, console-impl.h, console.c, device.c, dumper.c, lrecord.h, elhash.c, emodules.h, events.c, extents.c, frame.c, glyphs.c, glyphs.h, mule-charset.c, mule-coding.c, objects.c, profile.c, rangetab.c, redisplay.c, specifier.c, specifier.h, window.c, lstream.c, file-coding.h, file-coding.c: PDUMP:
Properly implement dump_add_root_block(), which never worked before,
and is necessary for dumping Unicode tables.
Pdump name changes for accuracy:
XD_STRUCT_PTR -> XD_BLOCK_PTR.
XD_STRUCT_ARRAY -> XD_BLOCK_ARRAY.
XD_C_STRING -> XD_ASCII_STRING.
*_structure_* -> *_block_*.
lrecord.h: some comments added about
dump_add_root_block() vs dump_add_root_block_ptr().
extents.c: remove incorrect comment about pdump problems with gap array.
---------------------------------------------------------------
ALLOCATION
---------------------------------------------------------------
abbrev.c, alloc.c, bytecode.c, casefiddle.c, device-msw.c, device-x.c, dired-msw.c, doc.c, doprnt.c, dragdrop.c, editfns.c, emodules.c, file-coding.c, fileio.c, filelock.c, fns.c, glyphs-eimage.c, glyphs-gtk.c, glyphs-msw.c, glyphs-x.c, gui-msw.c, gui-x.c, imgproc.c, intl-win32.c, lread.c, menubar-gtk.c, menubar.c, nt.c, objects-msw.c, objects-x.c, print.c, process-nt.c, process-unix.c, process.c, realpath.c, redisplay.c, search.c, select-common.c, symbols.c, sysdep.c, syswindows.h, text.c, text.h, ui-byhand.c: New macros {alloca,xnew}_{itext,{i,ext,raw,bin,asc}bytes} for
more convenient allocation of these commonly requested items.
Modify functions to use alloca_ibytes, alloca_array, alloca_extbytes,
xnew_ibytes, etc. also XREALLOC_ARRAY, xnew.
alloc.c: Rewrite the allocation functions to factor out repeated code.
Add assertions for freeing dumped data.
lisp.h: Moved down and consolidated with other allocation stuff.
lisp.h, dynarr.c: New functions for allocation that's very efficient when mostly in
LIFO order.
lisp.h, text.c, text.h: Factor out some stuff for general use by alloca()-conversion funs.
text.h, lisp.h: Fill out convenience routines for allocating various kinds of
bytes and put them in lisp.h. Use them in place of xmalloc(),
ALLOCA().
text.h: Fill out the convenience functions so the _MALLOC() kinds match
the alloca() kinds.
---------------------------------------------------------------
ERROR-CHECKING
---------------------------------------------------------------
text.h: Create ASSERT_ASCTEXT_ASCII() and ASSERT_ASCTEXT_ASCII_LEN()
from similar Eistring checkers and change the Eistring checkers to
use them instead.
---------------------------------------------------------------
MACROS IN LISP.H
---------------------------------------------------------------
lisp.h: Redo GCPRO declarations. Create a "base" set of functions that can
be used to generate any kind of gcpro sets -- regular, ngcpro,
nngcpro, private ones used in GC_EXTERNAL_LIST_LOOP_2.
buffer.c, callint.c, chartab.c, console-msw.c, device-x.c, dialog-msw.c, dired.c, extents.c, ui-gtk.c, rangetab.c, nt.c, mule-coding.c, minibuf.c, menubar-msw.c, menubar.c, menubar-gtk.c, lread.c, lisp.h, gutter.c, glyphs.c, glyphs-widget.c, fns.c, fileio.c, file-coding.c, specifier.c: Eliminate EXTERNAL_LIST_LOOP, which does not check for circularities.
Use EXTERNAL_LIST_LOOP_2 instead or EXTERNAL_LIST_LOOP_3
or EXTERNAL_PROPERTY_LIST_LOOP_3 or GC_EXTERNAL_LIST_LOOP_2
(new macro). Removed/redid comments on EXTERNAL_LIST_LOOP.
---------------------------------------------------------------
SPACING FIXES
---------------------------------------------------------------
callint.c, hftctl.c, number-gmp.c, process-unix.c: Spacing fixes.
---------------------------------------------------------------
FIX FOR GEOMETRY PROBLEM IN FIRST FRAME
---------------------------------------------------------------
unicode.c: Add workaround for newlib bug in sscanf() [should be fixed by
release 1.5.12 of Cygwin].
toolbar.c: bug fix for problem of initial frame being 77 chars wide on Windows.
will be overridden by my other ws.
---------------------------------------------------------------
FIX FOR LEAKING PROCESS HANDLES:
---------------------------------------------------------------
process-nt.c: Fixes for leaking handles. Inspired by work done by Adrian Aichner
<adrian@xemacs.org>.
---------------------------------------------------------------
FIX FOR CYGWIN BUG (Unicode-related):
---------------------------------------------------------------
unicode.c: Add workaround for newlib bug in sscanf() [should be fixed by
release 1.5.12 of Cygwin].
---------------------------------------------------------------
WARNING FIXES:
---------------------------------------------------------------
console-stream.c: `reinit' is unused.
compiler.h, event-msw.c, frame-msw.c, intl-encap-win32.c, text.h: Add stuff to deal with ANSI-aliasing warnings I got.
regex.c: Gather includes together to avoid warning.
---------------------------------------------------------------
CHANGES TO INITIALIZATION ROUTINES:
---------------------------------------------------------------
buffer.c, emacs.c, console.c, debug.c, device-x.c, device.c, dragdrop.c, emodules.c, eval.c, event-Xt.c, event-gtk.c, event-msw.c, event-stream.c, event-tty.c, events.c, extents.c, faces.c, file-coding.c, fileio.c, font-lock.c, frame-msw.c, glyphs-widget.c, glyphs.c, gui-x.c, insdel.c, lread.c, lstream.c, menubar-gtk.c, menubar-x.c, minibuf.c, mule-wnnfns.c, objects-msw.c, objects.c, print.c, scrollbar-x.c, search.c, select-x.c, text.c, undo.c, unicode.c, window.c, symsinit.h: Call reinit_*() functions directly from emacs.c, for clarity.
Factor out some redundant init code. Move disallowed stuff
that had crept into vars_of_glyphs() into complex_vars_of_glyphs().
Call init_eval_semi_early() from eval.c not in the middle of
vars_of_() in emacs.c since there should be no order dependency
in the latter calls.
---------------------------------------------------------------
ARMAGEDDON:
---------------------------------------------------------------
alloc.c, emacs.c, lisp.h, print.c: Rename inhibit_non_essential_printing_operations to
inhibit_non_essential_conversion_operations.
text.c: Assert on !inhibit_non_essential_conversion_operations.
console-msw.c, print.c: Don't do conversion in SetConsoleTitle or FindWindow to avoid
problems during armageddon. Put #errors for NON_ASCII_INTERNAL_FORMAT
in places where problems would arise.
---------------------------------------------------------------
CHANGES TO THE BUILD PROCEDURE:
---------------------------------------------------------------
config.h.in, s/cxux.h, s/usg5-4-2.h, m/powerpc.h: Add comment about correct ordering of this file.
Rearrange everything to follow this -- put all #undefs together
and before the s&m files. Add undefs for HAVE_ALLOCA, C_ALLOCA,
BROKEN_ALLOCA_IN_FUNCTION_CALLS, STACK_DIRECTION. Remove unused
HAVE_STPCPY, HAVE_GETWD, HAVE_SETLOCALE.
m/gec63.h: Deleted; totally broken, not used at all, not in FSF.
m/7300.h, m/acorn.h, m/alliant-2800.h, m/alliant.h, m/altos.h, m/amdahl.h, m/apollo.h, m/att3b.h, m/aviion.h, m/celerity.h, m/clipper.h, m/cnvrgnt.h, m/convex.h, m/cydra5.h, m/delta.h, m/delta88k.h, m/dpx2.h, m/elxsi.h, m/ews4800r.h, m/gould.h, m/hp300bsd.h, m/hp800.h, m/hp9000s300.h, m/i860.h, m/ibmps2-aix.h, m/ibmrs6000.h, m/ibmrt-aix.h, m/ibmrt.h, m/intel386.h, m/iris4d.h, m/iris5d.h, m/iris6d.h, m/irist.h, m/isi-ov.h, m/luna88k.h, m/m68k.h, m/masscomp.h, m/mg1.h, m/mips-nec.h, m/mips-siemens.h, m/mips.h, m/news.h, m/nh3000.h, m/nh4000.h, m/ns32000.h, m/orion105.h, m/pfa50.h, m/plexus.h, m/pmax.h, m/powerpc.h, m/pyrmips.h, m/sequent-ptx.h, m/sequent.h, m/sgi-challenge.h, m/symmetry.h, m/tad68k.h, m/tahoe.h, m/targon31.h, m/tekxd88.h, m/template.h, m/tower32.h, m/tower32v3.h, m/ustation.h, m/vax.h, m/wicat.h, m/xps100.h: Delete C_ALLOCA, HAVE_ALLOCA, STACK_DIRECTION,
BROKEN_ALLOCA_IN_FUNCTION_CALLS. All of this is auto-detected.
When in doubt, I followed recent FSF sources, which also have
these things deleted.
| author | ben |
|---|---|
| date | Thu, 04 Nov 2004 23:08:28 +0000 |
| parents | 804517e16990 |
| children | 69c43a181729 |
| rev | line source |
|---|---|
| 428 | 1 /* Primitives for word-abbrev mode. |
| 2 Copyright (C) 1985, 1986, 1992, 1993 Free Software Foundation, Inc. | |
| 793 | 3 Copyright (C) 2002 Ben Wing. |
| 428 | 4 |
| 5 This file is part of XEmacs. | |
| 6 | |
| 7 XEmacs is free software; you can redistribute it and/or modify it | |
| 8 under the terms of the GNU General Public License as published by the | |
| 9 Free Software Foundation; either version 2, or (at your option) any | |
| 10 later version. | |
| 11 | |
| 12 XEmacs is distributed in the hope that it will be useful, but WITHOUT | |
| 13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 15 for more details. | |
| 16 | |
| 17 You should have received a copy of the GNU General Public License | |
| 18 along with XEmacs; see the file COPYING. If not, write to | |
| 19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
| 20 Boston, MA 02111-1307, USA. */ | |
| 21 | |
| 22 /* Synched up with: FSF 19.30. Note that there are many more functions in | |
| 23 FSF's abbrev.c. These have been moved into Lisp in XEmacs. */ | |
| 24 | |
| 25 /* Authorship: | |
| 26 | |
| 27 FSF: Original version; a long time ago. | |
| 28 JWZ or Mly: Mostly moved into Lisp; maybe 1992. | |
| 29 Ben Wing: Some changes for Mule for 19.12. | |
| 30 Hrvoje Niksic: Largely rewritten in June 1997. | |
| 31 */ | |
| 32 | |
| 33 /* This file has been Mule-ized. */ | |
| 34 | |
| 35 #include <config.h> | |
| 36 #include "lisp.h" | |
| 37 | |
| 38 #include "buffer.h" | |
| 39 #include "commands.h" | |
| 40 #include "insdel.h" | |
| 41 #include "syntax.h" | |
| 42 #include "window.h" | |
| 43 | |
| 44 /* An abbrev table is an obarray. | |
| 45 Each defined abbrev is represented by a symbol in that obarray | |
| 46 whose print name is the abbreviation. | |
| 47 The symbol's value is a string which is the expansion. | |
| 48 If its function definition is non-nil, it is called | |
| 49 after the expansion is done. | |
| 50 The plist slot of the abbrev symbol is its usage count. */ | |
| 51 | |
| 52 /* The table of global abbrevs. These are in effect | |
| 53 in any buffer in which abbrev mode is turned on. */ | |
| 54 Lisp_Object Vglobal_abbrev_table; | |
| 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 Lisp_Object Vabbrev_start_location; | |
| 61 | |
| 62 /* Buffer that Vabbrev_start_location applies to */ | |
| 63 Lisp_Object Vabbrev_start_location_buffer; | |
| 64 | |
| 65 /* The symbol representing the abbrev most recently expanded */ | |
| 66 Lisp_Object Vlast_abbrev; | |
| 67 | |
| 68 /* A string for the actual text of the abbrev most recently expanded. | |
| 69 This has more info than Vlast_abbrev since case is significant. */ | |
| 70 Lisp_Object Vlast_abbrev_text; | |
| 71 | |
| 72 /* Character address of start of last abbrev expanded */ | |
| 458 | 73 Fixnum last_abbrev_location; |
| 428 | 74 |
| 75 /* Hook to run before expanding any abbrev. */ | |
| 76 Lisp_Object Vpre_abbrev_expand_hook, Qpre_abbrev_expand_hook; | |
| 77 | |
| 78 | |
| 826 | 79 struct abbrev_match_mapper_closure |
| 80 { | |
| 428 | 81 struct buffer *buf; |
| 826 | 82 Lisp_Object chartab; |
| 814 | 83 Charbpos point; |
| 84 Charcount maxlen; | |
| 440 | 85 Lisp_Symbol *found; |
| 428 | 86 }; |
| 87 | |
| 88 /* For use by abbrev_match(): Match SYMBOL's name against buffer text | |
| 89 before point, case-insensitively. When found, return non-zero, so | |
| 90 that map_obarray terminates mapping. */ | |
| 91 static int | |
| 92 abbrev_match_mapper (Lisp_Object symbol, void *arg) | |
| 93 { | |
| 94 struct abbrev_match_mapper_closure *closure = | |
| 95 (struct abbrev_match_mapper_closure *)arg; | |
| 96 Charcount abbrev_length; | |
| 440 | 97 Lisp_Symbol *sym = XSYMBOL (symbol); |
| 793 | 98 Lisp_Object abbrev; |
| 428 | 99 |
| 100 /* symbol_value should be OK here, because abbrevs are not expected | |
| 101 to contain any SYMBOL_MAGIC stuff. */ | |
| 102 if (UNBOUNDP (symbol_value (sym)) || NILP (symbol_value (sym))) | |
| 103 { | |
| 104 /* The symbol value of nil means that abbrev got undefined. */ | |
| 105 return 0; | |
| 106 } | |
| 107 abbrev = symbol_name (sym); | |
| 826 | 108 abbrev_length = string_char_length (abbrev); |
| 428 | 109 if (abbrev_length > closure->maxlen) |
| 110 { | |
| 111 /* This abbrev is too large -- it wouldn't fit. */ | |
| 112 return 0; | |
| 113 } | |
| 114 /* If `bar' is an abbrev, and a user presses `fubar<SPC>', we don't | |
| 115 normally want to expand it. OTOH, if the abbrev begins with | |
| 116 non-word syntax (e.g. `#if'), it is OK to abbreviate it anywhere. */ | |
| 117 if (abbrev_length < closure->maxlen && abbrev_length > 0 | |
| 867 | 118 && (WORD_SYNTAX_P (closure->chartab, string_ichar (abbrev, 0))) |
| 428 | 119 && (WORD_SYNTAX_P (closure->chartab, |
| 120 BUF_FETCH_CHAR (closure->buf, | |
| 793 | 121 closure->point - |
| 122 (abbrev_length + 1))))) | |
| 428 | 123 { |
| 124 return 0; | |
| 125 } | |
| 126 /* Match abbreviation string against buffer text. */ | |
| 127 { | |
| 867 | 128 Ibyte *ptr = XSTRING_DATA (abbrev); |
| 428 | 129 Charcount idx; |
| 130 | |
| 131 for (idx = 0; idx < abbrev_length; idx++) | |
| 132 { | |
| 133 if (DOWNCASE (closure->buf, | |
| 134 BUF_FETCH_CHAR (closure->buf, | |
| 135 closure->point - abbrev_length + idx)) | |
| 867 | 136 != DOWNCASE (closure->buf, itext_ichar (ptr))) |
| 428 | 137 { |
| 138 break; | |
| 139 } | |
| 867 | 140 INC_IBYTEPTR (ptr); |
| 428 | 141 } |
| 142 if (idx == abbrev_length) | |
| 143 { | |
| 144 /* This is the one. */ | |
| 145 closure->found = sym; | |
| 146 return 1; | |
| 147 } | |
| 148 } | |
| 149 return 0; | |
| 150 } | |
| 151 | |
| 152 /* Match the buffer text against names of symbols in obarray. Returns | |
| 153 the matching symbol, or 0 if not found. */ | |
| 440 | 154 static Lisp_Symbol * |
| 428 | 155 abbrev_match (struct buffer *buf, Lisp_Object obarray) |
| 156 { | |
| 157 struct abbrev_match_mapper_closure closure; | |
| 158 | |
| 159 /* Precalculate some stuff, so mapper function needn't to it in each | |
| 160 iteration. */ | |
| 161 closure.buf = buf; | |
| 162 closure.point = BUF_PT (buf); | |
| 163 closure.maxlen = closure.point - BUF_BEGV (buf); | |
| 826 | 164 closure.chartab = buf->mirror_syntax_table; |
| 428 | 165 closure.found = 0; |
| 166 | |
| 167 map_obarray (obarray, abbrev_match_mapper, &closure); | |
| 168 | |
| 169 return closure.found; | |
| 170 } | |
| 171 | |
| 172 /* Take the word before point (or Vabbrev_start_location, if non-nil), | |
| 173 and look it up in OBARRAY, and return the symbol (or zero). This | |
| 174 used to be the default method of searching, with the obvious | |
| 175 limitation that the abbrevs may consist only of word characters. | |
| 176 It is an order of magnitude faster than the proper abbrev_match(), | |
| 177 but then again, vi is an order of magnitude faster than Emacs. | |
| 178 | |
| 179 This speed difference should be unnoticeable, though. I have tested | |
| 180 the degenerated cases of thousands of abbrevs being defined, and | |
| 181 abbrev_match() was still fast enough for normal operation. */ | |
| 440 | 182 static Lisp_Symbol * |
| 428 | 183 abbrev_oblookup (struct buffer *buf, Lisp_Object obarray) |
| 184 { | |
| 665 | 185 Charbpos wordstart, wordend; |
| 867 | 186 Ibyte *word, *p; |
| 814 | 187 Charbpos idx; |
| 428 | 188 Lisp_Object lookup; |
| 189 | |
| 190 CHECK_VECTOR (obarray); | |
| 191 | |
| 192 if (!NILP (Vabbrev_start_location)) | |
| 193 { | |
| 194 wordstart = get_buffer_pos_char (buf, Vabbrev_start_location, | |
| 195 GB_COERCE_RANGE); | |
| 196 Vabbrev_start_location = Qnil; | |
| 197 #if 0 | |
| 198 /* Previously, abbrev-prefix-mark crockishly inserted a dash to | |
| 199 indicate the abbrev start point. It now uses an extent with | |
| 200 a begin glyph so there's no dash to remove. */ | |
| 201 if (wordstart != BUF_ZV (buf) | |
| 202 && BUF_FETCH_CHAR (buf, wordstart) == '-') | |
| 203 { | |
| 204 buffer_delete_range (buf, wordstart, wordstart + 1, 0); | |
| 205 } | |
| 206 #endif | |
| 207 wordend = BUF_PT (buf); | |
| 208 } | |
| 209 else | |
| 210 { | |
| 665 | 211 Charbpos point = BUF_PT (buf); |
| 428 | 212 |
| 213 wordstart = scan_words (buf, point, -1); | |
| 214 if (!wordstart) | |
| 215 return 0; | |
| 216 | |
| 217 wordend = scan_words (buf, wordstart, 1); | |
| 218 if (!wordend) | |
| 219 return 0; | |
| 220 if (wordend > BUF_ZV (buf)) | |
| 221 wordend = BUF_ZV (buf); | |
| 222 if (wordend > point) | |
| 223 wordend = point; | |
| 224 /* Unlike the original function, we allow expansion only after | |
| 225 the abbrev, not preceded by a number of spaces. This is | |
| 226 because of consistency with abbrev_match. */ | |
| 227 if (wordend < point) | |
| 228 return 0; | |
| 229 } | |
| 230 | |
| 231 if (wordend <= wordstart) | |
| 232 return 0; | |
| 233 | |
| 2367 | 234 p = word = alloca_ibytes (MAX_ICHAR_LEN * (wordend - wordstart)); |
| 428 | 235 for (idx = wordstart; idx < wordend; idx++) |
| 236 { | |
| 867 | 237 Ichar c = BUF_FETCH_CHAR (buf, idx); |
| 428 | 238 if (UPPERCASEP (buf, c)) |
| 239 c = DOWNCASE (buf, c); | |
| 867 | 240 p += set_itext_ichar (p, c); |
| 428 | 241 } |
| 242 lookup = oblookup (obarray, word, p - word); | |
| 243 if (SYMBOLP (lookup) && !NILP (symbol_value (XSYMBOL (lookup)))) | |
| 244 return XSYMBOL (lookup); | |
| 245 else | |
| 246 return NULL; | |
| 247 } | |
| 248 | |
| 249 /* Return non-zero if OBARRAY contains an interned symbol ` '. */ | |
| 250 static int | |
| 251 obarray_has_blank_p (Lisp_Object obarray) | |
| 252 { | |
| 867 | 253 return !ZEROP (oblookup (obarray, (Ibyte *)" ", 1)); |
| 428 | 254 } |
| 255 | |
| 256 /* Analyze case in the buffer substring, and report it. */ | |
| 257 static void | |
| 665 | 258 abbrev_count_case (struct buffer *buf, Charbpos pos, Charcount length, |
| 428 | 259 int *lccount, int *uccount) |
| 260 { | |
| 261 *lccount = *uccount = 0; | |
| 262 while (length--) | |
| 263 { | |
| 867 | 264 Ichar c = BUF_FETCH_CHAR (buf, pos); |
| 428 | 265 if (UPPERCASEP (buf, c)) |
| 266 ++*uccount; | |
| 267 else if (LOWERCASEP (buf, c)) | |
| 268 ++*lccount; | |
| 269 ++pos; | |
| 270 } | |
| 271 } | |
| 272 | |
| 273 DEFUN ("expand-abbrev", Fexpand_abbrev, 0, 0, "", /* | |
| 274 Expand the abbrev before point, if any. | |
| 275 Effective when explicitly called even when `abbrev-mode' is nil. | |
| 276 Returns the abbrev symbol, if expansion took place. | |
| 277 If no abbrev matched, but `pre-abbrev-expand-hook' changed the buffer, | |
| 278 returns t. | |
| 279 */ | |
| 280 ()) | |
| 281 { | |
| 282 /* This function can GC */ | |
| 283 struct buffer *buf = current_buffer; | |
| 284 int oldmodiff = BUF_MODIFF (buf); | |
| 285 Lisp_Object pre_modiff_p; | |
| 665 | 286 Charbpos point; /* position of point */ |
| 287 Charbpos abbrev_start; /* position of abbreviation beginning */ | |
| 428 | 288 |
| 440 | 289 Lisp_Symbol *(*fun) (struct buffer *, Lisp_Object); |
| 428 | 290 |
| 440 | 291 Lisp_Symbol *abbrev_symbol; |
| 428 | 292 Lisp_Object expansion, count, hook; |
| 293 Charcount abbrev_length; | |
| 294 int lccount, uccount; | |
| 295 | |
| 296 run_hook (Qpre_abbrev_expand_hook); | |
| 297 /* If the hook changes the buffer, treat that as having "done an | |
| 298 expansion". */ | |
| 299 pre_modiff_p = (BUF_MODIFF (buf) != oldmodiff ? Qt : Qnil); | |
| 300 | |
| 301 abbrev_symbol = NULL; | |
| 302 if (!BUFFERP (Vabbrev_start_location_buffer) || | |
| 303 XBUFFER (Vabbrev_start_location_buffer) != buf) | |
| 304 Vabbrev_start_location = Qnil; | |
| 305 /* We use the more general abbrev_match() if the obarray blank flag | |
| 306 is not set, and Vabbrev_start_location is nil. Otherwise, use | |
| 307 abbrev_oblookup(). */ | |
| 308 #define MATCHFUN(tbl) ((obarray_has_blank_p (tbl) \ | |
| 309 && NILP (Vabbrev_start_location)) \ | |
| 310 ? abbrev_match : abbrev_oblookup) | |
| 311 if (!NILP (buf->abbrev_table)) | |
| 312 { | |
| 313 fun = MATCHFUN (buf->abbrev_table); | |
| 314 abbrev_symbol = fun (buf, buf->abbrev_table); | |
| 315 } | |
| 316 if (!abbrev_symbol && !NILP (Vglobal_abbrev_table)) | |
| 317 { | |
| 318 fun = MATCHFUN (Vglobal_abbrev_table); | |
| 319 abbrev_symbol = fun (buf, Vglobal_abbrev_table); | |
| 320 } | |
| 321 if (!abbrev_symbol) | |
| 322 return pre_modiff_p; | |
| 323 | |
| 324 /* NOTE: we hope that `pre-abbrev-expand-hook' didn't do something | |
| 325 nasty, such as changed the buffer. Here we protect against the | |
| 326 buffer getting killed. */ | |
| 327 if (! BUFFER_LIVE_P (buf)) | |
| 328 return Qnil; | |
| 329 point = BUF_PT (buf); | |
| 330 | |
| 331 /* OK, we're out of the must-be-fast part. An abbreviation matched. | |
| 332 Now find the parameters, insert the expansion, and make it all | |
| 333 look pretty. */ | |
| 826 | 334 abbrev_length = string_char_length (symbol_name (abbrev_symbol)); |
| 428 | 335 abbrev_start = point - abbrev_length; |
| 336 | |
| 337 expansion = symbol_value (abbrev_symbol); | |
| 338 CHECK_STRING (expansion); | |
| 339 | |
| 340 count = symbol_plist (abbrev_symbol); /* Gag */ | |
| 341 if (NILP (count)) | |
| 342 count = Qzero; | |
| 343 else | |
| 344 CHECK_NATNUM (count); | |
| 345 symbol_plist (abbrev_symbol) = make_int (1 + XINT (count)); | |
| 346 | |
| 347 /* Count the case in the original text. */ | |
| 348 abbrev_count_case (buf, abbrev_start, abbrev_length, &lccount, &uccount); | |
| 349 | |
| 350 /* Remember the last abbrev text, location, etc. */ | |
| 793 | 351 Vlast_abbrev = wrap_symbol (abbrev_symbol); |
| 428 | 352 Vlast_abbrev_text = |
| 353 make_string_from_buffer (buf, abbrev_start, abbrev_length); | |
| 354 last_abbrev_location = abbrev_start; | |
| 355 | |
| 356 /* Add an undo boundary, in case we are doing this for a | |
| 357 self-inserting command which has avoided making one so far. */ | |
| 358 if (INTERACTIVE) | |
| 359 Fundo_boundary (); | |
| 360 | |
| 361 /* Remove the abbrev */ | |
| 362 buffer_delete_range (buf, abbrev_start, point, 0); | |
| 363 /* And insert the expansion. */ | |
| 364 buffer_insert_lisp_string (buf, expansion); | |
| 365 point = BUF_PT (buf); | |
| 366 | |
| 367 /* Now fiddle with the case. */ | |
| 368 if (uccount && !lccount) | |
| 369 { | |
| 370 /* Abbrev was all caps */ | |
| 371 if (!abbrev_all_caps | |
| 372 && scan_words (buf, point, -1) > scan_words (buf, abbrev_start, 1)) | |
| 373 { | |
| 374 Fupcase_initials_region (make_int (abbrev_start), make_int (point), | |
| 771 | 375 wrap_buffer (buf)); |
| 428 | 376 } |
| 377 else | |
| 378 { | |
| 379 /* If expansion is one word, or if user says so, upcase it all. */ | |
| 380 Fupcase_region (make_int (abbrev_start), make_int (point), | |
| 771 | 381 wrap_buffer (buf)); |
| 428 | 382 } |
| 383 } | |
| 384 else if (uccount) | |
| 385 { | |
| 386 /* Abbrev included some caps. Cap first initial of expansion */ | |
| 665 | 387 Charbpos pos = abbrev_start; |
| 428 | 388 /* Find the initial. */ |
| 389 while (pos < point | |
| 826 | 390 && !WORD_SYNTAX_P (buf->mirror_syntax_table, |
| 428 | 391 BUF_FETCH_CHAR (buf, pos))) |
| 392 pos++; | |
| 393 /* Change just that. */ | |
| 394 Fupcase_initials_region (make_int (pos), make_int (pos + 1), | |
| 771 | 395 wrap_buffer (buf)); |
| 428 | 396 } |
| 397 | |
| 398 hook = symbol_function (abbrev_symbol); | |
| 399 if (!NILP (hook) && !UNBOUNDP (hook)) | |
| 400 call0 (hook); | |
| 401 | |
| 402 return Vlast_abbrev; | |
| 403 } | |
| 404 | |
| 405 | |
| 406 void | |
| 407 syms_of_abbrev (void) | |
| 408 { | |
| 563 | 409 DEFSYMBOL (Qpre_abbrev_expand_hook); |
| 428 | 410 DEFSUBR (Fexpand_abbrev); |
| 411 } | |
| 412 | |
| 413 void | |
| 414 vars_of_abbrev (void) | |
| 415 { | |
| 416 DEFVAR_LISP ("global-abbrev-table", &Vglobal_abbrev_table /* | |
| 417 The abbrev table whose abbrevs affect all buffers. | |
| 418 Each buffer may also have a local abbrev table. | |
| 419 If it does, the local table overrides the global one | |
| 420 for any particular abbrev defined in both. | |
| 421 */ ); | |
| 422 Vglobal_abbrev_table = Qnil; /* setup by Lisp code */ | |
| 423 | |
| 424 DEFVAR_LISP ("last-abbrev", &Vlast_abbrev /* | |
| 425 The abbrev-symbol of the last abbrev expanded. | |
| 426 See the function `abbrev-symbol'. | |
| 427 */ ); | |
| 428 | |
| 429 DEFVAR_LISP ("last-abbrev-text", &Vlast_abbrev_text /* | |
| 430 The exact text of the last abbrev expanded. | |
| 431 nil if the abbrev has already been unexpanded. | |
| 432 */ ); | |
| 433 | |
| 434 DEFVAR_INT ("last-abbrev-location", &last_abbrev_location /* | |
| 435 The location of the start of the last abbrev expanded. | |
| 436 */ ); | |
| 437 | |
| 438 Vlast_abbrev = Qnil; | |
| 439 Vlast_abbrev_text = Qnil; | |
| 440 last_abbrev_location = 0; | |
| 441 | |
| 442 DEFVAR_LISP ("abbrev-start-location", &Vabbrev_start_location /* | |
| 443 Buffer position for `expand-abbrev' to use as the start of the abbrev. | |
| 444 nil means use the word before point as the abbrev. | |
| 445 Calling `expand-abbrev' sets this to nil. | |
| 446 */ ); | |
| 447 Vabbrev_start_location = Qnil; | |
| 448 | |
| 449 DEFVAR_LISP ("abbrev-start-location-buffer", &Vabbrev_start_location_buffer /* | |
| 450 Buffer that `abbrev-start-location' has been set for. | |
| 451 Trying to expand an abbrev in any other buffer clears `abbrev-start-location'. | |
| 452 */ ); | |
| 453 Vabbrev_start_location_buffer = Qnil; | |
| 454 | |
| 455 DEFVAR_BOOL ("abbrev-all-caps", &abbrev_all_caps /* | |
| 456 *Non-nil means expand multi-word abbrevs all caps if abbrev was so. | |
| 457 */ ); | |
| 458 abbrev_all_caps = 0; | |
| 459 | |
| 460 DEFVAR_LISP ("pre-abbrev-expand-hook", &Vpre_abbrev_expand_hook /* | |
| 461 Function or functions to be called before abbrev expansion is done. | |
| 462 This is the first thing that `expand-abbrev' does, and so this may change | |
| 463 the current abbrev table before abbrev lookup happens. | |
| 464 */ ); | |
| 465 Vpre_abbrev_expand_hook = Qnil; | |
| 466 } |