symbols.texi 22.6 KB
Newer Older
Glenn Morris's avatar
Glenn Morris committed
1 2
@c -*-texinfo-*-
@c This is part of the GNU Emacs Lisp Reference Manual.
Paul Eggert's avatar
Paul Eggert committed
3
@c Copyright (C) 1990--1995, 1998--1999, 2001--2020 Free Software
4
@c Foundation, Inc.
Glenn Morris's avatar
Glenn Morris committed
5
@c See the file elisp.texi for copying conditions.
6
@node Symbols
Glenn Morris's avatar
Glenn Morris committed
7 8 9 10 11 12 13 14 15 16
@chapter Symbols
@cindex symbol

  A @dfn{symbol} is an object with a unique name.  This chapter
describes symbols, their components, their property lists, and how they
are created and interned.  Separate chapters describe the use of symbols
as variables and as function names; see @ref{Variables}, and
@ref{Functions}.  For the precise read syntax for symbols, see
@ref{Symbol Type}.

17 18
  You can test whether an arbitrary Lisp object is a symbol with
@code{symbolp}:
Glenn Morris's avatar
Glenn Morris committed
19 20 21 22 23 24 25 26 27 28 29

@defun symbolp object
This function returns @code{t} if @var{object} is a symbol, @code{nil}
otherwise.
@end defun

@menu
* Symbol Components::        Symbols have names, values, function definitions
                               and property lists.
* Definitions::              A definition says how a symbol will be used.
* Creating Symbols::         How symbols are kept unique.
30
* Symbol Properties::        Each symbol has a property list
Glenn Morris's avatar
Glenn Morris committed
31 32 33
                               for recording miscellaneous information.
@end menu

34
@node Symbol Components
Glenn Morris's avatar
Glenn Morris committed
35 36 37
@section Symbol Components
@cindex symbol components

38
  Each symbol has four components (or ``cells''), each of which
Glenn Morris's avatar
Glenn Morris committed
39 40 41 42 43
references another object:

@table @asis
@item Print name
@cindex print name cell
44
The symbol's name.
Glenn Morris's avatar
Glenn Morris committed
45 46 47

@item Value
@cindex value cell
48
The symbol's current value as a variable.
Glenn Morris's avatar
Glenn Morris committed
49 50 51

@item Function
@cindex function cell
52 53
The symbol's function definition.  It can also hold a symbol, a
keymap, or a keyboard macro.
Glenn Morris's avatar
Glenn Morris committed
54 55 56

@item Property list
@cindex property list cell
57
The symbol's property list.
Glenn Morris's avatar
Glenn Morris committed
58 59
@end table

60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91
@noindent
The print name cell always holds a string, and cannot be changed.
Each of the other three cells can be set to any Lisp object.

  The print name cell holds the string that is the name of a symbol.
Since symbols are represented textually by their names, it is
important not to have two symbols with the same name.  The Lisp reader
ensures this: every time it reads a symbol, it looks for an existing
symbol with the specified name before it creates a new one.  To get a
symbol's name, use the function @code{symbol-name} (@pxref{Creating
Symbols}).

  The value cell holds a symbol's value as a variable, which is what
you get if the symbol itself is evaluated as a Lisp expression.
@xref{Variables}, for details about how values are set and retrieved,
including complications such as @dfn{local bindings} and @dfn{scoping
rules}.  Most symbols can have any Lisp object as a value, but certain
special symbols have values that cannot be changed; these include
@code{nil} and @code{t}, and any symbol whose name starts with
@samp{:} (those are called @dfn{keywords}).  @xref{Constant
Variables}.

  The function cell holds a symbol's function definition.  Often, we
refer to ``the function @code{foo}'' when we really mean the function
stored in the function cell of @code{foo}; we make the distinction
explicit only when necessary.  Typically, the function cell is used to
hold a function (@pxref{Functions}) or a macro (@pxref{Macros}).
However, it can also be used to hold a symbol (@pxref{Function
Indirection}), keyboard macro (@pxref{Keyboard Macros}), keymap
(@pxref{Keymaps}), or autoload object (@pxref{Autoloading}).  To get
the contents of a symbol's function cell, use the function
@code{symbol-function} (@pxref{Function Cells}).
Glenn Morris's avatar
Glenn Morris committed
92 93

  The property list cell normally should hold a correctly formatted
94
property list.  To get a symbol's property list, use the function
95
@code{symbol-plist}.  @xref{Symbol Properties}.
Glenn Morris's avatar
Glenn Morris committed
96 97 98 99 100 101 102

  The function cell or the value cell may be @dfn{void}, which means
that the cell does not reference any object.  (This is not the same
thing as holding the symbol @code{void}, nor the same as holding the
symbol @code{nil}.)  Examining a function or value cell that is void
results in an error, such as @samp{Symbol's value as variable is void}.

103 104 105 106 107
  Because each symbol has separate value and function cells, variables
names and function names do not conflict.  For example, the symbol
@code{buffer-file-name} has a value (the name of the file being
visited in the current buffer) as well as a function definition (a
primitive function that returns the name of the file):
Glenn Morris's avatar
Glenn Morris committed
108 109

@example
110
buffer-file-name
Glenn Morris's avatar
Glenn Morris committed
111 112 113 114 115
     @result{} "/gnu/elisp/symbols.texi"
(symbol-function 'buffer-file-name)
     @result{} #<subr buffer-file-name>
@end example

116
@node Definitions
Glenn Morris's avatar
Glenn Morris committed
117 118 119
@section Defining Symbols
@cindex definitions of symbols

120 121 122 123 124 125
  A @dfn{definition} is a special kind of Lisp expression that
announces your intention to use a symbol in a particular way.  It
typically specifies a value or meaning for the symbol for one kind of
use, plus documentation for its meaning when used in this way.  Thus,
when you define a symbol as a variable, you can supply an initial
value for the variable, plus documentation for the variable.
Glenn Morris's avatar
Glenn Morris committed
126 127

  @code{defvar} and @code{defconst} are special forms that define a
128 129 130 131 132 133 134
symbol as a @dfn{global variable}---a variable that can be accessed at
any point in a Lisp program.  @xref{Variables}, for details about
variables.  To define a customizable variable, use the
@code{defcustom} macro, which also calls @code{defvar} as a subroutine
(@pxref{Customization}).

  In principle, you can assign a variable value to any symbol with
135
@code{setq}, whether or not it has first been defined as a variable.
136 137 138 139
However, you ought to write a variable definition for each global
variable that you want to use; otherwise, your Lisp program may not
act correctly if it is evaluated with lexical scoping enabled
(@pxref{Variable Scoping}).
Glenn Morris's avatar
Glenn Morris committed
140 141 142 143

  @code{defun} defines a symbol as a function, creating a lambda
expression and storing it in the function cell of the symbol.  This
lambda expression thus becomes the function definition of the symbol.
144
(The term ``function definition'', meaning the contents of the function
Glenn Morris's avatar
Glenn Morris committed
145 146 147 148 149 150 151 152 153 154 155
cell, is derived from the idea that @code{defun} gives the symbol its
definition as a function.)  @code{defsubst} and @code{defalias} are two
other ways of defining a function.  @xref{Functions}.

  @code{defmacro} defines a symbol as a macro.  It creates a macro
object and stores it in the function cell of the symbol.  Note that a
given symbol can be a macro or a function, but not both at once, because
both macro and function definitions are kept in the function cell, and
that cell can hold only one Lisp object at any given time.
@xref{Macros}.

156
  As previously noted, Emacs Lisp allows the same symbol to be defined
157 158
both as a variable (e.g., with @code{defvar}) and as a function or
macro (e.g., with @code{defun}).  Such definitions do not conflict.
159

Bogdan Creanga's avatar
Bogdan Creanga committed
160
  These definitions also act as guides for programming tools.  For
161 162 163
example, the @kbd{C-h f} and @kbd{C-h v} commands create help buffers
containing links to the relevant variable, function, or macro
definitions.  @xref{Name Help,,, emacs, The GNU Emacs Manual}.
Glenn Morris's avatar
Glenn Morris committed
164

165
@node Creating Symbols
Glenn Morris's avatar
Glenn Morris committed
166 167 168 169 170 171 172 173 174 175 176 177 178
@section Creating and Interning Symbols
@cindex reading symbols

  To understand how symbols are created in GNU Emacs Lisp, you must know
how Lisp reads them.  Lisp must ensure that it finds the same symbol
every time it reads the same set of characters.  Failure to do so would
cause complete confusion.

@cindex symbol name hashing
@cindex hashing
@cindex obarray
@cindex bucket (in obarray)
  When the Lisp reader encounters a symbol, it reads all the characters
Paul Eggert's avatar
Paul Eggert committed
179
of the name.  Then it hashes those characters to find an index in a
Glenn Morris's avatar
Glenn Morris committed
180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237
table called an @dfn{obarray}.  Hashing is an efficient method of
looking something up.  For example, instead of searching a telephone
book cover to cover when looking up Jan Jones, you start with the J's
and go from there.  That is a simple version of hashing.  Each element
of the obarray is a @dfn{bucket} which holds all the symbols with a
given hash code; to look for a given name, it is sufficient to look
through all the symbols in the bucket for that name's hash code.  (The
same idea is used for general Emacs hash tables, but they are a
different data type; see @ref{Hash Tables}.)

@cindex interning
  If a symbol with the desired name is found, the reader uses that
symbol.  If the obarray does not contain a symbol with that name, the
reader makes a new symbol and adds it to the obarray.  Finding or adding
a symbol with a certain name is called @dfn{interning} it, and the
symbol is then called an @dfn{interned symbol}.

  Interning ensures that each obarray has just one symbol with any
particular name.  Other like-named symbols may exist, but not in the
same obarray.  Thus, the reader gets the same symbols for the same
names, as long as you keep reading with the same obarray.

  Interning usually happens automatically in the reader, but sometimes
other programs need to do it.  For example, after the @kbd{M-x} command
obtains the command name as a string using the minibuffer, it then
interns the string, to get the interned symbol with that name.

@cindex symbol equality
@cindex uninterned symbol
  No obarray contains all symbols; in fact, some symbols are not in any
obarray.  They are called @dfn{uninterned symbols}.  An uninterned
symbol has the same four cells as other symbols; however, the only way
to gain access to it is by finding it in some other object or as the
value of a variable.

  Creating an uninterned symbol is useful in generating Lisp code,
because an uninterned symbol used as a variable in the code you generate
cannot clash with any variables used in other Lisp programs.

  In Emacs Lisp, an obarray is actually a vector.  Each element of the
vector is a bucket; its value is either an interned symbol whose name
hashes to that bucket, or 0 if the bucket is empty.  Each interned
symbol has an internal link (invisible to the user) to the next symbol
in the bucket.  Because these links are invisible, there is no way to
find all the symbols in an obarray except using @code{mapatoms} (below).
The order of symbols in a bucket is not significant.

  In an empty obarray, every element is 0, so you can create an obarray
with @code{(make-vector @var{length} 0)}.  @strong{This is the only
valid way to create an obarray.}  Prime numbers as lengths tend
to result in good hashing; lengths one less than a power of two are also
good.

  @strong{Do not try to put symbols in an obarray yourself.}  This does
not work---only @code{intern} can enter a symbol in an obarray properly.

@cindex CL note---symbol in obarrays
@quotation
238 239
@b{Common Lisp note:} Unlike Common Lisp, Emacs Lisp does not provide
for interning a single symbol in several obarrays.
Glenn Morris's avatar
Glenn Morris committed
240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275
@end quotation

  Most of the functions below take a name and sometimes an obarray as
arguments.  A @code{wrong-type-argument} error is signaled if the name
is not a string, or if the obarray is not a vector.

@defun symbol-name symbol
This function returns the string that is @var{symbol}'s name.  For example:

@example
@group
(symbol-name 'foo)
     @result{} "foo"
@end group
@end example

@strong{Warning:} Changing the string by substituting characters does
change the name of the symbol, but fails to update the obarray, so don't
do it!
@end defun

@defun make-symbol name
This function returns a newly-allocated, uninterned symbol whose name is
@var{name} (which must be a string).  Its value and function definition
are void, and its property list is @code{nil}.  In the example below,
the value of @code{sym} is not @code{eq} to @code{foo} because it is a
distinct uninterned symbol whose name is also @samp{foo}.

@example
(setq sym (make-symbol "foo"))
     @result{} foo
(eq sym 'foo)
     @result{} nil
@end example
@end defun

Mark Oteiza's avatar
Mark Oteiza committed
276 277 278
@defun gensym &optional prefix
This function returns a symbol using @code{make-symbol}, whose name is
made by appending @code{gensym-counter} to @var{prefix}.  The prefix
279
defaults to @code{"g"}.
Mark Oteiza's avatar
Mark Oteiza committed
280 281
@end defun

Glenn Morris's avatar
Glenn Morris committed
282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319
@defun intern name &optional obarray
This function returns the interned symbol whose name is @var{name}.  If
there is no such symbol in the obarray @var{obarray}, @code{intern}
creates a new one, adds it to the obarray, and returns it.  If
@var{obarray} is omitted, the value of the global variable
@code{obarray} is used.

@example
(setq sym (intern "foo"))
     @result{} foo
(eq sym 'foo)
     @result{} t

(setq sym1 (intern "foo" other-obarray))
     @result{} foo
(eq sym1 'foo)
     @result{} nil
@end example
@end defun

@cindex CL note---interning existing symbol
@quotation
@b{Common Lisp note:} In Common Lisp, you can intern an existing symbol
in an obarray.  In Emacs Lisp, you cannot do this, because the argument
to @code{intern} must be a string, not a symbol.
@end quotation

@defun intern-soft name &optional obarray
This function returns the symbol in @var{obarray} whose name is
@var{name}, or @code{nil} if @var{obarray} has no symbol with that name.
Therefore, you can use @code{intern-soft} to test whether a symbol with
a given name is already interned.  If @var{obarray} is omitted, the
value of the global variable @code{obarray} is used.

The argument @var{name} may also be a symbol; in that case,
the function returns @var{name} if @var{name} is interned
in the specified obarray, and otherwise @code{nil}.

320
@example
Glenn Morris's avatar
Glenn Morris committed
321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340
(intern-soft "frazzle")        ; @r{No such symbol exists.}
     @result{} nil
(make-symbol "frazzle")        ; @r{Create an uninterned one.}
     @result{} frazzle
@group
(intern-soft "frazzle")        ; @r{That one cannot be found.}
     @result{} nil
@end group
@group
(setq sym (intern "frazzle"))  ; @r{Create an interned one.}
     @result{} frazzle
@end group
@group
(intern-soft "frazzle")        ; @r{That one can be found!}
     @result{} frazzle
@end group
@group
(eq sym 'frazzle)              ; @r{And it is the same one.}
     @result{} t
@end group
341
@end example
Glenn Morris's avatar
Glenn Morris committed
342 343 344 345 346 347 348 349 350 351 352 353 354 355
@end defun

@defvar obarray
This variable is the standard obarray for use by @code{intern} and
@code{read}.
@end defvar

@defun mapatoms function &optional obarray
@anchor{Definition of mapatoms}
This function calls @var{function} once with each symbol in the obarray
@var{obarray}.  Then it returns @code{nil}.  If @var{obarray} is
omitted, it defaults to the value of @code{obarray}, the standard
obarray for ordinary symbols.

356
@example
Glenn Morris's avatar
Glenn Morris committed
357 358 359 360 361 362 363 364 365
(setq count 0)
     @result{} 0
(defun count-syms (s)
  (setq count (1+ count)))
     @result{} count-syms
(mapatoms 'count-syms)
     @result{} nil
count
     @result{} 1871
366
@end example
Glenn Morris's avatar
Glenn Morris committed
367 368 369 370 371

See @code{documentation} in @ref{Accessing Documentation}, for another
example using @code{mapatoms}.
@end defun

372
@defun unintern symbol obarray
Glenn Morris's avatar
Glenn Morris committed
373 374 375 376 377 378 379 380 381 382 383 384 385
This function deletes @var{symbol} from the obarray @var{obarray}.  If
@code{symbol} is not actually in the obarray, @code{unintern} does
nothing.  If @var{obarray} is @code{nil}, the current obarray is used.

If you provide a string instead of a symbol as @var{symbol}, it stands
for a symbol name.  Then @code{unintern} deletes the symbol (if any) in
the obarray which has that name.  If there is no such symbol,
@code{unintern} does nothing.

If @code{unintern} does delete a symbol, it returns @code{t}.  Otherwise
it returns @code{nil}.
@end defun

386 387 388
@node Symbol Properties
@section Symbol Properties
@cindex symbol property
Glenn Morris's avatar
Glenn Morris committed
389

390 391 392 393 394
  A symbol may possess any number of @dfn{symbol properties}, which
can be used to record miscellaneous information about the symbol.  For
example, when a symbol has a @code{risky-local-variable} property with
a non-@code{nil} value, that means the variable which the symbol names
is a risky file-local variable (@pxref{File Local Variables}).
Glenn Morris's avatar
Glenn Morris committed
395

396 397 398
  Each symbol's properties and property values are stored in the
symbol's property list cell (@pxref{Symbol Components}), in the form
of a property list (@pxref{Property Lists}).
Glenn Morris's avatar
Glenn Morris committed
399 400

@menu
401 402
* Symbol Plists::        Accessing symbol properties.
* Standard Properties::  Standard meanings of symbol properties.
Glenn Morris's avatar
Glenn Morris committed
403 404 405
@end menu

@node Symbol Plists
406
@subsection Accessing Symbol Properties
Glenn Morris's avatar
Glenn Morris committed
407

408
  The following functions can be used to access symbol properties.
Glenn Morris's avatar
Glenn Morris committed
409 410

@defun get symbol property
411 412 413
This function returns the value of the property named @var{property}
in @var{symbol}'s property list.  If there is no such property, it
returns @code{nil}.  Thus, there is no distinction between a value of
Glenn Morris's avatar
Glenn Morris committed
414 415 416 417 418 419 420 421 422 423 424 425 426
@code{nil} and the absence of the property.

The name @var{property} is compared with the existing property names
using @code{eq}, so any object is a legitimate property.

See @code{put} for an example.
@end defun

@defun put symbol property value
This function puts @var{value} onto @var{symbol}'s property list under
the property name @var{property}, replacing any previous property value.
The @code{put} function returns @var{value}.

427
@example
Glenn Morris's avatar
Glenn Morris committed
428 429 430 431 432 433 434 435
(put 'fly 'verb 'transitive)
     @result{}'transitive
(put 'fly 'noun '(a buzzing little bug))
     @result{} (a buzzing little bug)
(get 'fly 'verb)
     @result{} transitive
(symbol-plist 'fly)
     @result{} (verb transitive noun (a buzzing little bug))
436
@end example
Glenn Morris's avatar
Glenn Morris committed
437 438
@end defun

439 440
@defun symbol-plist symbol
This function returns the property list of @var{symbol}.
Glenn Morris's avatar
Glenn Morris committed
441 442
@end defun

443 444 445 446
@defun setplist symbol plist
This function sets @var{symbol}'s property list to @var{plist}.
Normally, @var{plist} should be a well-formed property list, but this is
not enforced.  The return value is @var{plist}.
Glenn Morris's avatar
Glenn Morris committed
447 448

@example
449 450 451 452
(setplist 'foo '(a 1 b (2 3) c nil))
     @result{} (a 1 b (2 3) c nil)
(symbol-plist 'foo)
     @result{} (a 1 b (2 3) c nil)
Glenn Morris's avatar
Glenn Morris committed
453 454
@end example

455 456 457 458
For symbols in special obarrays, which are not used for ordinary
purposes, it may make sense to use the property list cell in a
nonstandard fashion; in fact, the abbrev mechanism does so
(@pxref{Abbrevs}).
Chong Yidong's avatar
Chong Yidong committed
459 460 461 462 463 464 465 466 467

You could define @code{put} in terms of @code{setplist} and
@code{plist-put}, as follows:

@example
(defun put (symbol prop value)
  (setplist symbol
            (plist-put (symbol-plist symbol) prop value)))
@end example
Glenn Morris's avatar
Glenn Morris committed
468 469
@end defun

Eli Zaretskii's avatar
Eli Zaretskii committed
470
@defun function-get symbol property &optional autoload
471 472
This function is identical to @code{get}, except that if @var{symbol}
is the name of a function alias, it looks in the property list of the
Eli Zaretskii's avatar
Eli Zaretskii committed
473 474 475 476 477 478 479 480 481 482 483 484 485 486
symbol naming the actual function.  @xref{Defining Functions}.  If the
optional argument @var{autoload} is non-@code{nil}, and @var{symbol}
is auto-loaded, this function will try to autoload it, since
autoloading might set @var{property} of @var{symbol}.  If
@var{autoload} is the symbol @code{macro}, only try autoloading if
@var{symbol} is an auto-loaded macro.
@end defun

@defun function-put function property value
This function sets @var{property} of @var{function} to @var{value}.
@var{function} should be a symbol.  This function is preferred to
calling @code{put} for setting properties of a function, because it
will allow us some day to implement remapping of old properties to new
ones.
Glenn Morris's avatar
Glenn Morris committed
487 488
@end defun

489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505
@node Standard Properties
@subsection Standard Symbol Properties

  Here, we list the symbol properties which are used for special
purposes in Emacs.  In the following table, whenever we say ``the
named function'', that means the function whose name is the relevant
symbol; similarly for ``the named variable'' etc.

@table @code
@item :advertised-binding
This property value specifies the preferred key binding, when showing
documentation, for the named function.  @xref{Keys in Documentation}.

@item char-table-extra-slots
The value, if non-@code{nil}, specifies the number of extra slots in
the named char-table type.  @xref{Char-Tables}.

Chong Yidong's avatar
Chong Yidong committed
506 507
@item customized-face
@itemx face-defface-spec
508 509 510 511 512 513 514
@itemx saved-face
@itemx theme-face
These properties are used to record a face's standard, saved,
customized, and themed face specs.  Do not set them directly; they are
managed by @code{defface} and related functions.  @xref{Defining
Faces}.

Chong Yidong's avatar
Chong Yidong committed
515
@item customized-value
516
@itemx saved-value
Chong Yidong's avatar
Chong Yidong committed
517
@itemx standard-value
518 519 520 521 522 523 524 525 526 527 528 529
@itemx theme-value
These properties are used to record a customizable variable's standard
value, saved value, customized-but-unsaved value, and themed values.
Do not set them directly; they are managed by @code{defcustom} and
related functions.  @xref{Variable Definitions}.

@item disabled
If the value is non-@code{nil}, the named function is disabled as a
command.  @xref{Disabling Commands}.

@item face-documentation
The value stores the documentation string of the named face.  This is
Chong Yidong's avatar
Chong Yidong committed
530
set automatically by @code{defface}.  @xref{Defining Faces}.
531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546

@item history-length
The value, if non-@code{nil}, specifies the maximum minibuffer history
length for the named history list variable.  @xref{Minibuffer
History}.

@item interactive-form
The value is an interactive form for the named function.  Normally,
you should not set this directly; use the @code{interactive} special
form instead.  @xref{Interactive Call}.

@item menu-enable
The value is an expression for determining whether the named menu item
should be enabled in menus.  @xref{Simple Menu Items}.

@item mode-class
Paul Eggert's avatar
Paul Eggert committed
547
If the value is @code{special}, the named major mode is special.
548 549 550 551 552 553 554 555 556 557 558 559 560
@xref{Major Mode Conventions}.

@item permanent-local
If the value is non-@code{nil}, the named variable is a buffer-local
variable whose value should not be reset when changing major modes.
@xref{Creating Buffer-Local}.

@item permanent-local-hook
If the value is non-@code{nil}, the named function should not be
deleted from the local value of a hook variable when changing major
modes.  @xref{Setting Hooks}.

@item pure
561
@cindex @code{pure} property
562
If the value is non-@code{nil}, the named function is considered to be
563 564 565 566
pure (@pxref{What Is a Function}).  Calls with constant arguments can
be evaluated at compile time.  This may shift run time errors to
compile time.  Not to be confused with pure storage (@pxref{Pure
Storage}).
567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584

@item risky-local-variable
If the value is non-@code{nil}, the named variable is considered risky
as a file-local variable.  @xref{File Local Variables}.

@item safe-function
If the value is non-@code{nil}, the named function is considered
generally safe for evaluation.  @xref{Function Safety}.

@item safe-local-eval-function
If the value is non-@code{nil}, the named function is safe to call in
file-local evaluation forms.  @xref{File Local Variables}.

@item safe-local-variable
The value specifies a function for determining safe file-local values
for the named variable.  @xref{File Local Variables}.

@item side-effect-free
585
@cindex @code{side-effect-free} property
586
A non-@code{nil} value indicates that the named function is free of
587 588 589 590 591
side effects (@pxref{What Is a Function}), so the byte compiler may
ignore a call whose value is unused.  If the property's value is
@code{error-free}, the byte compiler may even delete such unused
calls.  In addition to byte compiler optimizations, this property is
also used for determining function safety (@pxref{Function Safety}).
592

593 594 595 596 597
@item undo-inhibit-region
If non-@code{nil}, the named function prevents the @code{undo} operation
from being restricted to the active region, if @code{undo} is invoked
immediately after the function.  @xref{Undo}.

598
@item variable-documentation
Paul Eggert's avatar
Paul Eggert committed
599
If non-@code{nil}, this specifies the named variable's documentation
Chong Yidong's avatar
Chong Yidong committed
600 601
string.  This is set automatically by @code{defvar} and related
functions.  @xref{Defining Faces}.
602
@end table