[Emacs-diffs] Changes to emacs/src/eval.c

[Richard M . Stallman]

Index: emacs/src/eval.c
diff -c emacs/src/eval.c:1.243 emacs/src/eval.c:1.244
*** emacs/src/eval.c:1.243      Thu Jun 23 16:07:51 2005
--- emacs/src/eval.c    Sat Jun 25 14:37:47 2005
***************
*** 227,232 ****
--- 227,244 ----
    when_entered_debugger = -1;
  }
  
+ /* unwind-protect function used by call_debugger.  */
+ 
+ static Lisp_Object
+ restore_stack_limits (data)
+      Lisp_Object data;
+ {
+   max_specpdl_size = XINT (XCAR (data));
+   max_lisp_eval_depth = XINT (XCDR (data));
+ }
+ 
+ /* Call the Lisp debugger, giving it argument ARG.  */
+ 
  Lisp_Object
  call_debugger (arg)
       Lisp_Object arg;
***************
*** 234,245 ****
    int debug_while_redisplaying;
    int count = SPECPDL_INDEX ();
    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_hourglass_p)
--- 246,267 ----
    int debug_while_redisplaying;
    int count = SPECPDL_INDEX ();
    Lisp_Object val;
+   int old_max = max_specpdl_size;
  
!   /* Temporarily bump up the stack limits,
!      so the debugger won't run out of stack.  */
  
!   max_specpdl_size += 1;
!   record_unwind_protect (restore_stack_limits,
!                        Fcons (make_number (old_max),
!                               make_number (max_lisp_eval_depth)));
!   max_specpdl_size = old_max;
! 
!   if (lisp_eval_depth + 40 > max_lisp_eval_depth)
!     max_lisp_eval_depth = lisp_eval_depth + 40;
! 
!   if (SPECPDL_INDEX () + 100 > max_specpdl_size)
!     max_specpdl_size = SPECPDL_INDEX () + 100;
  
  #ifdef HAVE_X_WINDOWS
    if (display_hourglass_p)
***************
*** 256,261 ****
--- 278,284 ----
    specbind (intern ("debugger-may-continue"),
            debug_while_redisplaying ? Qnil : Qt);
    specbind (Qinhibit_redisplay, Qnil);
+   specbind (Qdebug_on_error, Qnil);
  
  #if 0 /* Binding this prevents execution of Lisp code during
         redisplay, which necessarily leads to display problems.  */
***************
*** 1533,1539 ****
    /* This hook is used by edebug.  */
    if (! NILP (Vsignal_hook_function)
        && ! NILP (error_symbol))
!     call2 (Vsignal_hook_function, error_symbol, data);
  
    conditions = Fget (real_error_symbol, Qerror_conditions);
  
--- 1556,1571 ----
    /* This hook is used by edebug.  */
    if (! NILP (Vsignal_hook_function)
        && ! NILP (error_symbol))
!     {
!       /* Edebug takes care of restoring these variables when it exits.  */
!       if (lisp_eval_depth + 20 > max_lisp_eval_depth)
!       max_lisp_eval_depth = lisp_eval_depth + 20;
! 
!       if (SPECPDL_INDEX () + 40 > max_specpdl_size)
!       max_specpdl_size = SPECPDL_INDEX () + 40;
! 
!       call2 (Vsignal_hook_function, error_symbol, data);
!     }
  
    conditions = Fget (real_error_symbol, Qerror_conditions);
  
***************
*** 1555,1566 ****
      {
        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);
  
--- 1587,1592 ----
***************
*** 1673,1679 ****
      = SIG is nil, and DATA is (SYMBOL . REST-OF-DATA).
         This is for memory-full errors only.
  
!    Store value returned from debugger into *DEBUGGER_VALUE_PTR.  */
  
  static Lisp_Object
  find_handler_clause (handlers, conditions, sig, data, debugger_value_ptr)
--- 1699,1709 ----
      = SIG is nil, and DATA is (SYMBOL . REST-OF-DATA).
         This is for memory-full errors only.
  
!    Store value returned from debugger into *DEBUGGER_VALUE_PTR.
! 
!    We need to increase max_specpdl_size temporarily around
!    anything we do that can push on the specpdl, so as not to get
!    a second error here in case we're handling specpdl overflow.  */
  
  static Lisp_Object
  find_handler_clause (handlers, conditions, sig, data, debugger_value_ptr)
***************
*** 1691,1697 ****
        || !NILP (Vdebug_on_signal)) /* This says call debugger even if
                                      there is a handler.  */
      {
-       int count = SPECPDL_INDEX ();
        int debugger_called = 0;
        Lisp_Object sig_symbol, combined_data;
        /* This is set to 1 if we are handling a memory-full error,
--- 1721,1726 ----
***************
*** 1713,1718 ****
--- 1742,1748 ----
  
        if (wants_debugger (Vstack_trace_on_error, conditions))
        {
+         max_specpdl_size++;
  #ifdef PROTOTYPES
          internal_with_output_to_temp_buffer ("*Backtrace*",
                                               (Lisp_Object (*) (Lisp_Object)) 
Fbacktrace,
***************
*** 1721,1726 ****
--- 1751,1757 ----
          internal_with_output_to_temp_buffer ("*Backtrace*",
                                               Fbacktrace, Qnil);
  #endif
+         max_specpdl_size--;
        }
        if (! no_debugger
          && (EQ (sig_symbol, Qquit)
***************
*** 1729,1735 ****
          && ! skip_debugger (conditions, combined_data)
          && when_entered_debugger < num_nonmacro_input_events)
        {
-         specbind (Qdebug_on_error, Qnil);
          *debugger_value_ptr
            = call_debugger (Fcons (Qerror,
                                    Fcons (combined_data, Qnil)));
--- 1760,1765 ----
***************
*** 1739,1745 ****
        if (EQ (handlers, Qerror))
        {
          if (debugger_called)
!           return unbind_to (count, Qlambda);
          return Qt;
        }
      }
--- 1769,1775 ----
        if (EQ (handlers, Qerror))
        {
          if (debugger_called)
!           return Qlambda;
          return Qt;
        }
      }
***************
*** 3019,3031 ****
        if (max_specpdl_size < 400)
        max_specpdl_size = 400;
        if (specpdl_size >= max_specpdl_size)
!       {
!         if (!NILP (Vdebug_on_error))
!           /* Leave room for some specpdl in the debugger.  */
!           max_specpdl_size = specpdl_size + 100;
!         Fsignal (Qerror,
!                  Fcons (build_string ("Variable binding depth exceeds 
max-specpdl-size"), Qnil));
!       }
      }
    specpdl_size *= 2;
    if (specpdl_size > max_specpdl_size)
--- 3049,3056 ----
        if (max_specpdl_size < 400)
        max_specpdl_size = 400;
        if (specpdl_size >= max_specpdl_size)
!       Fsignal (Qerror,
!                Fcons (build_string ("Variable binding depth exceeds 
max-specpdl-size"), Qnil));
      }
    specpdl_size *= 2;
    if (specpdl_size > max_specpdl_size)
***************
*** 3333,3339 ****
  {
    DEFVAR_INT ("max-specpdl-size", &max_specpdl_size,
              doc: /* *Limit on number of Lisp variable bindings & 
unwind-protects.
! If Lisp code tries to make more than this many at once,
  an error is signaled.
  You can safely use a value considerably larger than the default value,
  if that proves inconveniently small.  However, if you increase it too far,
--- 3358,3364 ----
  {
    DEFVAR_INT ("max-specpdl-size", &max_specpdl_size,
              doc: /* *Limit on number of Lisp variable bindings & 
unwind-protects.
! If Lisp code tries to increase the total number past this amount,
  an error is signaled.
  You can safely use a value considerably larger than the default value,
  if that proves inconveniently small.  However, if you increase it too far,