@end example
@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.
@code{max-lisp-eval-depth} provides another limit on depth of nesting.
@xref{Definition of max-lisp-eval-depth,, Eval}.
-The default value is 600. Entry to the Lisp debugger increases the
+The default value is 1000. Entry to the Lisp debugger increases the
value, if there is little room left, to make sure the debugger itself
has room to execute.
@end defvar
@item @dots{}-command
The value is a whole shell command.
-@item @samp{}-switches
+@item @dots{}-switches
The value specifies options for a command.
@end table
@end group
@group
-;; @r{Here the value of @code{abracadabra},}
+;; @r{Here, the value of @code{abracadabra},}
;; @r{which is @code{foo},}
;; @r{is the symbol whose value is examined.}
(let ((abracadabra 'foo))
@end quotation
@end defun
- 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 &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
-the argument yourself if that is what you want.
-@end defun
-
-Here's a scenario showing how to use @code{add-to-list}:
-
-@example
-(setq foo '(a b))
- @result{} (a b)
-
-(add-to-list 'foo 'c) ;; @r{Add @code{c}.}
- @result{} (c a b)
-
-(add-to-list 'foo 'b) ;; @r{No effect.}
- @result{} (c a b)
-
-foo ;; @r{@code{foo} was changed.}
- @result{} (c a b)
-@end example
-
- An equivalent expression for @code{(add-to-list '@var{var}
-@var{value})} is this:
-
-@example
-(or (member @var{value} @var{var})
- (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
@end example
@cindex closures not available
- Some Lisp dialects have ``closures'', objects that are like functions
+ Some Lisp dialects have ``closures,'' objects that are like functions
but record additional variable bindings. Emacs Lisp does not have
closures.
@defun kill-all-local-variables
This function eliminates all the buffer-local variable bindings of the
-current buffer except for variables marked as ``permanent''. As a
+current buffer except for variables marked as ``permanent.'' As a
result, the buffer will see the default values of most variables.
This function also resets certain other information pertaining to the
@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.
+ A file can specify local variable values; Emacs uses these to create
+buffer-local bindings for those variables in the buffer visiting that
+file. @xref{File variables, , Local Variables in Files, emacs, The
+GNU Emacs Manual}, for basic information about file local variables.
+This section describes the functions and variables that affect
+processing of file local variables.
@defopt enable-local-variables
This variable controls whether to process file local variables. A
measures to prevent this.
@cindex safe local variable
- When Emacs encounters a file local variable whose safety is not
-guaranteed, it asks the user whether or not to obey the file variable
-specifications. If the user says no, Emacs ignores @emph{all} the
-file variables specified in that file. A variable can be marked as
-@dfn{safe} by setting its @code{safe-local-variable} property. If the
-property is @code{t}, that variable is always considered safe,
-regardless of the value assigned to it. The
-@code{safe-local-variable} property can also be a a function taking
-exactly one argument. In that case, Emacs considers it safe to give
-the variable a certain value if the function returns non-@code{nil}
-when called with that value as argument. Many commonly-encountered
-file variables possess @code{safe-local-variable} by default,
+ You can specify safe values for a variable with a
+@code{safe-local-variable} property. The property has to be
+a function of one argument; 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}.
+@code{indent-tabs-mode}. For boolean-valued variables that are safe,
+use @code{booleanp} as the property value. Lambda expressions should
+be quoted so that @code{describe-variable} can display the predicate.
@defopt safe-local-variable-values
-This variable provides another way to mark variables as safe. It is a
-list of cons cells @code{(var . val)}, where @var{var} is a variable
-name and @var{val} is a value of that variable that is safe.
-
-When Emacs asks the user whether or not to obey a set of file variable
-specifications, the user can choose to mark them as safe. This adds
-those variable-value pairs to @code{safe-local-variable-values}, and
-saves it to the user's custom file.
+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
@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},
+ 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
based on the above criteria.
@end defun
-If a variable is risky, it will not be entered automatically into
+ 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 it by editing @code{safe-local-variable-values}
-via Customize.
+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
the user what to do for each file. The default value is @code{maybe}.
@end defopt
+@defopt safe-local-eval-forms
+This variable holds a list of expressions that are safe to
+evaluate when found in the @samp{Eval:} ``variable'' in a file
+local variables list.
+@end defopt
+
+ If the expression is a function call and the function has a
+@code{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 @code{t}
+(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.