| 1 | @c -*-texinfo-*- |
| 2 | @c This is part of the GNU Emacs Lisp Reference Manual. |
| 3 | @c Copyright (C) 1990-1994, 1999, 2001-2012 Free Software Foundation, Inc. |
| 4 | @c See the file elisp.texi for copying conditions. |
| 5 | @node Abbrevs |
| 6 | @chapter Abbrevs and Abbrev Expansion |
| 7 | @cindex abbrev |
| 8 | @c @cindex abbrev table Redundant with "abbrev". |
| 9 | |
| 10 | An abbreviation or @dfn{abbrev} is a string of characters that may be |
| 11 | expanded to a longer string. The user can insert the abbrev string and |
| 12 | find it replaced automatically with the expansion of the abbrev. This |
| 13 | saves typing. |
| 14 | |
| 15 | The set of abbrevs currently in effect is recorded in an @dfn{abbrev |
| 16 | table}. Each buffer has a local abbrev table, but normally all buffers |
| 17 | in the same major mode share one abbrev table. There is also a global |
| 18 | abbrev table. Normally both are used. |
| 19 | |
| 20 | An abbrev table is represented as an obarray. @xref{Creating |
| 21 | Symbols}, for information about obarrays. Each abbreviation is |
| 22 | represented by a symbol in the obarray. The symbol's name is the |
| 23 | abbreviation; its value is the expansion; its function definition is |
| 24 | the hook function for performing the expansion (@pxref{Defining |
| 25 | Abbrevs}); and its property list cell contains various additional |
| 26 | properties, including the use count and the number of times the |
| 27 | abbreviation has been expanded (@pxref{Abbrev Properties}). |
| 28 | |
| 29 | @cindex system abbrev |
| 30 | Certain abbrevs, called @dfn{system abbrevs}, are defined by a major |
| 31 | mode instead of the user. A system abbrev is identified by its |
| 32 | non-@code{nil} @code{:system} property (@pxref{Abbrev Properties}). |
| 33 | When abbrevs are saved to an abbrev file, system abbrevs are omitted. |
| 34 | @xref{Abbrev Files}. |
| 35 | |
| 36 | Because the symbols used for abbrevs are not interned in the usual |
| 37 | obarray, they will never appear as the result of reading a Lisp |
| 38 | expression; in fact, normally they are never used except by the code |
| 39 | that handles abbrevs. Therefore, it is safe to use them in a |
| 40 | nonstandard way. |
| 41 | |
| 42 | If the minor mode Abbrev mode is enabled, the buffer-local variable |
| 43 | @code{abbrev-mode} is non-@code{nil}, and abbrevs are automatically |
| 44 | expanded in the buffer. For the user-level commands for abbrevs, see |
| 45 | @ref{Abbrevs,, Abbrev Mode, emacs, The GNU Emacs Manual}. |
| 46 | |
| 47 | @menu |
| 48 | * Tables: Abbrev Tables. Creating and working with abbrev tables. |
| 49 | * Defining Abbrevs:: Specifying abbreviations and their expansions. |
| 50 | * Files: Abbrev Files. Saving abbrevs in files. |
| 51 | * Expansion: Abbrev Expansion. Controlling expansion; expansion subroutines. |
| 52 | * Standard Abbrev Tables:: Abbrev tables used by various major modes. |
| 53 | * Abbrev Properties:: How to read and set abbrev properties. |
| 54 | Which properties have which effect. |
| 55 | * Abbrev Table Properties:: How to read and set abbrev table properties. |
| 56 | Which properties have which effect. |
| 57 | @end menu |
| 58 | |
| 59 | @node Abbrev Tables |
| 60 | @section Abbrev Tables |
| 61 | |
| 62 | This section describes how to create and manipulate abbrev tables. |
| 63 | |
| 64 | @defun make-abbrev-table &optional props |
| 65 | This function creates and returns a new, empty abbrev table---an |
| 66 | obarray containing no symbols. It is a vector filled with zeros. |
| 67 | @var{props} is a property list that is applied to the new table |
| 68 | (@pxref{Abbrev Table Properties}). |
| 69 | @end defun |
| 70 | |
| 71 | @defun abbrev-table-p object |
| 72 | This function returns a non-@code{nil} value if @var{object} is an |
| 73 | abbrev table. |
| 74 | @end defun |
| 75 | |
| 76 | @defun clear-abbrev-table abbrev-table |
| 77 | This function undefines all the abbrevs in @var{abbrev-table}, leaving |
| 78 | it empty. |
| 79 | @c Don't see why this needs saying. |
| 80 | @c It always returns @code{nil}. |
| 81 | @end defun |
| 82 | |
| 83 | @defun copy-abbrev-table abbrev-table |
| 84 | This function returns a copy of @var{abbrev-table}---a new abbrev |
| 85 | table containing the same abbrev definitions. It does @emph{not} copy |
| 86 | any property lists; only the names, values, and functions. |
| 87 | @end defun |
| 88 | |
| 89 | @defun define-abbrev-table tabname definitions &optional docstring &rest props |
| 90 | This function defines @var{tabname} (a symbol) as an abbrev table |
| 91 | name, i.e., as a variable whose value is an abbrev table. It defines |
| 92 | abbrevs in the table according to @var{definitions}, a list of |
| 93 | elements of the form @code{(@var{abbrevname} @var{expansion} |
| 94 | [@var{hook}] [@var{props}...])}. These elements are passed as |
| 95 | arguments to @code{define-abbrev}. @c The return value is always @code{nil}. |
| 96 | |
| 97 | The optional string @var{docstring} is the documentation string of the |
| 98 | variable @var{tabname}. The property list @var{props} is applied to |
| 99 | the abbrev table (@pxref{Abbrev Table Properties}). |
| 100 | |
| 101 | If this function is called more than once for the same @var{tabname}, |
| 102 | subsequent calls add the definitions in @var{definitions} to |
| 103 | @var{tabname}, rather than overwriting the entire original contents. |
| 104 | (A subsequent call only overrides abbrevs explicitly redefined or |
| 105 | undefined in @var{definitions}.) |
| 106 | @end defun |
| 107 | |
| 108 | @defvar abbrev-table-name-list |
| 109 | This is a list of symbols whose values are abbrev tables. |
| 110 | @code{define-abbrev-table} adds the new abbrev table name to this list. |
| 111 | @end defvar |
| 112 | |
| 113 | @defun insert-abbrev-table-description name &optional human |
| 114 | This function inserts before point a description of the abbrev table |
| 115 | named @var{name}. The argument @var{name} is a symbol whose value is an |
| 116 | abbrev table. @c The return value is always @code{nil}. |
| 117 | |
| 118 | If @var{human} is non-@code{nil}, the description is human-oriented. |
| 119 | System abbrevs are listed and identified as such. Otherwise the |
| 120 | description is a Lisp expression---a call to @code{define-abbrev-table} |
| 121 | that would define @var{name} as it is currently defined, but without |
| 122 | the system abbrevs. (The mode or package using @var{name} is supposed |
| 123 | to add these to @var{name} separately.) |
| 124 | @end defun |
| 125 | |
| 126 | @node Defining Abbrevs |
| 127 | @section Defining Abbrevs |
| 128 | |
| 129 | @code{define-abbrev} is the low-level basic function for defining an |
| 130 | abbrev in an abbrev table. |
| 131 | |
| 132 | When a major mode defines a system abbrev, it should call |
| 133 | @code{define-abbrev} and specify @code{t} for the @code{:system} |
| 134 | property. Be aware that any saved non-``system'' abbrevs are restored |
| 135 | at startup, i.e. before some major modes are loaded. Therefore, major |
| 136 | modes should not assume that their abbrev tables are empty when they |
| 137 | are first loaded. |
| 138 | |
| 139 | @defun define-abbrev abbrev-table name expansion &optional hook &rest props |
| 140 | This function defines an abbrev named @var{name}, in |
| 141 | @var{abbrev-table}, to expand to @var{expansion} and call @var{hook}, |
| 142 | with properties @var{props} (@pxref{Abbrev Properties}). The return |
| 143 | value is @var{name}. The @code{:system} property in @var{props} is |
| 144 | treated specially here: if it has the value @code{force}, then it will |
| 145 | overwrite an existing definition even for a non-``system'' abbrev of |
| 146 | the same name. |
| 147 | |
| 148 | @var{name} should be a string. The argument @var{expansion} is |
| 149 | normally the desired expansion (a string), or @code{nil} to undefine |
| 150 | the abbrev. If it is anything but a string or @code{nil}, then the |
| 151 | abbreviation ``expands'' solely by running @var{hook}. |
| 152 | |
| 153 | The argument @var{hook} is a function or @code{nil}. If @var{hook} is |
| 154 | non-@code{nil}, then it is called with no arguments after the abbrev is |
| 155 | replaced with @var{expansion}; point is located at the end of |
| 156 | @var{expansion} when @var{hook} is called. |
| 157 | |
| 158 | @cindex @code{no-self-insert} property |
| 159 | If @var{hook} is a non-@code{nil} symbol whose @code{no-self-insert} |
| 160 | property is non-@code{nil}, @var{hook} can explicitly control whether |
| 161 | to insert the self-inserting input character that triggered the |
| 162 | expansion. If @var{hook} returns non-@code{nil} in this case, that |
| 163 | inhibits insertion of the character. By contrast, if @var{hook} |
| 164 | returns @code{nil}, @code{expand-abbrev} (or @code{abbrev-insert}) |
| 165 | also returns @code{nil}, as if expansion had not really occurred. |
| 166 | |
| 167 | Normally, @code{define-abbrev} sets the variable |
| 168 | @code{abbrevs-changed} to @code{t}, if it actually changes the abbrev. |
| 169 | This is so that some commands will offer to save the abbrevs. It |
| 170 | does not do this for a system abbrev, since those aren't saved anyway. |
| 171 | @end defun |
| 172 | |
| 173 | @defopt only-global-abbrevs |
| 174 | If this variable is non-@code{nil}, it means that the user plans to use |
| 175 | global abbrevs only. This tells the commands that define mode-specific |
| 176 | abbrevs to define global ones instead. This variable does not alter the |
| 177 | behavior of the functions in this section; it is examined by their |
| 178 | callers. |
| 179 | @end defopt |
| 180 | |
| 181 | @node Abbrev Files |
| 182 | @section Saving Abbrevs in Files |
| 183 | |
| 184 | A file of saved abbrev definitions is actually a file of Lisp code. |
| 185 | The abbrevs are saved in the form of a Lisp program to define the same |
| 186 | abbrev tables with the same contents. Therefore, you can load the file |
| 187 | with @code{load} (@pxref{How Programs Do Loading}). However, the |
| 188 | function @code{quietly-read-abbrev-file} is provided as a more |
| 189 | convenient interface. Emacs automatically calls this function at |
| 190 | startup. |
| 191 | |
| 192 | User-level facilities such as @code{save-some-buffers} can save |
| 193 | abbrevs in a file automatically, under the control of variables |
| 194 | described here. |
| 195 | |
| 196 | @defopt abbrev-file-name |
| 197 | This is the default file name for reading and saving abbrevs. |
| 198 | @end defopt |
| 199 | |
| 200 | @defun quietly-read-abbrev-file &optional filename |
| 201 | This function reads abbrev definitions from a file named @var{filename}, |
| 202 | previously written with @code{write-abbrev-file}. If @var{filename} is |
| 203 | omitted or @code{nil}, the file specified in @code{abbrev-file-name} is |
| 204 | used. |
| 205 | |
| 206 | As the name implies, this function does not display any messages. |
| 207 | @c It returns @code{nil}. |
| 208 | @end defun |
| 209 | |
| 210 | @defopt save-abbrevs |
| 211 | A non-@code{nil} value for @code{save-abbrevs} means that Emacs should |
| 212 | offer to save abbrevs (if any have changed) when files are saved. If |
| 213 | the value is @code{silently}, Emacs saves the abbrevs without asking |
| 214 | the user. @code{abbrev-file-name} specifies the file to save the |
| 215 | abbrevs in. |
| 216 | @end defopt |
| 217 | |
| 218 | @defvar abbrevs-changed |
| 219 | This variable is set non-@code{nil} by defining or altering any |
| 220 | abbrevs (except system abbrevs). This serves as a flag for various |
| 221 | Emacs commands to offer to save your abbrevs. |
| 222 | @end defvar |
| 223 | |
| 224 | @deffn Command write-abbrev-file &optional filename |
| 225 | Save all abbrev definitions (except system abbrevs), for all abbrev |
| 226 | tables listed in @code{abbrev-table-name-list}, in the file |
| 227 | @var{filename}, in the form of a Lisp program that when loaded will |
| 228 | define the same abbrevs. If @var{filename} is @code{nil} or omitted, |
| 229 | @code{abbrev-file-name} is used. This function returns @code{nil}. |
| 230 | @end deffn |
| 231 | |
| 232 | @node Abbrev Expansion |
| 233 | @section Looking Up and Expanding Abbreviations |
| 234 | |
| 235 | Abbrevs are usually expanded by certain interactive commands, |
| 236 | including @code{self-insert-command}. This section describes the |
| 237 | subroutines used in writing such commands, as well as the variables they |
| 238 | use for communication. |
| 239 | |
| 240 | @defun abbrev-symbol abbrev &optional table |
| 241 | This function returns the symbol representing the abbrev named |
| 242 | @var{abbrev}. It returns @code{nil} if that abbrev is not |
| 243 | defined. The optional second argument @var{table} is the abbrev table |
| 244 | in which to look it up. If @var{table} is @code{nil}, this function |
| 245 | tries first the current buffer's local abbrev table, and second the |
| 246 | global abbrev table. |
| 247 | @end defun |
| 248 | |
| 249 | @defun abbrev-expansion abbrev &optional table |
| 250 | This function returns the string that @var{abbrev} would expand into (as |
| 251 | defined by the abbrev tables used for the current buffer). It returns |
| 252 | @code{nil} if @var{abbrev} is not a valid abbrev. |
| 253 | The optional argument @var{table} specifies the abbrev table to use, |
| 254 | as in @code{abbrev-symbol}. |
| 255 | @end defun |
| 256 | |
| 257 | @deffn Command expand-abbrev |
| 258 | This command expands the abbrev before point, if any. If point does not |
| 259 | follow an abbrev, this command does nothing. The command returns the |
| 260 | abbrev symbol if it did expansion, @code{nil} otherwise. |
| 261 | |
| 262 | If the abbrev symbol has a hook function that is a symbol whose |
| 263 | @code{no-self-insert} property is non-@code{nil}, and if the hook |
| 264 | function returns @code{nil} as its value, then @code{expand-abbrev} |
| 265 | returns @code{nil} even though expansion did occur. |
| 266 | @end deffn |
| 267 | |
| 268 | @defun abbrev-insert abbrev &optional name start end |
| 269 | This function inserts the abbrev expansion of @code{abbrev}, replacing |
| 270 | the text between @code{start} and @code{end}. If @code{start} is |
| 271 | omitted, it defaults to point. @code{name}, if non-@code{nil}, should |
| 272 | be the name by which this abbrev was found (a string); it is used to |
| 273 | figure out whether to adjust the capitalization of the expansion. The |
| 274 | function returns @code{abbrev} if the abbrev was successfully |
| 275 | inserted. |
| 276 | @end defun |
| 277 | |
| 278 | @deffn Command abbrev-prefix-mark &optional arg |
| 279 | This command marks the current location of point as the beginning of |
| 280 | an abbrev. The next call to @code{expand-abbrev} will use the text |
| 281 | from here to point (where it is then) as the abbrev to expand, rather |
| 282 | than using the previous word as usual. |
| 283 | |
| 284 | First, this command expands any abbrev before point, unless @var{arg} |
| 285 | is non-@code{nil}. (Interactively, @var{arg} is the prefix argument.) |
| 286 | Then it inserts a hyphen before point, to indicate the start of the |
| 287 | next abbrev to be expanded. The actual expansion removes the hyphen. |
| 288 | @end deffn |
| 289 | |
| 290 | @defopt abbrev-all-caps |
| 291 | When this is set non-@code{nil}, an abbrev entered entirely in upper |
| 292 | case is expanded using all upper case. Otherwise, an abbrev entered |
| 293 | entirely in upper case is expanded by capitalizing each word of the |
| 294 | expansion. |
| 295 | @end defopt |
| 296 | |
| 297 | @defvar abbrev-start-location |
| 298 | The value of this variable is a buffer position (an integer or a marker) |
| 299 | for @code{expand-abbrev} to use as the start of the next abbrev to be |
| 300 | expanded. The value can also be @code{nil}, which means to use the |
| 301 | word before point instead. @code{abbrev-start-location} is set to |
| 302 | @code{nil} each time @code{expand-abbrev} is called. This variable is |
| 303 | also set by @code{abbrev-prefix-mark}. |
| 304 | @end defvar |
| 305 | |
| 306 | @defvar abbrev-start-location-buffer |
| 307 | The value of this variable is the buffer for which |
| 308 | @code{abbrev-start-location} has been set. Trying to expand an abbrev |
| 309 | in any other buffer clears @code{abbrev-start-location}. This variable |
| 310 | is set by @code{abbrev-prefix-mark}. |
| 311 | @end defvar |
| 312 | |
| 313 | @defvar last-abbrev |
| 314 | This is the @code{abbrev-symbol} of the most recent abbrev expanded. This |
| 315 | information is left by @code{expand-abbrev} for the sake of the |
| 316 | @code{unexpand-abbrev} command (@pxref{Expanding Abbrevs,, Expanding |
| 317 | Abbrevs, emacs, The GNU Emacs Manual}). |
| 318 | @end defvar |
| 319 | |
| 320 | @defvar last-abbrev-location |
| 321 | This is the location of the most recent abbrev expanded. This contains |
| 322 | information left by @code{expand-abbrev} for the sake of the |
| 323 | @code{unexpand-abbrev} command. |
| 324 | @end defvar |
| 325 | |
| 326 | @defvar last-abbrev-text |
| 327 | This is the exact expansion text of the most recent abbrev expanded, |
| 328 | after case conversion (if any). Its value is @code{nil} if the abbrev |
| 329 | has already been unexpanded. This contains information left by |
| 330 | @code{expand-abbrev} for the sake of the @code{unexpand-abbrev} command. |
| 331 | @end defvar |
| 332 | |
| 333 | @defvar abbrev-expand-functions |
| 334 | This is a wrapper hook (@pxref{Running Hooks}) run around the |
| 335 | @code{expand-abbrev} function. Each function on this hook is called |
| 336 | with a single argument: a function that performs the normal abbrev |
| 337 | expansion. The hook function can hence do anything it wants before |
| 338 | and after performing the expansion. It can also choose not to call |
| 339 | its argument, thus overriding the default behavior; or it may even |
| 340 | call it several times. The function should return the abbrev symbol |
| 341 | if expansion took place. |
| 342 | @end defvar |
| 343 | |
| 344 | The following sample code shows a simple use of |
| 345 | @code{abbrev-expand-functions}. It assumes that @code{foo-mode} is a |
| 346 | mode for editing certain files in which lines that start with @samp{#} |
| 347 | are comments. You want to use Text mode abbrevs for those lines. The |
| 348 | regular local abbrev table, @code{foo-mode-abbrev-table} is |
| 349 | appropriate for all other lines. @xref{Standard Abbrev Tables}, for the |
| 350 | definitions of @code{local-abbrev-table} and @code{text-mode-abbrev-table}. |
| 351 | |
| 352 | @smallexample |
| 353 | (defun foo-mode-abbrev-expand-function (expand) |
| 354 | (if (not (save-excursion (forward-line 0) (eq (char-after) ?#))) |
| 355 | ;; Performs normal expansion. |
| 356 | (funcall expand) |
| 357 | ;; We're inside a comment: use the text-mode abbrevs. |
| 358 | (let ((local-abbrev-table text-mode-abbrev-table)) |
| 359 | (funcall expand)))) |
| 360 | |
| 361 | (add-hook 'foo-mode-hook |
| 362 | #'(lambda () |
| 363 | (add-hook 'abbrev-expand-functions |
| 364 | 'foo-mode-abbrev-expand-function |
| 365 | nil t))) |
| 366 | @end smallexample |
| 367 | |
| 368 | @node Standard Abbrev Tables |
| 369 | @section Standard Abbrev Tables |
| 370 | |
| 371 | Here we list the variables that hold the abbrev tables for the |
| 372 | preloaded major modes of Emacs. |
| 373 | |
| 374 | @defvar global-abbrev-table |
| 375 | This is the abbrev table for mode-independent abbrevs. The abbrevs |
| 376 | defined in it apply to all buffers. Each buffer may also have a local |
| 377 | abbrev table, whose abbrev definitions take precedence over those in the |
| 378 | global table. |
| 379 | @end defvar |
| 380 | |
| 381 | @defvar local-abbrev-table |
| 382 | The value of this buffer-local variable is the (mode-specific) |
| 383 | abbreviation table of the current buffer. It can also be a list of |
| 384 | such tables. |
| 385 | @end defvar |
| 386 | |
| 387 | @defvar abbrev-minor-mode-table-alist |
| 388 | The value of this variable is a list of elements of the form |
| 389 | @code{(@var{mode} . @var{abbrev-table})} where @var{mode} is the name |
| 390 | of a variable: if the variable is bound to a non-@code{nil} value, |
| 391 | then the @var{abbrev-table} is active, otherwise it is ignored. |
| 392 | @var{abbrev-table} can also be a list of abbrev tables. |
| 393 | @end defvar |
| 394 | |
| 395 | @defvar fundamental-mode-abbrev-table |
| 396 | This is the local abbrev table used in Fundamental mode; in other words, |
| 397 | it is the local abbrev table in all buffers in Fundamental mode. |
| 398 | @end defvar |
| 399 | |
| 400 | @defvar text-mode-abbrev-table |
| 401 | This is the local abbrev table used in Text mode. |
| 402 | @end defvar |
| 403 | |
| 404 | @defvar lisp-mode-abbrev-table |
| 405 | This is the local abbrev table used in Lisp mode. It is the parent |
| 406 | of the local abbrev table used in Emacs Lisp mode. @xref{Abbrev Table |
| 407 | Properties}. |
| 408 | @end defvar |
| 409 | |
| 410 | @node Abbrev Properties |
| 411 | @section Abbrev Properties |
| 412 | |
| 413 | Abbrevs have properties, some of which influence the way they work. |
| 414 | You can provide them as arguments to @code{define-abbrev}, and |
| 415 | manipulate them with the following functions: |
| 416 | |
| 417 | @defun abbrev-put abbrev prop val |
| 418 | Set the property @var{prop} of @var{abbrev} to value @var{val}. |
| 419 | @end defun |
| 420 | |
| 421 | @defun abbrev-get abbrev prop |
| 422 | Return the property @var{prop} of @var{abbrev}, or @code{nil} if the |
| 423 | abbrev has no such property. |
| 424 | @end defun |
| 425 | |
| 426 | The following properties have special meanings: |
| 427 | |
| 428 | @table @code |
| 429 | @item :count |
| 430 | This property counts the number of times the abbrev has |
| 431 | been expanded. If not explicitly set, it is initialized to 0 by |
| 432 | @code{define-abbrev}. |
| 433 | |
| 434 | @item :system |
| 435 | If non-@code{nil}, this property marks the abbrev as a system abbrev. |
| 436 | Such abbrevs are not saved (@pxref{Abbrev Files}). |
| 437 | |
| 438 | @item :enable-function |
| 439 | If non-@code{nil}, this property should be a function of no |
| 440 | arguments which returns @code{nil} if the abbrev should not be used |
| 441 | and @code{t} otherwise. |
| 442 | |
| 443 | @item :case-fixed |
| 444 | If non-@code{nil}, this property indicates that the case of the |
| 445 | abbrev's name is significant and should only match a text with the |
| 446 | same pattern of capitalization. It also disables the code that |
| 447 | modifies the capitalization of the expansion. |
| 448 | @end table |
| 449 | |
| 450 | @node Abbrev Table Properties |
| 451 | @section Abbrev Table Properties |
| 452 | |
| 453 | Like abbrevs, abbrev tables have properties, some of which influence |
| 454 | the way they work. You can provide them as arguments to |
| 455 | @code{define-abbrev-table}, and manipulate them with the functions: |
| 456 | |
| 457 | @defun abbrev-table-put table prop val |
| 458 | Set the property @var{prop} of abbrev table @var{table} to value @var{val}. |
| 459 | @end defun |
| 460 | |
| 461 | @defun abbrev-table-get table prop |
| 462 | Return the property @var{prop} of abbrev table @var{table}, or @code{nil} |
| 463 | if the abbrev has no such property. |
| 464 | @end defun |
| 465 | |
| 466 | The following properties have special meaning: |
| 467 | |
| 468 | @table @code |
| 469 | @item :enable-function |
| 470 | This is like the @code{:enable-function} abbrev property except that |
| 471 | it applies to all abbrevs in the table. It is used before even trying |
| 472 | to find the abbrev before point, so it can dynamically modify the |
| 473 | abbrev table. |
| 474 | |
| 475 | @item :case-fixed |
| 476 | This is like the @code{:case-fixed} abbrev property except that it |
| 477 | applies to all abbrevs in the table. |
| 478 | |
| 479 | @item :regexp |
| 480 | If non-@code{nil}, this property is a regular expression that |
| 481 | indicates how to extract the name of the abbrev before point, before |
| 482 | looking it up in the table. When the regular expression matches |
| 483 | before point, the abbrev name is expected to be in submatch 1. |
| 484 | If this property is @code{nil}, the default is to use |
| 485 | @code{backward-word} and @code{forward-word} to find the name. This |
| 486 | property allows the use of abbrevs whose name contains characters of |
| 487 | non-word syntax. |
| 488 | |
| 489 | @item :parents |
| 490 | This property holds a list of tables from which to inherit |
| 491 | other abbrevs. |
| 492 | |
| 493 | @item :abbrev-table-modiff |
| 494 | This property holds a counter incremented each time a new abbrev is |
| 495 | added to the table. |
| 496 | |
| 497 | @end table |