1 files changed, 200 insertions, 356 deletions

diff --git a/src/eval.c b/src/eval.c
index 15112d8659b..d0effc755a2 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -1,7 +1,5 @@
 /* Evaluator for GNU Emacs Lisp interpreter.
-   Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1999, 2000, 2001,
-                 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
-                 Free Software Foundation, Inc.
+   Copyright (C) 1985-1987, 1993-1995, 1999-2011  Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -58,7 +56,7 @@ int gcpro_level;
 #endif
 
 Lisp_Object Qautoload, Qmacro, Qexit, Qinteractive, Qcommandp, Qdefun;
-Lisp_Object Qinhibit_quit, Vinhibit_quit, Vquit_flag;
+Lisp_Object Qinhibit_quit;
 Lisp_Object Qand_rest, Qand_optional;
 Lisp_Object Qdebug_on_error;
 Lisp_Object Qdeclare;
@@ -89,56 +87,10 @@ struct specbinding *specpdl;
 
 struct specbinding *specpdl_ptr;
 
-/* Maximum size allowed for specpdl allocation */
-
-EMACS_INT max_specpdl_size;
-
 /* Depth in Lisp evaluations and function calls.  */
 
 EMACS_INT lisp_eval_depth;
 
-/* Maximum allowed depth in Lisp evaluations and function calls.  */
-
-EMACS_INT max_lisp_eval_depth;
-
-/* Nonzero means enter debugger before next function call */
-
-int debug_on_next_call;
-
-/* Non-zero means debugger 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_error 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
    started to enter the debugger.  If we decide to enter the debugger
    again when this is still equal to num_nonmacro_input_events, then we
@@ -148,8 +100,6 @@ int debug_on_quit;
 
 int when_entered_debugger;
 
-Lisp_Object Vdebugger;
-
 /* The function from which the last `signal' was called.  Set in
    Fsignal.  */
 
@@ -161,12 +111,10 @@ Lisp_Object Vsignaling_function;
 
 int handling_signal;
 
-/* Function to process declarations in defmacro forms.  */
-
-Lisp_Object Vmacro_declaration_function;
-
 static Lisp_Object funcall_lambda (Lisp_Object, int, Lisp_Object*);
 static void unwind_to_catch (struct catchtag *, Lisp_Object) NO_RETURN;
+static int interactive_p (int);
+static Lisp_Object apply_lambda (Lisp_Object, Lisp_Object, int);
 
 void
 init_eval_once (void)
@@ -176,7 +124,7 @@ init_eval_once (void)
   specpdl_ptr = specpdl;
   /* Don't forget to update docs (lispref node "Local Variables").  */
   max_specpdl_size = 1000;
-  max_lisp_eval_depth = 500;
+  max_lisp_eval_depth = 600;
 
   Vrun_hooks = Qnil;
 }
@@ -581,7 +529,7 @@ way to do this), or via (not (or executing-kbd-macro noninteractive)).  */)
     EXCLUDE_SUBRS_P non-zero means always return 0 if the function
     called is a built-in.  */
 
-int
+static int
 interactive_p (int exclude_subrs_p)
 {
   struct backtrace *btp;
@@ -1609,6 +1557,8 @@ internal_condition_case_n (Lisp_Object (*bfun) (int, Lisp_Object*),
 
 static Lisp_Object find_handler_clause (Lisp_Object, Lisp_Object,
                                         Lisp_Object, Lisp_Object);
+static int maybe_call_debugger (Lisp_Object conditions, Lisp_Object sig,
+                                Lisp_Object data);
 
 DEFUN ("signal", Fsignal, Ssignal, 2, 2, 0,
        doc: /* Signal an error.  Args are ERROR-SYMBOL and associated DATA.
@@ -1629,10 +1579,12 @@ See also the function `condition-case'.  */)
   /* When memory is full, ERROR-SYMBOL is nil,
      and DATA is (REAL-ERROR-SYMBOL . REAL-DATA).
      That is a special case--don't do this in other situations.  */
-  register struct handler *allhandlers = handlerlist;
   Lisp_Object conditions;
   Lisp_Object string;
-  Lisp_Object real_error_symbol;
+  Lisp_Object real_error_symbol
+    = (NILP (error_symbol) ? Fcar (data) : error_symbol);
+  register Lisp_Object clause = Qnil;
+  struct handler *h;
   struct backtrace *bp;
 
   immediate_quit = handling_signal = 0;
@@ -1640,11 +1592,6 @@ See also the function `condition-case'.  */)
   if (gc_in_progress || waiting_for_input)
     abort ();
 
-  if (NILP (error_symbol))
-    real_error_symbol = Fcar (data);
-  else
-    real_error_symbol = error_symbol;
-
 #if 0 /* rms: I don't know why this was here,
          but it is surely wrong for an error that is handled.  */
 #ifdef HAVE_WINDOW_SYSTEM
@@ -1683,49 +1630,49 @@ See also the function `condition-case'.  */)
         Vsignaling_function = *bp->function;
     }
 
-  for (; handlerlist; handlerlist = handlerlist->next)
+  for (h = handlerlist; h; h = h->next)
     {
-      register Lisp_Object clause;
-
-      clause = find_handler_clause (handlerlist->handler, conditions,
+      clause = find_handler_clause (h->handler, conditions,
                                     error_symbol, data);
-
-      if (EQ (clause, Qlambda))
-        {
-          /* We can't return values to code which signaled an error, but we
-             can continue code which has signaled a quit.  */
-          if (EQ (real_error_symbol, Qquit))
-            return Qnil;
-          else
-            error ("Cannot return from the debugger in an error");
-        }
-
       if (!NILP (clause))
-        {
-          Lisp_Object unwind_data;
-          struct handler *h = handlerlist;
-
-          handlerlist = allhandlers;
-
-          if (NILP (error_symbol))
-            unwind_data = data;
-          else
-            unwind_data = Fcons (error_symbol, data);
-          h->chosen_clause = clause;
-          unwind_to_catch (h->tag, unwind_data);
-        }
+        break;
     }
+          
+  if (/* Don't run the debugger for a memory-full error.
+         (There is no room in memory to do that!) */
+      !NILP (error_symbol)
+      && (!NILP (Vdebug_on_signal)
+          /* If no handler is present now, try to run the debugger.  */
+          || NILP (clause)
+          /* Special handler that means "print a message and run debugger
+             if requested".  */
+          || EQ (h->handler, Qerror)))
+    {
+      int debugger_called
+        = maybe_call_debugger (conditions, error_symbol, data);
+      /* We can't return values to code which signaled an error, but we
+         can continue code which has signaled a quit.  */
+      if (debugger_called && EQ (real_error_symbol, Qquit))
+        return Qnil;
+    }      
 
-  handlerlist = allhandlers;
-  /* If no handler is present now, try to run the debugger,
-     and if that fails, throw to top level.  */
-  find_handler_clause (Qerror, conditions, error_symbol, data);
-  if (catchlist != 0)
-    Fthrow (Qtop_level, Qt);
+  if (!NILP (clause))
+    {
+      Lisp_Object unwind_data
+        = (NILP (error_symbol) ? data : Fcons (error_symbol, data));
+      
+      h->chosen_clause = clause;
+      unwind_to_catch (h->tag, unwind_data);
+    }
+  else
+    {
+      if (catchlist != 0)
+        Fthrow (Qtop_level, Qt);
+    }
 
   if (! NILP (error_symbol))
     data = Fcons (error_symbol, data);
-
+      
   string = Ferror_message_string (data);
   fatal ("%s", SDATA (string), 0);
 }
@@ -1900,63 +1847,24 @@ find_handler_clause (Lisp_Object handlers, Lisp_Object conditions,
                      Lisp_Object sig, Lisp_Object data)
 {
   register Lisp_Object h;
-  register Lisp_Object tem;
-  int debugger_called = 0;
-  int debugger_considered = 0;
 
   /* t is used by handlers for all conditions, set up by C code.  */
   if (EQ (handlers, Qt))
     return Qt;
 
-  /* Don't run the debugger for a memory-full error.
-     (There is no room in memory to do that!)  */
-  if (NILP (sig))
-    debugger_considered = 1;
-
   /* error is used similarly, but means print an error message
      and run the debugger if that is enabled.  */
-  if (EQ (handlers, Qerror)
-      || !NILP (Vdebug_on_signal)) /* This says call debugger even if
-                                      there is a handler.  */
-    {
-      if (!NILP (sig) && wants_debugger (Vstack_trace_on_error, conditions))
-        {
-          max_lisp_eval_depth += 15;
-          max_specpdl_size++;
-          if (noninteractive)
-            Fbacktrace ();
-          else
-            internal_with_output_to_temp_buffer
-              ("*Backtrace*",
-               (Lisp_Object (*) (Lisp_Object)) Fbacktrace,
-               Qnil);
-          max_specpdl_size--;
-          max_lisp_eval_depth -= 15;
-        }
-
-      if (!debugger_considered)
-        {
-          debugger_considered = 1;
-          debugger_called = maybe_call_debugger (conditions, sig, data);
-        }
-
-      /* If there is no handler, return saying whether we ran the debugger.  */
-      if (EQ (handlers, Qerror))
-        {
-          if (debugger_called)
-            return Qlambda;
-          return Qt;
-        }
-    }
+  if (EQ (handlers, Qerror))
+    return Qt;
 
-  for (h = handlers; CONSP (h); h = Fcdr (h))
+  for (h = handlers; CONSP (h); h = XCDR (h))
     {
-      Lisp_Object handler, condit;
+      Lisp_Object handler = XCAR (h);
+      Lisp_Object condit, tem;
 
-      handler = Fcar (h);
       if (!CONSP (handler))
         continue;
-      condit = Fcar (handler);
+      condit = XCAR (handler);
       /* Handle a single condition name in handler HANDLER.  */
       if (SYMBOLP (condit))
         {
@@ -1970,15 +1878,9 @@ find_handler_clause (Lisp_Object handlers, Lisp_Object conditions,
           Lisp_Object tail;
           for (tail = condit; CONSP (tail); tail = XCDR (tail))
             {
-              tem = Fmemq (Fcar (tail), conditions);
+              tem = Fmemq (XCAR (tail), conditions);
               if (!NILP (tem))
-                {
-                  /* This handler is going to apply.
-                     Does it allow the debugger to run first?  */
-                  if (! debugger_considered && !NILP (Fmemq (Qdebug, condit)))
-                    maybe_call_debugger (conditions, sig, data);
-                  return handler;
-                }
+                return handler;
             }
         }
     }
@@ -1995,7 +1897,6 @@ verror (const char *m, va_list ap)
   EMACS_INT size = 200;
   int mlen;
   char *buffer = buf;
-  char *args[3];
   int allocated = 0;
   Lisp_Object string;
 
@@ -2291,14 +2192,12 @@ DEFUN ("eval", Feval, Seval, 1, 1, 0,
           (XSUBR (fun)->max_args >= 0 && XSUBR (fun)->max_args < XINT (numargs)))
         xsignal2 (Qwrong_number_of_arguments, original_fun, numargs);
 
-      if (XSUBR (fun)->max_args == UNEVALLED)
+      else if (XSUBR (fun)->max_args == UNEVALLED)
         {
           backtrace.evalargs = 0;
           val = (XSUBR (fun)->function.aUNEVALLED) (args_left);
-          goto done;
         }
-
-      if (XSUBR (fun)->max_args == MANY)
+      else if (XSUBR (fun)->max_args == MANY)
         {
           /* Pass a vector of evaluated arguments */
           Lisp_Object *vals;
@@ -2324,73 +2223,76 @@ DEFUN ("eval", Feval, Seval, 1, 1, 0,
           val = (XSUBR (fun)->function.aMANY) (XINT (numargs), vals);
           UNGCPRO;
           SAFE_FREE ();
-          goto done;
         }
-
-      GCPRO3 (args_left, fun, fun);
-      gcpro3.var = argvals;
-      gcpro3.nvars = 0;
-
-      maxargs = XSUBR (fun)->max_args;
-      for (i = 0; i < maxargs; args_left = Fcdr (args_left))
+      else
         {
-          argvals[i] = Feval (Fcar (args_left));
-          gcpro3.nvars = ++i;
-        }
+          GCPRO3 (args_left, fun, fun);
+          gcpro3.var = argvals;
+          gcpro3.nvars = 0;
 
-      UNGCPRO;
+          maxargs = XSUBR (fun)->max_args;
+          for (i = 0; i < maxargs; args_left = Fcdr (args_left))
+            {
+              argvals[i] = Feval (Fcar (args_left));
+              gcpro3.nvars = ++i;
+            }
 
-      backtrace.args = argvals;
-      backtrace.nargs = XINT (numargs);
+          UNGCPRO;
 
-      switch (i)
-        {
-        case 0:
-          val = (XSUBR (fun)->function.a0) ();
-          goto done;
-        case 1:
-          val = (XSUBR (fun)->function.a1) (argvals[0]);
-          goto done;
-        case 2:
-          val = (XSUBR (fun)->function.a2) (argvals[0], argvals[1]);
-          goto done;
-        case 3:
-          val = (XSUBR (fun)->function.a3) (argvals[0], argvals[1],
-                                            argvals[2]);
-          goto done;
-        case 4:
-          val = (XSUBR (fun)->function.a4) (argvals[0], argvals[1],
-                                            argvals[2], argvals[3]);
-          goto done;
-        case 5:
-          val = (XSUBR (fun)->function.a5) (argvals[0], argvals[1], argvals[2],
-                                            argvals[3], argvals[4]);
-          goto done;
-        case 6:
-          val = (XSUBR (fun)->function.a6) (argvals[0], argvals[1], argvals[2],
-                                            argvals[3], argvals[4], argvals[5]);
-          goto done;
-        case 7:
-          val = (XSUBR (fun)->function.a7) (argvals[0], argvals[1], argvals[2],
-                                            argvals[3], argvals[4], argvals[5],
-                                            argvals[6]);
-          goto done;
-
-        case 8:
-          val = (XSUBR (fun)->function.a8) (argvals[0], argvals[1], argvals[2],
-                                            argvals[3], argvals[4], argvals[5],
-                                            argvals[6], argvals[7]);
-          goto done;
-
-        default:
-          /* Someone has created a subr that takes more arguments than
-             is supported by this code.  We need to either rewrite the
-             subr to use a different argument protocol, or add more
-             cases to this switch.  */
-          abort ();
+          backtrace.args = argvals;
+          backtrace.nargs = XINT (numargs);
+
+          switch (i)
+            {
+            case 0:
+              val = (XSUBR (fun)->function.a0 ());
+              break;
+            case 1:
+              val = (XSUBR (fun)->function.a1 (argvals[0]));
+              break;
+            case 2:
+              val = (XSUBR (fun)->function.a2 (argvals[0], argvals[1]));
+              break;
+            case 3:
+              val = (XSUBR (fun)->function.a3
+                     (argvals[0], argvals[1], argvals[2]));
+              break;
+            case 4:
+              val = (XSUBR (fun)->function.a4
+                     (argvals[0], argvals[1], argvals[2], argvals[3]));
+              break;
+            case 5:
+              val = (XSUBR (fun)->function.a5
+                     (argvals[0], argvals[1], argvals[2], argvals[3],
+                      argvals[4]));
+              break;
+            case 6:
+              val = (XSUBR (fun)->function.a6
+                     (argvals[0], argvals[1], argvals[2], argvals[3],
+                      argvals[4], argvals[5]));
+              break;
+            case 7:
+              val = (XSUBR (fun)->function.a7
+                     (argvals[0], argvals[1], argvals[2], argvals[3],
+                      argvals[4], argvals[5], argvals[6]));
+              break;
+
+            case 8:
+              val = (XSUBR (fun)->function.a8
+                     (argvals[0], argvals[1], argvals[2], argvals[3],
+                      argvals[4], argvals[5], argvals[6], argvals[7]));
+              break;
+
+            default:
+              /* Someone has created a subr that takes more arguments than
+                 is supported by this code.  We need to either rewrite the
+                 subr to use a different argument protocol, or add more
+                 cases to this switch.  */
+              abort ();
+            }
         }
     }
-  if (COMPILEDP (fun))
+  else if (COMPILEDP (fun))
     val = apply_lambda (fun, original_args, 1);
   else
     {
@@ -2413,7 +2315,6 @@ DEFUN ("eval", Feval, Seval, 1, 1, 0,
       else
         xsignal1 (Qinvalid_function, original_fun);
     }
- done:
   CHECK_CONS_LIST ();
 
   lisp_eval_depth--;
@@ -2685,53 +2586,6 @@ run_hook_with_args (int nargs, Lisp_Object *args, enum run_hooks_condition cond)
     }
 }
 
-/* Run a hook symbol ARGS[0], but use FUNLIST instead of the actual
-   present value of that symbol.
-   Call each element of FUNLIST,
-   passing each of them the rest of ARGS.
-   The caller (or its caller, etc) must gcpro all of ARGS,
-   except that it isn't necessary to gcpro ARGS[0].  */
-
-Lisp_Object
-run_hook_list_with_args (Lisp_Object funlist, int nargs, Lisp_Object *args)
-{
-  Lisp_Object sym;
-  Lisp_Object val;
-  Lisp_Object globals;
-  struct gcpro gcpro1, gcpro2, gcpro3;
-
-  sym = args[0];
-  globals = Qnil;
-  GCPRO3 (sym, val, globals);
-
-  for (val = funlist; CONSP (val); val = XCDR (val))
-    {
-      if (EQ (XCAR (val), Qt))
-        {
-          /* t indicates this hook has a local binding;
-             it means to run the global binding too.  */
-
-          for (globals = Fdefault_value (sym);
-               CONSP (globals);
-               globals = XCDR (globals))
-            {
-              args[0] = XCAR (globals);
-              /* In a global value, t should not occur.  If it does, we
-                 must ignore it to avoid an endless loop.  */
-              if (!EQ (args[0], Qt))
-                Ffuncall (nargs, args);
-            }
-        }
-      else
-        {
-          args[0] = XCAR (val);
-          Ffuncall (nargs, args);
-        }
-    }
-  UNGCPRO;
-  return Qnil;
-}
-
 /* Run the hook HOOK, giving each function the two args ARG1 and ARG2.  */
 
 void
@@ -2956,83 +2810,84 @@ usage: (funcall FUNCTION &rest ARGUMENTS)  */)
 
   if (SUBRP (fun))
     {
-       if (numargs < XSUBR (fun)->min_args
+      if (numargs < XSUBR (fun)->min_args
           || (XSUBR (fun)->max_args >= 0 && XSUBR (fun)->max_args < numargs))
         {
           XSETFASTINT (lisp_numargs, numargs);
           xsignal2 (Qwrong_number_of_arguments, original_fun, lisp_numargs);
         }
 
-      if (XSUBR (fun)->max_args == UNEVALLED)
+      else if (XSUBR (fun)->max_args == UNEVALLED)
         xsignal1 (Qinvalid_function, original_fun);
 
-      if (XSUBR (fun)->max_args == MANY)
-        {
-          val = (XSUBR (fun)->function.aMANY) (numargs, args + 1);
-          goto done;
-        }
-
-      if (XSUBR (fun)->max_args > numargs)
-        {
-          internal_args = (Lisp_Object *) alloca (XSUBR (fun)->max_args * sizeof (Lisp_Object));
-          memcpy (internal_args, args + 1, numargs * sizeof (Lisp_Object));
-          for (i = numargs; i < XSUBR (fun)->max_args; i++)
-            internal_args[i] = Qnil;
-        }
+      else if (XSUBR (fun)->max_args == MANY)
+        val = (XSUBR (fun)->function.aMANY) (numargs, args + 1);
       else
-        internal_args = args + 1;
-      switch (XSUBR (fun)->max_args)
         {
-        case 0:
-          val = (XSUBR (fun)->function.a0) ();
-          goto done;
-        case 1:
-          val = (XSUBR (fun)->function.a1) (internal_args[0]);
-          goto done;
-        case 2:
-          val = (XSUBR (fun)->function.a2) (internal_args[0], internal_args[1]);
-          goto done;
-        case 3:
-          val = (XSUBR (fun)->function.a3) (internal_args[0], internal_args[1],
-                                            internal_args[2]);
-          goto done;
-        case 4:
-          val = (XSUBR (fun)->function.a4) (internal_args[0], internal_args[1],
-                                            internal_args[2], internal_args[3]);
-          goto done;
-        case 5:
-          val = (XSUBR (fun)->function.a5) (internal_args[0], internal_args[1],
-                                            internal_args[2], internal_args[3],
-                                            internal_args[4]);
-          goto done;
-        case 6:
-          val = (XSUBR (fun)->function.a6) (internal_args[0], internal_args[1],
-                                            internal_args[2], internal_args[3],
-                                            internal_args[4], internal_args[5]);
-          goto done;
-        case 7:
-          val = (XSUBR (fun)->function.a7) (internal_args[0], internal_args[1],
-                                            internal_args[2], internal_args[3],
-                                            internal_args[4], internal_args[5],
-                                            internal_args[6]);
-          goto done;
-
-        case 8:
-          val = (XSUBR (fun)->function.a8) (internal_args[0], internal_args[1],
-                                            internal_args[2], internal_args[3],
-                                            internal_args[4], internal_args[5],
-                                            internal_args[6], internal_args[7]);
-          goto done;
-
-        default:
-
-          /* If a subr takes more than 8 arguments without using MANY
-             or UNEVALLED, we need to extend this function to support it.
-             Until this is done, there is no way to call the function.  */
-          abort ();
+          if (XSUBR (fun)->max_args > numargs)
+            {
+              internal_args = (Lisp_Object *) alloca (XSUBR (fun)->max_args * sizeof (Lisp_Object));
+              memcpy (internal_args, args + 1, numargs * sizeof (Lisp_Object));
+              for (i = numargs; i < XSUBR (fun)->max_args; i++)
+                internal_args[i] = Qnil;
+            }
+          else
+            internal_args = args + 1;
+          switch (XSUBR (fun)->max_args)
+            {
+            case 0:
+              val = (XSUBR (fun)->function.a0 ());
+              break;
+            case 1:
+              val = (XSUBR (fun)->function.a1 (internal_args[0]));
+              break;
+            case 2:
+              val = (XSUBR (fun)->function.a2
+                     (internal_args[0], internal_args[1]));
+              break;
+            case 3:
+              val = (XSUBR (fun)->function.a3
+                     (internal_args[0], internal_args[1], internal_args[2]));
+              break;
+            case 4:
+              val = (XSUBR (fun)->function.a4
+                     (internal_args[0], internal_args[1], internal_args[2],
+                     internal_args[3]));
+              break;
+            case 5:
+              val = (XSUBR (fun)->function.a5
+                     (internal_args[0], internal_args[1], internal_args[2],
+                      internal_args[3], internal_args[4]));
+              break;
+            case 6:
+              val = (XSUBR (fun)->function.a6
+                     (internal_args[0], internal_args[1], internal_args[2],
+                      internal_args[3], internal_args[4], internal_args[5]));
+              break;
+            case 7:
+              val = (XSUBR (fun)->function.a7
+                     (internal_args[0], internal_args[1], internal_args[2],
+                      internal_args[3], internal_args[4], internal_args[5],
+                      internal_args[6]));
+              break;
+
+            case 8:
+              val = (XSUBR (fun)->function.a8
+                     (internal_args[0], internal_args[1], internal_args[2],
+                      internal_args[3], internal_args[4], internal_args[5],
+                      internal_args[6], internal_args[7]));
+              break;
+
+            default:
+
+              /* If a subr takes more than 8 arguments without using MANY
+                 or UNEVALLED, we need to extend this function to support it.
+                 Until this is done, there is no way to call the function.  */
+              abort ();
+            }
         }
     }
-  if (COMPILEDP (fun))
+  else if (COMPILEDP (fun))
     val = funcall_lambda (fun, numargs, args + 1);
   else
     {
@@ -3054,7 +2909,6 @@ usage: (funcall FUNCTION &rest ARGUMENTS)  */)
       else
         xsignal1 (Qinvalid_function, original_fun);
     }
- done:
   CHECK_CONS_LIST ();
   lisp_eval_depth--;
   if (backtrace.debug_on_exit)
@@ -3063,7 +2917,7 @@ usage: (funcall FUNCTION &rest ARGUMENTS)  */)
   return val;
 }
 
-Lisp_Object
+static Lisp_Object
 apply_lambda (Lisp_Object fun, Lisp_Object args, int eval_flag)
 {
   Lisp_Object args_left;
@@ -3550,7 +3404,7 @@ mark_backtrace (void)
 void
 syms_of_eval (void)
 {
-  DEFVAR_INT ("max-specpdl-size", &max_specpdl_size,
+  DEFVAR_INT ("max-specpdl-size", max_specpdl_size,
               doc: /* *Limit on number of Lisp variable bindings and `unwind-protect's.
 If Lisp code tries to increase the total number past this amount,
 an error is signaled.
@@ -3558,7 +3412,7 @@ You can safely use a value considerably larger than the default value,
 if that proves inconveniently small.  However, if you increase it too far,
 Emacs could run out of memory trying to make the stack bigger.  */);
 
-  DEFVAR_INT ("max-lisp-eval-depth", &max_lisp_eval_depth,
+  DEFVAR_INT ("max-lisp-eval-depth", max_lisp_eval_depth,
               doc: /* *Limit on depth in `eval', `apply' and `funcall' before error.
 
 This limit serves to catch infinite recursions for you before they cause
@@ -3567,7 +3421,7 @@ You can safely make it considerably larger than its default value,
 if that proves inconveniently small.  However, if you increase it too far,
 Emacs could overflow the real C stack, and crash.  */);
 
-  DEFVAR_LISP ("quit-flag", &Vquit_flag,
+  DEFVAR_LISP ("quit-flag", Vquit_flag,
                doc: /* Non-nil causes `eval' to abort, unless `inhibit-quit' is non-nil.
 If the value is t, that means do an ordinary quit.
 If the value equals `throw-on-input', that means quit by throwing
@@ -3576,7 +3430,7 @@ Typing C-g sets `quit-flag' to t, regardless of `inhibit-quit',
 but `inhibit-quit' non-nil prevents anything from taking notice of that.  */);
   Vquit_flag = Qnil;
 
-  DEFVAR_LISP ("inhibit-quit", &Vinhibit_quit,
+  DEFVAR_LISP ("inhibit-quit", Vinhibit_quit,
                doc: /* Non-nil inhibits C-g quitting from happening immediately.
 Note that `quit-flag' will still be set by typing C-g,
 so a quit will be signaled as soon as `inhibit-quit' is nil.
@@ -3622,15 +3476,7 @@ before making `inhibit-quit' nil.  */);
   Qdebug = intern_c_string ("debug");
   staticpro (&Qdebug);
 
-  DEFVAR_LISP ("stack-trace-on-error", &Vstack_trace_on_error,
-               doc: /* *Non-nil means errors display a backtrace buffer.
-More precisely, this happens for any error that is handled
-by the editor command loop.
-If the value is a list, an error only means to display a backtrace
-if one of its condition symbols appears in the list.  */);
-  Vstack_trace_on_error = Qnil;
-
-  DEFVAR_LISP ("debug-on-error", &Vdebug_on_error,
+  DEFVAR_LISP ("debug-on-error", Vdebug_on_error,
                doc: /* *Non-nil means enter debugger if an error is signaled.
 Does not apply to errors handled by `condition-case' or those
 matched by `debug-ignored-errors'.
@@ -3642,7 +3488,7 @@ The command `toggle-debug-on-error' toggles this.
 See also the variable `debug-on-quit'.  */);
   Vdebug_on_error = Qnil;
 
-  DEFVAR_LISP ("debug-ignored-errors", &Vdebug_ignored_errors,
+  DEFVAR_LISP ("debug-ignored-errors", Vdebug_ignored_errors,
     doc: /* *List of errors for which the debugger should not be called.
 Each element may be a condition-name or a regexp that matches error messages.
 If any element applies to a given error, that error skips the debugger
@@ -3651,21 +3497,21 @@ This overrides the variable `debug-on-error'.
 It does not apply to errors handled by `condition-case'.  */);
   Vdebug_ignored_errors = Qnil;
 
-  DEFVAR_BOOL ("debug-on-quit", &debug_on_quit,
+  DEFVAR_BOOL ("debug-on-quit", debug_on_quit,
     doc: /* *Non-nil means enter debugger if quit is signaled (C-g, for example).
 Does not apply if quit is handled by a `condition-case'.  */);
   debug_on_quit = 0;
 
-  DEFVAR_BOOL ("debug-on-next-call", &debug_on_next_call,
+  DEFVAR_BOOL ("debug-on-next-call", debug_on_next_call,
                doc: /* Non-nil means enter debugger before next `eval', `apply' or `funcall'.  */);
 
-  DEFVAR_BOOL ("debugger-may-continue", &debugger_may_continue,
+  DEFVAR_BOOL ("debugger-may-continue", debugger_may_continue,
                doc: /* Non-nil means debugger may continue execution.
 This is nil when the debugger is called under circumstances where it
 might not be safe to continue.  */);
   debugger_may_continue = 1;
 
-  DEFVAR_LISP ("debugger", &Vdebugger,
+  DEFVAR_LISP ("debugger", Vdebugger,
                doc: /* Function to call to invoke debugger.
 If due to frame exit, args are `exit' and the value being returned;
  this function's value will be returned instead of that.
@@ -3674,19 +3520,19 @@ If due to `apply' or `funcall' entry, one arg, `lambda'.
 If due to `eval' entry, one arg, t.  */);
   Vdebugger = Qnil;
 
-  DEFVAR_LISP ("signal-hook-function", &Vsignal_hook_function,
+  DEFVAR_LISP ("signal-hook-function", Vsignal_hook_function,
                doc: /* If non-nil, this is a function for `signal' to call.
 It receives the same arguments that `signal' was given.
 The Edebug package uses this to regain control.  */);
   Vsignal_hook_function = Qnil;
 
-  DEFVAR_LISP ("debug-on-signal", &Vdebug_on_signal,
+  DEFVAR_LISP ("debug-on-signal", Vdebug_on_signal,
                doc: /* *Non-nil means call the debugger regardless of condition handlers.
 Note that `debug-on-error', `debug-on-quit' and friends
 still determine whether to handle the particular condition.  */);
   Vdebug_on_signal = Qnil;
 
-  DEFVAR_LISP ("macro-declaration-function", &Vmacro_declaration_function,
+  DEFVAR_LISP ("macro-declaration-function", Vmacro_declaration_function,
                doc: /* Function to process declarations in a macro definition.
 The function will be called with two args MACRO and DECL.
 MACRO is the name of the macro being defined.
@@ -3744,5 +3590,3 @@ The value the function returns is not used.  */);
   defsubr (&Sbacktrace_frame);
 }
 
-/* arch-tag: 014a07aa-33ab-4a8f-a3d2-ee8a4a9ff7fb
-   (do not change this comment) */