/* Evaluator for GNU Emacs Lisp interpreter.
- Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995 Free Software Foundation, Inc.
+ Copyright (C) 1985, 86, 87, 93, 94, 95, 99, 2000
+ Free Software Foundation, Inc.
This file is part of GNU Emacs.
#include <config.h>
-
-#ifdef STDC_HEADERS
-#include <stdlib.h>
-#endif
-
#include "lisp.h"
#include "blockinput.h"
-
-#ifndef standalone
#include "commands.h"
#include "keyboard.h"
-#else
-#define INTERACTIVE 1
-#endif
-
+#include "dispextern.h"
#include <setjmp.h>
/* This definition is duplicated in alloc.c and keyboard.c */
/* Putting it in lisp.h makes cc bomb out! */
struct backtrace
- {
- struct backtrace *next;
- Lisp_Object *function;
- Lisp_Object *args; /* Points to vector of args. */
- int nargs; /* Length of vector.
+{
+ struct backtrace *next;
+ Lisp_Object *function;
+ Lisp_Object *args; /* Points to vector of args. */
+ int nargs; /* Length of vector.
If nargs is UNEVALLED, args points to slot holding
list of unevalled args */
- char evalargs;
- /* Nonzero means call value of debugger when done with this operation. */
- char debug_on_exit;
- };
+ char evalargs;
+ /* Nonzero means call value of debugger when done with this operation. */
+ char debug_on_exit;
+};
struct backtrace *backtrace_list;
All the other members are concerned with restoring the interpreter
state. */
+
struct catchtag
- {
- Lisp_Object tag;
- Lisp_Object val;
- struct catchtag *next;
- struct gcpro *gcpro;
- jmp_buf jmp;
- struct backtrace *backlist;
- struct handler *handlerlist;
- int lisp_eval_depth;
- int pdlcount;
- int poll_suppress_count;
- };
+{
+ Lisp_Object tag;
+ Lisp_Object val;
+ struct catchtag *next;
+ struct gcpro *gcpro;
+ jmp_buf jmp;
+ struct backtrace *backlist;
+ struct handler *handlerlist;
+ int lisp_eval_depth;
+ int pdlcount;
+ int poll_suppress_count;
+ struct byte_stack *byte_stack;
+};
struct catchtag *catchlist;
+#ifdef DEBUG_GCPRO
+/* Count levels of GCPRO to detect failure to UNGCPRO. */
+int gcpro_level;
+#endif
+
Lisp_Object Qautoload, Qmacro, Qexit, Qinteractive, Qcommandp, Qdefun;
Lisp_Object Qinhibit_quit, Vinhibit_quit, Vquit_flag;
Lisp_Object Qmocklisp_arguments, Vmocklisp_arguments, Qmocklisp;
/* This holds either the symbol `run-hooks' or nil.
It is nil at an early stage of startup, and when Emacs
is shutting down. */
+
Lisp_Object Vrun_hooks;
/* Non-nil means record all fset's and provide's, to be undone
Lisp_Object Vautoload_queue;
/* Current number of specbindings allocated in specpdl. */
+
int specpdl_size;
/* Pointer to beginning of specpdl. */
+
struct specbinding *specpdl;
/* Pointer to first unused element in specpdl. */
+
struct specbinding *specpdl_ptr;
/* Maximum size allowed for specpdl allocation */
+
int max_specpdl_size;
/* Depth in Lisp evaluations and function calls. */
+
int lisp_eval_depth;
/* Maximum allowed depth in Lisp evaluations and function calls. */
+
int max_lisp_eval_depth;
/* Nonzero means enter debugger before next function call */
+
int debug_on_next_call;
+/* Non-zero means debuffer may continue. This is zero when the
+ debugger is called during redisplay, where it might not be safe to
+ continue the interrupted redisplay. */
+
+int debugger_may_continue;
+
/* List of conditions (non-nil atom means all) which cause a backtrace
if an error is handled by the command loop's error handler. */
+
Lisp_Object Vstack_trace_on_error;
/* List of conditions (non-nil atom means all) which enter the debugger
if an error is handled by the command loop's error handler. */
+
Lisp_Object Vdebug_on_error;
/* List of conditions and regexps specifying error messages which
do not enter the debugger even if Vdebug_on_errors says they should. */
+
Lisp_Object Vdebug_ignored_errors;
/* Non-nil means call the debugger even if the error will be handled. */
+
Lisp_Object Vdebug_on_signal;
/* Hook for edebug to use. */
+
Lisp_Object Vsignal_hook_function;
/* Nonzero means enter debugger if a quit signal
is handled by the command loop's error handler. */
+
int debug_on_quit;
/* The value of num_nonmacro_input_events as of the last time we
know that the debugger itself has an error, and we should just
signal the error instead of entering an infinite loop of debugger
invocations. */
+
int when_entered_debugger;
Lisp_Object Vdebugger;
+/* The function from which the last `signal' was called. Set in
+ Fsignal. */
+
+Lisp_Object Vsignaling_function;
+
+/* Set to non-zero while processing X events. Checked in Feval to
+ make sure the Lisp interpreter isn't called from a signal handler,
+ which is unsafe because the interpreter isn't reentrant. */
+
+int handling_signal;
+
void specbind (), record_unwind_protect ();
Lisp_Object run_hook_with_args ();
Vquit_flag = Qnil;
debug_on_next_call = 0;
lisp_eval_depth = 0;
+#ifdef DEBUG_GCPRO
+ gcpro_level = 0;
+#endif
/* This is less than the initial value of num_nonmacro_input_events. */
when_entered_debugger = -1;
}
call_debugger (arg)
Lisp_Object arg;
{
+ int debug_while_redisplaying;
+ int count = specpdl_ptr - specpdl;
+ Lisp_Object val;
+
if (lisp_eval_depth + 20 > max_lisp_eval_depth)
max_lisp_eval_depth = lisp_eval_depth + 20;
+
if (specpdl_size + 40 > max_specpdl_size)
max_specpdl_size = specpdl_size + 40;
+
+#ifdef HAVE_X_WINDOWS
+ if (display_busy_cursor_p)
+ cancel_busy_cursor ();
+#endif
+
debug_on_next_call = 0;
when_entered_debugger = num_nonmacro_input_events;
- return apply1 (Vdebugger, arg);
+
+ /* Resetting redisplaying_p to 0 makes sure that debug output is
+ displayed if the debugger is invoked during redisplay. */
+ debug_while_redisplaying = redisplaying_p;
+ redisplaying_p = 0;
+ specbind (intern ("debugger-may-continue"),
+ debug_while_redisplaying ? Qnil : Qt);
+
+ val = apply1 (Vdebugger, arg);
+
+ /* Interrupting redisplay and resuming it later is not safe under
+ all circumstances. So, when the debugger returns, abort the
+ interupted redisplay by going back to the top-level. */
+ if (debug_while_redisplaying)
+ Ftop_level ();
+
+ return unbind_to (count, val);
}
void
}
DEFUN ("if", Fif, Sif, 2, UNEVALLED, 0,
- "(if COND THEN ELSE...): if COND yields non-nil, do THEN, else do ELSE...\n\
+ "If COND yields non-nil, do THEN, else do ELSE...\n\
Returns the value of THEN or the value of the last of the ELSE's.\n\
THEN must be one expression, but ELSE... can be zero or more expressions.\n\
If COND yields nil, and there are no ELSE's, the value is nil.")
}
DEFUN ("cond", Fcond, Scond, 0, UNEVALLED, 0,
- "(cond CLAUSES...): try each clause until one succeeds.\n\
+ "Try each clause until one succeeds.\n\
Each clause looks like (CONDITION BODY...). CONDITION is evaluated\n\
and, if the value is non-nil, this clause succeeds:\n\
then the expressions in BODY are evaluated and the last one's\n\
}
DEFUN ("progn", Fprogn, Sprogn, 0, UNEVALLED, 0,
- "(progn BODY...): eval BODY forms sequentially and return value of last one.")
+ "Eval BODY forms sequentially and return value of last one.")
(args)
Lisp_Object args;
{
}
DEFUN ("prog1", Fprog1, Sprog1, 1, UNEVALLED, 0,
- "(prog1 FIRST BODY...): eval FIRST and BODY sequentially; value from FIRST.\n\
+ "Eval FIRST and BODY sequentially; value from FIRST.\n\
The value of FIRST is saved during the evaluation of the remaining args,\n\
whose values are discarded.")
(args)
}
DEFUN ("prog2", Fprog2, Sprog2, 2, UNEVALLED, 0,
- "(prog2 X Y BODY...): eval X, Y and BODY sequentially; value from Y.\n\
+ "Eval X, Y and BODY sequentially; value from Y.\n\
The value of Y is saved during the evaluation of the remaining args,\n\
whose values are discarded.")
(args)
}
DEFUN ("setq", Fsetq, Ssetq, 0, UNEVALLED, 0,
- "(setq SYM VAL SYM VAL ...): set each SYM to the value of its VAL.\n\
+ "Set each SYM to the value of its VAL.\n\
The symbols SYM are variables; they are literal (not evaluated).\n\
The values VAL are expressions; they are evaluated.\n\
Thus, (setq x (1+ y)) sets `x' to the value of `(1+ y)'.\n\
}
DEFUN ("defun", Fdefun, Sdefun, 2, UNEVALLED, 0,
- "(defun NAME ARGLIST [DOCSTRING] BODY...): define NAME as a function.\n\
+ "Define NAME as a function.\n\
The definition is (lambda ARGLIST [DOCSTRING] BODY...).\n\
See also the function `interactive'.")
(args)
}
DEFUN ("defmacro", Fdefmacro, Sdefmacro, 2, UNEVALLED, 0,
- "(defmacro NAME ARGLIST [DOCSTRING] BODY...): define NAME as a macro.\n\
+ "Define NAME as a macro.\n\
The definition is (macro lambda ARGLIST [DOCSTRING] BODY...).\n\
When the macro is called, as in (NAME ARGS...),\n\
the function (lambda ARGLIST BODY...) is applied to\n\
}
DEFUN ("defvar", Fdefvar, Sdefvar, 1, UNEVALLED, 0,
- "(defvar SYMBOL INITVALUE DOCSTRING): define SYMBOL as a variable.\n\
+ "Define SYMBOL as a variable.\n\
You are not required to define a variable in order to use it,\n\
but the definition can supply documentation and an initial value\n\
in a way that tags can recognize.\n\n\
buffer-local values are not affected.\n\
INITVALUE and DOCSTRING are optional.\n\
If DOCSTRING starts with *, this variable is identified as a user option.\n\
- This means that M-x set-variable and M-x edit-options recognize it.\n\
+ This means that M-x set-variable recognizes it.\n\
+ See also `user-variable-p'.\n\
If INITVALUE is missing, SYMBOL's value is not set.")
(args)
Lisp_Object args;
}
DEFUN ("defconst", Fdefconst, Sdefconst, 2, UNEVALLED, 0,
- "(defconst SYMBOL INITVALUE DOCSTRING): define SYMBOL as a constant variable.\n\
+ "Define SYMBOL as a constant variable.\n\
The intent is that neither programs nor users should ever change this value.\n\
Always sets the value of SYMBOL to the result of evalling INITVALUE.\n\
If SYMBOL is buffer-local, its default value is what is set;\n\
if (!NILP (Fcdr (Fcdr (Fcdr (args)))))
error ("too many arguments");
- Fset_default (sym, Feval (Fcar (Fcdr (args))));
+ tem = Feval (Fcar (Fcdr (args)));
+ if (!NILP (Vpurify_flag))
+ tem = Fpurecopy (tem);
+ Fset_default (sym, tem);
tem = Fcar (Fcdr (Fcdr (args)));
if (!NILP (tem))
{
"Returns t if VARIABLE is intended to be set and modified by users.\n\
\(The alternative is a variable used internally in a Lisp program.)\n\
Determined by whether the first character of the documentation\n\
-for the variable is `*'.")
+for the variable is `*' or if the variable is customizable (has a non-nil\n\
+value of any of `custom-type', `custom-loads' or `standard-value'\n\
+on its property list).")
(variable)
Lisp_Object variable;
{
&& INTEGERP (XCDR (documentation))
&& XINT (XCDR (documentation)) < 0)
return Qt;
+ /* Customizable? */
+ if ((!NILP (Fget (variable, intern ("custom-type"))))
+ || (!NILP (Fget (variable, intern ("custom-loads"))))
+ || (!NILP (Fget (variable, intern ("standard-value")))))
+ return Qt;
return Qnil;
}
\f
DEFUN ("let*", FletX, SletX, 1, UNEVALLED, 0,
- "(let* VARLIST BODY...): bind variables according to VARLIST then eval BODY.\n\
+ "Bind variables according to VARLIST then eval BODY.\n\
The value of the last form in BODY is returned.\n\
Each element of VARLIST is a symbol (which is bound to nil)\n\
or a list (SYMBOL VALUEFORM) (which binds SYMBOL to the value of VALUEFORM).\n\
}
DEFUN ("let", Flet, Slet, 1, UNEVALLED, 0,
- "(let VARLIST BODY...): bind variables according to VARLIST then eval BODY.\n\
+ "Bind variables according to VARLIST then eval BODY.\n\
The value of the last form in BODY is returned.\n\
Each element of VARLIST is a symbol (which is bound to nil)\n\
or a list (SYMBOL VALUEFORM) (which binds SYMBOL to the value of VALUEFORM).\n\
}
DEFUN ("while", Fwhile, Swhile, 1, UNEVALLED, 0,
- "(while TEST BODY...): if TEST yields non-nil, eval BODY... and repeat.\n\
+ "If TEST yields non-nil, eval BODY... and repeat.\n\
The order of execution is thus TEST, BODY, TEST, BODY and so on\n\
until TEST returns nil.")
(args)
If FORM is not a macro call, it is returned unchanged.\n\
Otherwise, the macro is expanded and the expansion is considered\n\
in place of FORM. When a non-macro-call results, it is returned.\n\n\
-The second optional arg ENVIRONMENT species an environment of macro\n\
+The second optional arg ENVIRONMENT specifies an environment of macro\n\
definitions to shadow the loaded ones for use in file byte-compilation.")
(form, environment)
Lisp_Object form;
}
\f
DEFUN ("catch", Fcatch, Scatch, 1, UNEVALLED, 0,
- "(catch TAG BODY...): eval BODY allowing nonlocal exits using `throw'.\n\
+ "Eval BODY allowing nonlocal exits using `throw'.\n\
TAG is evalled to get the tag to use; it must not be nil.\n\
\n\
Then the BODY is executed.\n\
c.pdlcount = specpdl_ptr - specpdl;
c.poll_suppress_count = poll_suppress_count;
c.gcpro = gcprolist;
+ c.byte_stack = byte_stack_list;
catchlist = &c;
/* Call FUNC. */
}
while (! last_time);
+ byte_stack_list = catch->byte_stack;
gcprolist = catch->gcpro;
+#ifdef DEBUG_GCPRO
+ if (gcprolist != 0)
+ gcpro_level = gcprolist->level + 1;
+ else
+ gcpro_level = 0;
+#endif
backtrace_list = catch->backlist;
lisp_eval_depth = catch->lisp_eval_depth;
}
DEFUN ("throw", Fthrow, Sthrow, 2, 2, 0,
- "(throw TAG VALUE): throw to the catch for TAG and return VALUE from it.\n\
+ "Throw to the catch for TAG and return VALUE from it.\n\
Both TAG and VALUE are evalled.")
(tag, value)
register Lisp_Object tag, value;
DEFUN ("unwind-protect", Funwind_protect, Sunwind_protect, 1, UNEVALLED, 0,
"Do BODYFORM, protecting with UNWINDFORMS.\n\
-Usage looks like (unwind-protect BODYFORM UNWINDFORMS...).\n\
If BODYFORM completes normally, its value is returned\n\
after executing the UNWINDFORMS.\n\
If BODYFORM exits nonlocally, the UNWINDFORMS are executed anyway.")
DEFUN ("condition-case", Fcondition_case, Scondition_case, 2, UNEVALLED, 0,
"Regain control when an error is signaled.\n\
-Usage looks like (condition-case VAR BODYFORM HANDLERS...).\n\
executes BODYFORM and returns its value if no error happens.\n\
Each element of HANDLERS looks like (CONDITION-NAME BODY...)\n\
where the BODY is made of Lisp expressions.\n\n\
c.pdlcount = specpdl_ptr - specpdl;
c.poll_suppress_count = poll_suppress_count;
c.gcpro = gcprolist;
+ c.byte_stack = byte_stack_list;
if (_setjmp (c.jmp))
{
if (!NILP (h.var))
struct catchtag c;
struct handler h;
+#if 0 /* Can't do this check anymore because realize_basic_faces has
+ to BLOCK_INPUT, and can call Lisp. What's really needed is a
+ flag indicating that we're currently handling a signal. */
/* Since Fsignal resets this to 0, it had better be 0 now
or else we have a potential bug. */
if (interrupt_input_blocked != 0)
abort ();
+#endif
c.tag = Qnil;
c.val = Qnil;
c.pdlcount = specpdl_ptr - specpdl;
c.poll_suppress_count = poll_suppress_count;
c.gcpro = gcprolist;
+ c.byte_stack = byte_stack_list;
if (_setjmp (c.jmp))
{
return (*hfun) (c.val);
c.pdlcount = specpdl_ptr - specpdl;
c.poll_suppress_count = poll_suppress_count;
c.gcpro = gcprolist;
+ c.byte_stack = byte_stack_list;
if (_setjmp (c.jmp))
{
return (*hfun) (c.val);
handlerlist = h.next;
return val;
}
+
+
+/* Like internal_condition_case but call HFUN with NARGS as first,
+ and ARGS as second argument. */
+
+Lisp_Object
+internal_condition_case_2 (bfun, nargs, args, handlers, hfun)
+ Lisp_Object (*bfun) ();
+ int nargs;
+ Lisp_Object *args;
+ Lisp_Object handlers;
+ Lisp_Object (*hfun) ();
+{
+ Lisp_Object val;
+ struct catchtag c;
+ struct handler h;
+
+ c.tag = Qnil;
+ c.val = Qnil;
+ c.backlist = backtrace_list;
+ c.handlerlist = handlerlist;
+ c.lisp_eval_depth = lisp_eval_depth;
+ c.pdlcount = specpdl_ptr - specpdl;
+ c.poll_suppress_count = poll_suppress_count;
+ c.gcpro = gcprolist;
+ c.byte_stack = byte_stack_list;
+ if (_setjmp (c.jmp))
+ {
+ return (*hfun) (c.val);
+ }
+ c.next = catchlist;
+ catchlist = &c;
+ h.handler = handlers;
+ h.var = Qnil;
+ h.next = handlerlist;
+ h.tag = &c;
+ handlerlist = &h;
+
+ val = (*bfun) (nargs, args);
+ catchlist = c.next;
+ handlerlist = h.next;
+ return val;
+}
+
\f
static Lisp_Object find_handler_clause ();
Lisp_Object debugger_value;
Lisp_Object string;
Lisp_Object real_error_symbol;
- Lisp_Object combined_data;
extern int display_busy_cursor_p;
+ struct backtrace *bp;
immediate_quit = 0;
if (gc_in_progress || waiting_for_input)
#ifdef HAVE_X_WINDOWS
if (display_busy_cursor_p)
- Fx_hide_busy_cursor (Qt);
+ cancel_busy_cursor ();
#endif
/* This hook is used by edebug. */
conditions = Fget (real_error_symbol, Qerror_conditions);
+ /* Remember from where signal was called. Skip over the frame for
+ `signal' itself. If a frame for `error' follows, skip that,
+ too. */
+ Vsignaling_function = Qnil;
+ if (backtrace_list)
+ {
+ bp = backtrace_list->next;
+ if (bp && bp->function && EQ (*bp->function, Qerror))
+ bp = bp->next;
+ if (bp && bp->function)
+ Vsignaling_function = *bp->function;
+ }
+
for (; handlerlist; handlerlist = handlerlist->next)
{
register Lisp_Object clause;
+
+ if (lisp_eval_depth + 20 > max_lisp_eval_depth)
+ max_lisp_eval_depth = lisp_eval_depth + 20;
+
+ if (specpdl_size + 40 > max_specpdl_size)
+ max_specpdl_size = specpdl_size + 40;
+
clause = find_handler_clause (handlerlist->handler, conditions,
error_symbol, data, &debugger_value);
if (wants_debugger (Vstack_trace_on_error, conditions))
{
-#ifdef __STDC__
+#ifdef PROTOTYPES
internal_with_output_to_temp_buffer ("*Backtrace*",
(Lisp_Object (*) (Lisp_Object)) Fbacktrace,
Qnil);
string = build_string (buffer);
if (allocated)
- free (buffer);
+ xfree (buffer);
Fsignal (Qerror, Fcons (string, Qnil));
}
{
register Lisp_Object fun;
register Lisp_Object funcar;
- register Lisp_Object tem;
- register int i = 0;
fun = function;
&& EQ (XCAR (XSYMBOL (function)->function), Qautoload)))
return Qnil;
+ if (NILP (Vpurify_flag))
+ /* Only add entries after dumping, because the ones before are
+ not useful and else we get loads of them from the loaddefs.el. */
+ LOADHIST_ATTACH (Fcons (Qautoload, function));
+
#ifdef NO_ARG_ARRAY
args[0] = file;
args[1] = docstring;
Lisp_Object fundef, funname;
{
int count = specpdl_ptr - specpdl;
- Lisp_Object fun, val, queue, first, second;
+ Lisp_Object fun, queue, first, second;
struct gcpro gcpro1, gcpro2, gcpro3;
fun = funname;
XSYMBOL (funname)->name->data);
UNGCPRO;
}
+
\f
DEFUN ("eval", Feval, Seval, 1, 1, 0,
"Evaluate FORM and return its value.")
struct backtrace backtrace;
struct gcpro gcpro1, gcpro2, gcpro3;
- /* Since Fsignal resets this to 0, it had better be 0 now
- or else we have a potential bug. */
- if (interrupt_input_blocked != 0)
+ if (handling_signal)
abort ();
if (SYMBOLP (form))
/* If we are dying or still initializing,
don't do anything--it would probably crash if we tried. */
if (NILP (Vrun_hooks))
- return;
+ return Qnil;
sym = args[0];
val = find_symbol_value (sym);
int nargs;
register Lisp_Object *arg_vector;
{
- Lisp_Object val, tem;
- register Lisp_Object syms_left;
- Lisp_Object numargs;
- register Lisp_Object next;
+ Lisp_Object val, syms_left, next;
int count = specpdl_ptr - specpdl;
- register int i;
- int optional = 0, rest = 0;
+ int i, optional, rest;
- specbind (Qmocklisp_arguments, Qt); /* t means NOT mocklisp! */
-
- XSETFASTINT (numargs, nargs);
+ if (NILP (Vmocklisp_arguments))
+ specbind (Qmocklisp_arguments, Qt); /* t means NOT mocklisp! */
if (CONSP (fun))
- syms_left = Fcar (Fcdr (fun));
+ {
+ syms_left = XCDR (fun);
+ if (CONSP (syms_left))
+ syms_left = XCAR (syms_left);
+ else
+ return Fsignal (Qinvalid_function, Fcons (fun, Qnil));
+ }
else if (COMPILEDP (fun))
syms_left = XVECTOR (fun)->contents[COMPILED_ARGLIST];
- else abort ();
+ else
+ abort ();
- i = 0;
- for (; !NILP (syms_left); syms_left = Fcdr (syms_left))
+ i = optional = rest = 0;
+ for (; CONSP (syms_left); syms_left = XCDR (syms_left))
{
QUIT;
- next = Fcar (syms_left);
+
+ next = XCAR (syms_left);
while (!SYMBOLP (next))
next = Fsignal (Qinvalid_function, Fcons (fun, Qnil));
+
if (EQ (next, Qand_rest))
rest = 1;
else if (EQ (next, Qand_optional))
i = nargs;
}
else if (i < nargs)
- {
- tem = arg_vector[i++];
- specbind (next, tem);
- }
+ specbind (next, arg_vector[i++]);
else if (!optional)
- return Fsignal (Qwrong_number_of_arguments, Fcons (fun, Fcons (numargs, Qnil)));
+ return Fsignal (Qwrong_number_of_arguments,
+ Fcons (fun, Fcons (make_number (nargs), Qnil)));
else
specbind (next, Qnil);
}
- if (i < nargs)
- return Fsignal (Qwrong_number_of_arguments, Fcons (fun, Fcons (numargs, Qnil)));
+ if (!NILP (syms_left))
+ return Fsignal (Qinvalid_function, Fcons (fun, Qnil));
+ else if (i < nargs)
+ return Fsignal (Qwrong_number_of_arguments,
+ Fcons (fun, Fcons (make_number (nargs), Qnil)));
if (CONSP (fun))
- val = Fprogn (Fcdr (Fcdr (fun)));
+ val = Fprogn (XCDR (XCDR (fun)));
else
{
/* If we have not actually read the bytecode string
XVECTOR (fun)->contents[COMPILED_CONSTANTS],
XVECTOR (fun)->contents[COMPILED_STACK_DEPTH]);
}
+
return unbind_to (count, val);
}
Lisp_Object ovalue;
CHECK_SYMBOL (symbol, 0);
-
if (specpdl_ptr == specpdl + specpdl_size)
grow_specpdl ();
- specpdl_ptr->symbol = symbol;
- specpdl_ptr->func = 0;
- specpdl_ptr->old_value = ovalue = find_symbol_value (symbol);
- specpdl_ptr++;
- if (BUFFER_OBJFWDP (ovalue) || KBOARD_OBJFWDP (ovalue))
- store_symval_forwarding (symbol, ovalue, value);
+
+ /* The most common case is that a non-constant symbol with a trivial
+ value. Make that as fast as we can. */
+ if (!MISCP (XSYMBOL (symbol)->value)
+ && !EQ (symbol, Qnil)
+ && !EQ (symbol, Qt)
+ && !(XSYMBOL (symbol)->name->data[0] == ':'
+ && EQ (XSYMBOL (symbol)->obarray, initial_obarray)
+ && !EQ (value, symbol)))
+ {
+ specpdl_ptr->symbol = symbol;
+ specpdl_ptr->old_value = XSYMBOL (symbol)->value;
+ specpdl_ptr->func = NULL;
+ ++specpdl_ptr;
+ XSYMBOL (symbol)->value = value;
+ }
else
- set_internal (symbol, value, 1);
+ {
+ ovalue = find_symbol_value (symbol);
+ specpdl_ptr->func = 0;
+ specpdl_ptr->old_value = ovalue;
+
+ if (BUFFER_LOCAL_VALUEP (XSYMBOL (symbol)->value)
+ || SOME_BUFFER_LOCAL_VALUEP (XSYMBOL (symbol)->value)
+ || BUFFER_OBJFWDP (XSYMBOL (symbol)->value))
+ {
+ Lisp_Object current_buffer, binding_buffer;
+ /* For a local variable, record both the symbol and which
+ buffer's value we are saving. */
+ current_buffer = Fcurrent_buffer ();
+ binding_buffer = current_buffer;
+ /* If the variable is not local in this buffer,
+ we are saving the global value, so restore that. */
+ if (NILP (Flocal_variable_p (symbol, binding_buffer)))
+ binding_buffer = Qnil;
+ specpdl_ptr->symbol
+ = Fcons (symbol, Fcons (binding_buffer, current_buffer));
+ }
+ else
+ specpdl_ptr->symbol = symbol;
+
+ specpdl_ptr++;
+ if (BUFFER_OBJFWDP (ovalue) || KBOARD_OBJFWDP (ovalue))
+ store_symval_forwarding (symbol, ovalue, value);
+ else
+ set_internal (symbol, value, 0, 1);
+ }
}
void
struct gcpro gcpro1;
GCPRO1 (value);
-
Vquit_flag = Qnil;
while (specpdl_ptr != specpdl + count)
{
--specpdl_ptr;
+
if (specpdl_ptr->func != 0)
(*specpdl_ptr->func) (specpdl_ptr->old_value);
/* Note that a "binding" of nil is really an unwind protect,
- so in that case the "old value" is a list of forms to evaluate. */
+ so in that case the "old value" is a list of forms to evaluate. */
else if (NILP (specpdl_ptr->symbol))
Fprogn (specpdl_ptr->old_value);
+ /* If the symbol is a list, it is really
+ (SYMBOL BINDING_BUFFER . CURRENT_BUFFER)
+ and it indicates we bound a variable that has
+ buffer-local bindings. */
+ else if (CONSP (specpdl_ptr->symbol))
+ {
+ Lisp_Object symbol, buffer;
+
+ symbol = XCAR (specpdl_ptr->symbol);
+ buffer = XCAR (XCDR (specpdl_ptr->symbol));
+
+ /* Handle restoring a default value. */
+ if (NILP (buffer))
+ Fset_default (symbol, specpdl_ptr->old_value);
+ /* Handle restoring a value saved from a live buffer. */
+ else
+ set_internal (symbol, specpdl_ptr->old_value, XBUFFER (buffer), 1);
+ }
else
- set_internal (specpdl_ptr->symbol, specpdl_ptr->old_value, 1);
+ {
+ /* If variable has a trivial value (no forwarding), we can
+ just set it. No need to check for constant symbols here,
+ since that was already done by specbind. */
+ if (!MISCP (XSYMBOL (specpdl_ptr->symbol)->value))
+ XSYMBOL (specpdl_ptr->symbol)->value = specpdl_ptr->old_value;
+ else
+ set_internal (specpdl_ptr->symbol, specpdl_ptr->old_value, 0, 1);
+ }
}
- if (NILP (Vquit_flag) && quitf) Vquit_flag = Qt;
+
+ if (NILP (Vquit_flag) && quitf)
+ Vquit_flag = Qt;
UNGCPRO;
-
return value;
}
\f
return Fcons (Qt, Fcons (*backlist->function, tem));
}
}
+
\f
void
syms_of_eval ()
DEFVAR_BOOL ("debug-on-next-call", &debug_on_next_call,
"Non-nil means enter debugger before next `eval', `apply' or `funcall'.");
+ DEFVAR_BOOL ("debugger-may-continue", &debugger_may_continue,
+ "Non-nil means debugger may continue execution.\n\
+This is nil when the debugger is called under circumstances where it\n\
+might not be safe to continue.");
+ debugger_may_continue = 1;
+
DEFVAR_LISP ("debugger", &Vdebugger,
"Function to call to invoke debugger.\n\
If due to frame exit, args are `exit' and the value being returned;\n\
staticpro (&Vautoload_queue);
Vautoload_queue = Qnil;
+ staticpro (&Vsignaling_function);
+ Vsignaling_function = Qnil;
defsubr (&Sor);
defsubr (&Sand);
HCoop / bpt / emacs.git / blobdiff