A file can specify local variable values; Emacs uses these to create buffer-local bindings for those variables in the buffer visiting that file. See Local Variables in Files, for basic information about file-local variables. This section describes the functions and variables that affect how file-local variables are processed.
If a file-local variable could specify an arbitrary function or Lisp expression that would be called later, visiting a file could take over your Emacs. Emacs protects against this by automatically setting only those file-local variables whose specified values are known to be safe. Other file-local variables are set only if the user agrees.
For additional safety,
read-circle is temporarily bound to
nil when Emacs reads file-local variables (see Input Functions). This prevents the Lisp reader from recognizing circular
and shared Lisp structures (see Circular Objects).
This variable controls whether to process file-local variables. The possible values are:
- Set the safe variables, and query (once) about any unsafe variables.
- Set only the safe variables and do not query.
- Set all the variables and do not query.
- Don't set any variables.
- anything else
- Query (once) about all the variables.
This function parses, and binds or evaluates as appropriate, any local variables specified by the contents of the current buffer. The variable
enable-local-variableshas its effect here. However, this function does not look for the ‘mode:’ local variable in the ‘-*-’ line.
set-auto-modedoes that, also taking
enable-local-variablesinto account (see Auto Major Mode).
This function works by walking the alist stored in
file-local-variables-alistand applying each local variable in turn. It calls
hack-local-variables-hookbefore and after applying the variables, respectively.
If the optional argument mode-only is non-
nil, then all this function does is return
tif the ‘-*-’ line or the local variables list specifies a mode and
nilotherwise. It does not set the mode nor any other file-local variable.
This buffer-local variable holds the alist of file-local variable settings. Each element of the alist is of the form
), where var is a symbol of the local variable and value is its value. When Emacs visits a file, it first collects all the file-local variables into this alist, and then the
hack-local-variablesfunction applies them one by one.
Emacs calls this hook immediately before applying file-local variables stored in
Emacs calls this hook immediately after it finishes applying file-local variables stored in
You can specify safe values for a variable with a
safe-local-variable property. The property has to be a
function of one argument; any value is safe if the function returns
nil given that value. Many commonly-encountered file
safe-local-variable properties; these include
For boolean-valued variables that are safe, use
booleanp as the
property value. Lambda expressions should be quoted so that
describe-variable can display the predicate.
This variable provides another way to mark some variable values as safe. It is a list of cons cells
), where var is a variable name and 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
safe-local-variable-values, and saves it to the user's custom file.
This function returns non-
nilif it is safe to give sym the value val, based on the above criteria.
Some variables are considered risky. A variable whose name
ends in any of ‘-command’, ‘-frame-alist’, ‘-function’,
‘-functions’, ‘-hook’, ‘-hooks’, ‘-form’,
‘-forms’, ‘-map’, ‘-map-alist’, ‘-mode-alist’,
‘-program’, or ‘-predicate’ is considered risky. The
variables ‘font-lock-keywords’, ‘font-lock-keywords’
followed by a digit, and ‘font-lock-syntactic-keywords’ are also
considered risky. Finally, any variable whose name has a
risky-local-variable property is considered
This function returns non-
nilif sym is a risky variable, based on the above criteria.
If a variable is risky, it will not be entered automatically into
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
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.
The ‘Eval:’ “variable” is also a potential loophole, so Emacs normally asks for confirmation before handling it.
This variable controls processing of ‘Eval:’ in ‘-*-’ lines or local variables lists in files being visited. A value of
tmeans process them unconditionally;
nilmeans ignore them; anything else means ask the user what to do for each file. The default value is
This variable holds a list of expressions that are safe to evaluate when found in the ‘Eval:’ “variable” in a file local variables list.
If the expression is a function call and the function has a
safe-local-eval-function property, the property value
determines whether the expression is safe to evaluate. The property
value can be a predicate to call to test the expression, a list of
such predicates (it's safe if any predicate succeeds), or
(always safe provided the arguments are constant).
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.blog comments powered by Disqus