@c -*-texinfo-*-
@c This is part of the GNU Emacs Lisp Reference Manual.
-@c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998 Free Software Foundation, Inc.
+@c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000, 2002,
+@c 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
@c See the file elisp.texi for copying conditions.
@setfilename ../info/variables
@node Variables, Functions, Control Structures, Top
* Local Variables:: Variable values that exist only temporarily.
* Void Variables:: Symbols that lack values.
* Defining Variables:: A definition says a symbol is used as a variable.
-* Tips for Defining:: How to avoid bad results from quitting
- within the code to initialize a variable.
+* Tips for Defining:: Things you should think about when you
+ define a variable.
* Accessing Variables:: Examining values of variables whose names
are known only at run time.
* Setting Variables:: Storing new values in variables.
* Buffer-Local Variables:: Variable values in effect only in one buffer.
* Frame-Local Variables:: Variable values in effect only in one frame.
* Future Local Variables:: New kinds of local values we might add some day.
+* File Local Variables:: Handling local variable lists in files.
+* Variable Aliases:: Variables that are aliases for other variables.
+* Variables with Restricted Values:: Non-constant variables whose value can
+ @emph{not} be an arbitrary Lisp object.
@end menu
@node Global Variables
@end example
@node Constant Variables
-@section Variables That Never Change
+@section Variables that Never Change
@vindex nil
@vindex t
@kindex setting-constant
+@cindex keyword symbol
In Emacs Lisp, certain symbols normally evaluate to themselves. These
include @code{nil} and @code{t}, as well as any symbol whose name starts
-with @samp{:}. These symbols cannot be rebound, nor can their values be
-changed. Any attempt to set or bind @code{nil} or @code{t} signals a
-@code{setting-constant} error. The same is true for a symbol whose name
-starts with @samp{:}, except that you are allowed to set such a symbol to
-itself.
+with @samp{:} (these are called @dfn{keywords}). These symbols cannot
+be rebound, nor can their values be changed. Any attempt to set or bind
+@code{nil} or @code{t} signals a @code{setting-constant} error. The
+same is true for a keyword (a symbol whose name starts with @samp{:}),
+if it is interned in the standard obarray, except that setting such a
+symbol to itself is not an error.
@example
@group
@end group
@end example
-@defvar keyword-symbols-constant-flag
-@tindex keyword-symbols-constant-flag
-If this variable is @code{nil}, you are allowed to set and bind symbols
-whose names start with @samp{:} as you wish. This is to make it
-possible to run old Lisp programs which do that.
-@end defvar
+@defun keywordp object
+@tindex keywordp
+function returns @code{t} if @var{object} is a symbol whose name
+starts with @samp{:}, interned in the standard obarray, and returns
+@code{nil} otherwise.
+@end defun
@node Local Variables
@section Local Variables
All of the @var{value-form}s in @var{bindings} are evaluated in the
order they appear and @emph{before} binding any of the symbols to them.
-Here is an example of this: @code{Z} is bound to the old value of
-@code{Y}, which is 2, not the new value of @code{Y}, which is 1.
+Here is an example of this: @code{z} is bound to the old value of
+@code{y}, which is 2, not the new value of @code{y}, which is 1.
@example
@group
-(setq Y 2)
+(setq y 2)
@result{} 2
@end group
@group
-(let ((Y 1)
- (Z Y))
- (list Y Z))
+(let ((y 1)
+ (z y))
+ (list y z))
@result{} (1 2)
@end group
@end example
@example
@group
-(setq Y 2)
+(setq y 2)
@result{} 2
@end group
@group
-(let* ((Y 1)
- (Z Y)) ; @r{Use the just-established value of @code{Y}.}
- (list Y Z))
+(let* ((y 1)
+ (z y)) ; @r{Use the just-established value of @code{y}.}
+ (list y z))
@result{} (1 1)
@end group
@end example
localized in time.
@defvar max-specpdl-size
+@anchor{Definition of max-specpdl-size}
@cindex variable limit error
@cindex evaluation error
@cindex infinite recursion
This variable defines the limit on the total number of local variable
-bindings and @code{unwind-protect} cleanups (@pxref{Nonlocal Exits})
-that are allowed before signaling an error (with data @code{"Variable
-binding depth exceeds max-specpdl-size"}).
+bindings and @code{unwind-protect} cleanups (@pxref{Cleanups,,
+Cleaning Up from Nonlocal Exits}) that are allowed before signaling an
+error (with data @code{"Variable binding depth exceeds
+max-specpdl-size"}).
This limit, with the associated error when it is exceeded, is one way
that Lisp avoids infinite recursion on an ill-defined function.
@code{max-lisp-eval-depth} provides another limit on depth of nesting.
-@xref{Eval}.
+@xref{Definition of max-lisp-eval-depth,, Eval}.
The default value is 600. Entry to the Lisp debugger increases the
value, if there is little room left, to make sure the debugger itself
stored in the symbol's @code{variable-documentation} property. The
Emacs help functions (@pxref{Documentation}) look for this property.
-If the first character of @var{doc-string} is @samp{*}, it means that
-this variable is considered a user option. This lets users set the
-variable conveniently using the commands @code{set-variable} and
-@code{edit-options}. However, it is better to use @code{defcustom}
-instead of @code{defvar} for user option variables, so you can specify
-customization information. @xref{Customization}.
+If the variable is a user option that users would want to set
+interactively, you should use @samp{*} as the first character of
+@var{doc-string}. This lets users set the variable conveniently using
+the @code{set-variable} command. Note that you should nearly always
+use @code{defcustom} instead of @code{defvar} to define these
+variables, so that users can use @kbd{M-x customize} and related
+commands to set them. @xref{Customization}.
Here are some examples. This form defines @code{foo} but does not
initialize it:
at top level in a file where its value does not matter.
@end defspec
-@defspec defconst symbol [value [doc-string]]
+@defspec defconst symbol value [doc-string]
This special form defines @var{symbol} as a value and initializes it.
It informs a person reading your code that @var{symbol} has a standard
global value, established here, that should not be changed by the user
symbol to be defined must appear explicitly in the @code{defconst}.
@code{defconst} always evaluates @var{value}, and sets the value of
-@var{symbol} to the result if @var{value} is given. If @var{symbol}
-does have a buffer-local binding in the current buffer, @code{defconst}
-sets the default value, not the buffer-local value. (But you should not
-be making buffer-local bindings for a symbol that is defined with
+@var{symbol} to the result. If @var{symbol} does have a buffer-local
+binding in the current buffer, @code{defconst} sets the default value,
+not the buffer-local value. (But you should not be making
+buffer-local bindings for a symbol that is defined with
@code{defconst}.)
Here, @code{pi} is a constant that presumably ought not to be changed
@code{nil} otherwise. (Variables other than user options exist for the
internal purposes of Lisp programs, and users need not know about them.)
-User option variables are distinguished from other variables by the
-first character of the @code{variable-documentation} property. If the
-property exists and is a string, and its first character is @samp{*},
-then the variable is a user option.
+User option variables are distinguished from other variables either
+though being declared using @code{defcustom}@footnote{They may also be
+declared equivalently in @file{cus-start.el}.} or by the first character
+of their @code{variable-documentation} property. If the property exists
+and is a string, and its first character is @samp{*}, then the variable
+is a user option. Aliases of user options are also user options.
@end defun
@kindex variable-interactive
If a user option variable has a @code{variable-interactive} property,
the @code{set-variable} command uses that value to control reading the
new value for the variable. The property's value is used as if it were
-to @code{interactive} (@pxref{Using Interactive}). However, this feature
-is largely obsoleted by @code{defcustom} (@pxref{Customization}).
+specified in @code{interactive} (@pxref{Using Interactive}). However,
+this feature is largely obsoleted by @code{defcustom}
+(@pxref{Customization}).
@strong{Warning:} If the @code{defconst} and @code{defvar} special
-forms are used while the variable has a local binding, they set the
-local binding's value; the global binding is not changed. This is not
-what we really want. To prevent it, use these special forms at top
-level in a file, where normally no local binding is in effect, and make
-sure to load the file before making a local binding for the variable.
+forms are used while the variable has a local binding (made with
+@code{let}, or a function argument), they set the local-binding's
+value; the top-level binding is not changed. This is not what you
+usually want. To prevent it, use these special forms at top level in
+a file, where normally no local binding is in effect, and make sure to
+load the file before making a local binding for the variable.
@node Tips for Defining
@section Tips for Defining Variables Robustly
+ When you define a variable whose value is a function, or a list of
+functions, use a name that ends in @samp{-function} or
+@samp{-functions}, respectively.
+
+ There are several other variable name conventions;
+here is a complete list:
+
+@table @samp
+@item @dots{}-hook
+The variable is a normal hook (@pxref{Hooks}).
+
+@item @dots{}-function
+The value is a function.
+
+@item @dots{}-functions
+The value is a list of functions.
+
+@item @dots{}-form
+The value is a form (an expression).
+
+@item @dots{}-forms
+The value is a list of forms (expressions).
+
+@item @dots{}-predicate
+The value is a predicate---a function of one argument that returns
+non-@code{nil} for ``good'' arguments and @code{nil} for ``bad''
+arguments.
+
+@item @dots{}-flag
+The value is significant only as to whether it is @code{nil} or not.
+
+@item @dots{}-program
+The value is a program name.
+
+@item @dots{}-command
+The value is a whole shell command.
+
+@item @samp{}-switches
+The value specifies options for a command.
+@end table
+
+ When you define a variable, always consider whether you should mark
+it as ``risky''; see @ref{File Local Variables}.
+
When defining and initializing a variable that holds a complicated
value (such as a keymap with bindings in it), it's best to put the
entire computation of the value into the @code{defvar}, like this:
@example
(defvar my-mode-map nil
@var{docstring})
-(if my-mode-map
- nil
+(unless my-mode-map
(let ((map (make-sparse-keymap)))
- (define-key my-mode-map "\C-c\C-a" 'my-command)
+ (define-key map "\C-c\C-a" 'my-command)
@dots{}
(setq my-mode-map map)))
@end example
@example
(defvar my-mode-map nil
@var{docstring})
-(if my-mode-map
- nil
+(unless my-mode-map
(setq my-mode-map (make-sparse-keymap))
(define-key my-mode-map "\C-c\C-a" 'my-command)
@dots{})
x ; @r{@code{x} now has a global value.}
@result{} 3
@group
-(let ((x 5))
+(let ((x 5))
(setq x 6) ; @r{The local binding of @code{x} is set.}
x)
@result{} 6
@group
(setq x 10 ; @r{Notice that @code{x} is set before}
y (1+ x)) ; @r{the value of @code{y} is computed.}
- @result{} 11
+ @result{} 11
@end group
@end example
@end defspec
One other function for setting a variable is designed to add
an element to a list if it is not already present in the list.
-@defun add-to-list symbol element
+@defun add-to-list symbol element &optional append
This function sets the variable @var{symbol} by consing @var{element}
onto the old value, if @var{element} is not already a member of that
value. It returns the resulting list, whether updated or not. The
value of @var{symbol} had better be a list already before the call.
+Membership is tested using @code{equal}.
+
+Normally, if @var{element} is added, it is added to the front of
+@var{symbol}, but if the optional argument @var{append} is
+non-@code{nil}, it is added at the end.
The argument @var{symbol} is not implicitly quoted; @code{add-to-list}
is an ordinary function, like @code{set} and unlike @code{setq}. Quote
(setq @var{var} (cons @var{value} @var{var})))
@end example
+@defun add-to-ordered-list symbol element &optional order
+This function sets the variable @var{symbol} by inserting
+@var{element} into the old value, which must be a list, at the
+position specified by @var{order}. If @var{element} is already a
+member of the list, its position in the list is adjusted according
+to @var{order}. Membership is tested using @code{eq}.
+This function returns the resulting list, whether updated or not.
+
+The @var{order} is typically a number (integer or float), and the
+elements of the list are sorted in non-decreasing numerical order.
+
+@var{order} may also be omitted or @code{nil}. Then the numeric order
+of @var{element} stays unchanged if it already has one; otherwise,
+@var{element} has no numeric order. Elements without a numeric list
+order are placed at the end of the list, in no particular order.
+
+Any other value for @var{order} removes the numeric order of @var{element}
+if it already has one; otherwise, it is equivalent to @code{nil}.
+
+The argument @var{symbol} is not implicitly quoted;
+@code{add-to-ordered-list} is an ordinary function, like @code{set}
+and unlike @code{setq}. Quote the argument yourself if that is what
+you want.
+
+The ordering information is stored in a hash table on @var{symbol}'s
+@code{list-order} property.
+@end defun
+
+Here's a scenario showing how to use @code{add-to-ordered-list}:
+
+@example
+(setq foo '())
+ @result{} nil
+
+(add-to-ordered-list 'foo 'a 1) ;; @r{Add @code{a}.}
+ @result{} (a)
+
+(add-to-ordered-list 'foo 'c 3) ;; @r{Add @code{c}.}
+ @result{} (a c)
+
+(add-to-ordered-list 'foo 'b 2) ;; @r{Add @code{b}.}
+ @result{} (a b c)
+
+(add-to-ordered-list 'foo 'b 4) ;; @r{Move @code{b}.}
+ @result{} (a c b)
+
+(add-to-ordered-list 'foo 'd) ;; @r{Append @code{d}.}
+ @result{} (a c b d)
+
+(add-to-ordered-list 'foo 'e) ;; @r{Add @code{e}}.
+ @result{} (a c b e d)
+
+foo ;; @r{@code{foo} was changed.}
+ @result{} (a c b e d)
+@end example
+
@node Variable Scoping
@section Scoping Rules for Variable Bindings
@cindex scope
@cindex extent
@cindex dynamic scoping
+@cindex lexical scoping
Local bindings in Emacs Lisp have @dfn{indefinite scope} and
@dfn{dynamic extent}. @dfn{Scope} refers to @emph{where} textually in
-the source code the binding can be accessed. Indefinite scope means
+the source code the binding can be accessed. ``Indefinite scope'' means
that any part of the program can potentially access the variable
binding. @dfn{Extent} refers to @emph{when}, as the program is
-executing, the binding exists. Dynamic extent means that the binding
+executing, the binding exists. ``Dynamic extent'' means that the binding
lasts as long as the activation of the construct that established it.
The combination of dynamic extent and indefinite scope is called
In a lexically scoped language, the binding of @code{x} in
@code{binder} would never be accessible in @code{user}, because
@code{user} is not textually contained within the function
-@code{binder}. However, in dynamically scoped Emacs Lisp, @code{user}
+@code{binder}. However, in dynamically-scoped Emacs Lisp, @code{user}
may or may not refer to the binding of @code{x} established in
-@code{binder}, depending on circumstances:
+@code{binder}, depending on the circumstances:
@itemize @bullet
@item
@cindex buffer-local variables
Global and local variable bindings are found in most programming
-languages in one form or another. Emacs also supports additional,
+languages in one form or another. Emacs, however, also supports additional,
unusual kinds of variable binding: @dfn{buffer-local} bindings, which
-apply only in one buffer, and frame-local bindings, which apply only in
+apply only in one buffer, and @dfn{frame-local} bindings, which apply only in
one frame. Having different values for a variable in different buffers
and/or frames is an important customization method.
A variable can have buffer-local bindings in some buffers but not in
other buffers. The default binding is shared by all the buffers that
don't have their own bindings for the variable. (This includes all
-newly created buffers.) If you set the variable in a buffer that does
+newly-created buffers.) If you set the variable in a buffer that does
not have a buffer-local binding for it, this sets the default binding
(assuming there are no frame-local bindings to complicate the matter),
so the new value is visible in all the buffers that see the default
be changed with @code{setq} in any buffer; the only way to change it is
with @code{setq-default}.
- @strong{Warning:} When a variable has buffer-local values in one or
-more buffers, you can get Emacs very confused by binding the variable
-with @code{let}, changing to a different current buffer in which a
-different binding is in effect, and then exiting the @code{let}. This
-can scramble the values of the buffer-local and default bindings.
-
- To preserve your sanity, avoid using a variable in that way. If you
-use @code{save-excursion} around each piece of code that changes to a
-different current buffer, you will not have this problem
-(@pxref{Excursions}). Here is an example of what to avoid:
+ @strong{Warning:} When a variable has buffer-local or frame-local
+bindings in one or more buffers, @code{let} rebinds the binding that's
+currently in effect. For instance, if the current buffer has a
+buffer-local value, @code{let} temporarily rebinds that. If no
+buffer-local or frame-local bindings are in effect, @code{let} rebinds
+the default value. If inside the @code{let} you then change to a
+different current buffer in which a different binding is in effect,
+you won't see the @code{let} binding any more. And if you exit the
+@code{let} while still in the other buffer, you won't see the
+unbinding occur (though it will occur properly). Here is an example
+to illustrate:
@example
@group
-(setq foo 'b)
+(setq foo 'g)
(set-buffer "a")
(make-local-variable 'foo)
@end group
(setq foo 'a)
(let ((foo 'temp))
+ ;; foo @result{} 'temp ; @r{let binding in buffer @samp{a}}
(set-buffer "b")
+ ;; foo @result{} 'g ; @r{the global value since foo is not local in @samp{b}}
@var{body}@dots{})
@group
-foo @result{} 'a ; @r{The old buffer-local value from buffer @samp{a}}
- ; @r{is now the default value.}
+foo @result{} 'g ; @r{exiting restored the local value in buffer @samp{a},}
+ ; @r{but we don't see that in buffer @samp{b}}
@end group
@group
-(set-buffer "a")
-foo @result{} 'temp ; @r{The local @code{let} value that should be gone}
- ; @r{is now the buffer-local value in buffer @samp{a}.}
-@end group
-@end example
-
-@noindent
-But @code{save-excursion} as shown here avoids the problem:
-
-@example
-@group
-(let ((foo 'temp))
- (save-excursion
- (set-buffer "b")
- @var{body}@dots{}))
+(set-buffer "a") ; @r{verify the local value was restored}
+foo @result{} 'a
@end group
@end example
variables cannot have buffer-local bindings as well. @xref{Multiple
Displays}.
-@strong{Note:} do not use @code{make-local-variable} for a hook
-variable. Instead, use @code{make-local-hook}. @xref{Hooks}.
+@strong{Warning:} do not use @code{make-local-variable} for a hook
+variable. The hook variables are automatically made buffer-local as
+needed if you use the @var{local} argument to @code{add-hook} or
+@code{remove-hook}.
@end deffn
@deffn Command make-variable-buffer-local variable
A peculiar wrinkle of this feature is that binding the variable (with
@code{let} or other binding constructs) does not create a buffer-local
binding for it. Only setting the variable (with @code{set} or
-@code{setq}) does so.
+@code{setq}), while the variable does not have a @code{let}-style
+binding that was made in the current buffer, does so.
+
+If @var{variable} does not have a default value, then calling this
+command will give it a default value of @code{nil}. If @var{variable}
+already has a default value, that value remains unchanged.
+Subsequently calling @code{makunbound} on @var{variable} will result
+in a void buffer-local value and leave the default value unaffected.
The value returned is @var{variable}.
@code{nil}.
@end defun
+@defun local-variable-if-set-p variable &optional buffer
+This returns @code{t} if @var{variable} will become buffer-local in
+buffer @var{buffer} (which defaults to the current buffer) if it is
+set there.
+@end defun
+
+@defun buffer-local-value variable buffer
+This function returns the buffer-local binding of @var{variable} (a
+symbol) in buffer @var{buffer}. If @var{variable} does not have a
+buffer-local binding in buffer @var{buffer}, it returns the default
+value (@pxref{Default Value}) of @var{variable} instead.
+@end defun
+
@defun buffer-local-variables &optional buffer
This function returns a list describing the buffer-local variables in
buffer @var{buffer}. (If @var{buffer} is omitted, the current buffer is
(mode-name . "Fundamental")
@dots{}
@group
- ;; @r{Next, non-built-in buffer-local variables.}
+ ;; @r{Next, non-built-in buffer-local variables.}
;; @r{This one is buffer-local and void:}
foobar
;; @r{This one is buffer-local and nonvoid:}
The function @code{kill-all-local-variables} runs this normal hook
before it does anything else. This gives major modes a way to arrange
for something special to be done if the user switches to a different
-major mode. For best results, make this variable buffer-local, so that
-it will disappear after doing its job and will not interfere with the
+major mode. It is also useful for buffer-specific minor modes
+that should be forgotten if the user changes the major mode.
+
+For best results, make this variable buffer-local, so that it will
+disappear after doing its job and will not interfere with the
subsequent major mode. @xref{Hooks}.
@end defvar
if some frame already has a value for @var{variable} as a frame
parameter, that value automatically becomes a frame-local binding.
+If @var{variable} does not have a default value, then calling this
+command will give it a default value of @code{nil}. If @var{variable}
+already has a default value, that value remains unchanged.
+
If the variable is terminal-local, this function signals an error,
because such variables cannot have frame-local bindings as well.
@xref{Multiple Displays}. A few variables that are implemented
-specially in Emacs can be (and usually are) buffer-local, but can never
-be frame-local.
+specially in Emacs can be buffer-local, but can never be frame-local.
+
+This command returns @var{variable}.
@end deffn
Buffer-local bindings take precedence over frame-local bindings. Thus,
of frames---for example, all color frames, or all frames with dark
backgrounds. We have not implemented them because it is not clear that
this feature is really useful. You can get more or less the same
-results by adding a function to @code{after-make-frame-hook}, set up to
+results by adding a function to @code{after-make-frame-functions}, set up to
define a particular frame parameter according to the appropriate
conditions for each frame.
If sufficient application is found for either of these two kinds of
local bindings, we will provide it in a subsequent Emacs version.
+@node File Local Variables
+@section File Local Variables
+
+ This section describes the functions and variables that affect
+processing of file local variables. @xref{File variables, ,
+Local Variables in Files, emacs, The GNU Emacs Manual}, for basic
+information about file local variables.
+
+@defopt enable-local-variables
+This variable controls whether to process file local variables. A
+value of @code{t} means to process them, querying the user if unsafe
+variables are encountered; @code{nil} means ignore them; anything else
+means to query the user for each file. The default value is @code{t}.
+@end defopt
+
+@defun hack-local-variables &optional mode-only
+This function parses, and binds or evaluates as appropriate, any local
+variables specified by the contents of the current buffer. The variable
+@code{enable-local-variables} has its effect here. However, this
+function does not look for the @samp{mode:} local variable in the
+@w{@samp{-*-}} line. @code{set-auto-mode} does that, also taking
+@code{enable-local-variables} into account (@pxref{Auto Major Mode}).
+
+If the optional argument @var{mode-only} is non-@code{nil}, then all
+this function does is return @code{t} if the @w{@samp{-*-}} line or
+the local variables list specifies a mode and @code{nil} otherwise.
+It does not set the mode nor any other file local variable.
+@end defun
+
+ If a file local variable could specify a function that would
+be called later, or an expression that would be executed later, simply
+visiting a file could take over your Emacs. Emacs takes several
+measures to prevent this.
+
+@cindex safe local variable
+ You can specify safe values for a variable with a
+@code{safe-local-variable} property. If the property is @code{t},
+setting that variable in a file is always considered safe, regardless
+of the value used. If the property is a function of one argument,
+then any value is safe if the function returns non-@code{nil} given
+that value. Many commonly encountered file variables standardly have
+@code{safe-local-variable} properties, including @code{fill-column},
+@code{fill-prefix}, and @code{indent-tabs-mode}.
+
+@defopt safe-local-variable-values
+This variable provides another way to mark some variable values as
+safe. It is a list of cons cells @code{(@var{var} . @var{val})},
+where @var{var} is a variable name and @var{val} is a value which is
+safe for that variable.
+
+When Emacs asks the user whether or not to obey a set of file local
+variable specifications, the user can choose to mark them as safe.
+Doing so adds those variable/value pairs to
+@code{safe-local-variable-values}, and saves it to the user's custom
+file.
+@end defopt
+
+@defun safe-local-variable-p sym val
+This function returns non-@code{nil} if it is safe to give @var{sym}
+the value @var{val}, based on the above criteria.
+@end defun
+
+@cindex risky local variable
+ Some variables are considered @dfn{risky}. A variable whose name
+ends in any of @samp{-command}, @samp{-frame-alist}, @samp{-function},
+@samp{-functions}, @samp{-hook}, @samp{-hooks}, @samp{-form},
+@samp{-forms}, @samp{-map}, @samp{-map-alist}, @samp{-mode-alist},
+@samp{-program}, or @samp{-predicate} is considered risky. The
+variables @samp{font-lock-keywords}, @samp{font-lock-keywords}
+followed by a digit, and @samp{font-lock-syntactic-keywords} are also
+considered risky. Finally, any variable whose name has a
+non-@code{nil} @code{risky-local-variable} property is considered
+risky.
+
+@defun risky-local-variable-p sym
+This function returns non-@code{nil} if @var{sym} is a risky variable,
+based on the above criteria.
+@end defun
+
+ If a variable is risky, it will not be entered automatically into
+@code{safe-local-variable-values} as described above. Therefore,
+Emacs will always query before setting a risky variable, unless the
+user explicitly allows the setting by customizing
+@code{safe-local-variable-values} directly.
+
+@defvar ignored-local-variables
+This variable holds a list of variables that should not be given local
+values by files. Any value specified for one of these variables is
+completely ignored.
+@end defvar
+
+ The @samp{Eval:} ``variable'' is also a potential loophole, so Emacs
+normally asks for confirmation before handling it.
+
+@defopt enable-local-eval
+This variable controls processing of @samp{Eval:} in @samp{-*-} lines
+or local variables
+lists in files being visited. A value of @code{t} means process them
+unconditionally; @code{nil} means ignore them; anything else means ask
+the user what to do for each file. The default value is @code{maybe}.
+@end defopt
+
+ Text properties are also potential loopholes, since their values
+could include functions to call. So Emacs discards all text
+properties from string values specified for file local variables.
+
+@node Variable Aliases
+@section Variable Aliases
+
+ It is sometimes useful to make two variables synonyms, so that both
+variables always have the same value, and changing either one also
+changes the other. Whenever you change the name of a
+variable---either because you realize its old name was not well
+chosen, or because its meaning has partly changed---it can be useful
+to keep the old name as an @emph{alias} of the new one for
+compatibility. You can do this with @code{defvaralias}.
+
+@defun defvaralias new-alias base-variable &optional docstring
+This function defines the symbol @var{new-alias} as a variable alias
+for symbol @var{base-variable}. This means that retrieving the value of
+@var{new-alias} returns the value of @var{base-variable}, and changing the
+value of @var{new-alias} changes the value of @var{base-variable}.
+
+If the @var{docstring} argument is non-@code{nil}, it specifies the
+documentation for @var{new-alias}; otherwise, the alias gets the same
+documentation as @var{base-variable} has, if any, unless
+@var{base-variable} is itself an alias, in which case @var{new-alias} gets
+the documentation of the variable at the end of the chain of aliases.
+
+This function returns @var{base-variable}.
+@end defun
+
+ Variable aliases are convenient for replacing an old name for a
+variable with a new name. @code{make-obsolete-variable} declares that
+the old name is obsolete and therefore that it may be removed at some
+stage in the future.
+
+@defun make-obsolete-variable obsolete-name current-name &optional when
+This function makes the byte-compiler warn that the variable
+@var{obsolete-name} is obsolete. If @var{current-name} is a symbol, it is
+the variable's new name; then the warning message says to use
+@var{current-name} instead of @var{obsolete-name}. If @var{current-name}
+is a string, this is the message and there is no replacement variable.
+
+If provided, @var{when} should be a string indicating when the
+variable was first made obsolete---for example, a date or a release
+number.
+@end defun
+
+ You can make two variables synonyms and declare one obsolete at the
+same time using the macro @code{define-obsolete-variable-alias}.
+
+@defmac define-obsolete-variable-alias obsolete-name current-name &optional when docstring
+This macro marks the variable @var{obsolete-name} as obsolete and also
+makes it an alias for the variable @var{current-name}. It is
+equivalent to the following:
+
+@example
+(defvaralias @var{obsolete-name} @var{current-name} @var{docstring})
+(make-obsolete-variable @var{obsolete-name} @var{current-name} @var{when})
+@end example
+@end defmac
+
+@defun indirect-variable variable
+This function returns the variable at the end of the chain of aliases
+of @var{variable}. If @var{variable} is not a symbol, or if @var{variable} is
+not defined as an alias, the function returns @var{variable}.
+
+This function signals a @code{cyclic-variable-indirection} error if
+there is a loop in the chain of symbols.
+@end defun
+
+@example
+(defvaralias 'foo 'bar)
+(indirect-variable 'foo)
+ @result{} bar
+(indirect-variable 'bar)
+ @result{} bar
+(setq bar 2)
+bar
+ @result{} 2
+@group
+foo
+ @result{} 2
+@end group
+(setq foo 0)
+bar
+ @result{} 0
+foo
+ @result{} 0
+@end example
+
+@node Variables with Restricted Values
+@section Variables with Restricted Values
+
+ Ordinary Lisp variables can be assigned any value that is a valid
+Lisp object. However, certain Lisp variables are not defined in Lisp,
+but in C. Most of these variables are defined in the C code using
+@code{DEFVAR_LISP}. Like variables defined in Lisp, these can take on
+any value. However, some variables are defined using
+@code{DEFVAR_INT} or @code{DEFVAR_BOOL}. @xref{Defining Lisp
+variables in C,, Writing Emacs Primitives}, in particular the
+description of functions of the type @code{syms_of_@var{filename}},
+for a brief discussion of the C implementation.
+ Variables of type @code{DEFVAR_BOOL} can only take on the values
+@code{nil} or @code{t}. Attempting to assign them any other value
+will set them to @code{t}:
+
+@example
+(let ((display-hourglass 5))
+ display-hourglass)
+ @result{} t
+@end example
+
+@defvar byte-boolean-vars
+This variable holds a list of all variables of type @code{DEFVAR_BOOL}.
+@end defvar
+
+ Variables of type @code{DEFVAR_INT} can only take on integer values.
+Attempting to assign them any other value will result in an error:
+
+@example
+(setq window-min-height 5.0)
+@error{} Wrong type argument: integerp, 5.0
+@end example
+
+@ignore
+ arch-tag: 5ff62c44-2b51-47bb-99d4-fea5aeec5d3e
+@end ignore