unofficial mirror of emacs-devel@gnu.org 
 help / color / mirror / code / Atom feed
* 23.0.60; Occasional hangs in flyspell-mode and ispell-word
@ 2008-03-27  5:20 Markus Triska
  2008-03-27 21:04 ` Stefan Monnier
  0 siblings, 1 reply; 6+ messages in thread
From: Markus Triska @ 2008-03-27  5:20 UTC (permalink / raw)
  To: emacs-pretest-bug


In connection with flyspell-mode and ispell-word, sometimes Emacs
hangs indefinitely and cannot be interrupted with C-g. When running
Emacs inside gdb and doing a backtrace when it hangs, I get:

   (gdb) backtrace
   #0  wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, do_display=0, wait_for_cell=50332681, wait_proc=0x249d970, just_wait_proc=0) at process.c:4471
   #1  0x00183f22 in Faccept_process_output (process=38394228, seconds=50332681, millisec=50332681, just_this_one=50332681) at process.c:3948
   #2  0x00149784 in Ffuncall (nargs=4, args=0xbfffef20) at eval.c:3035
   #3  0x001797cb in Fbyte_code (bytestr=89564547, vector=38604804, maxdepth=4) at bytecode.c:679
   #4  0x00149067 in funcall_lambda (fun=38387252, nargs=0, arg_vector=0xbffff0a4) at eval.c:3212
   #5  0x0014954a in Ffuncall (nargs=1, args=0xbffff0a0) at eval.c:3082
   #6  0x001797cb in Fbyte_code (bytestr=89549107, vector=34149860, maxdepth=8) at bytecode.c:679
   #7  0x00149067 in funcall_lambda (fun=38350484, nargs=4, arg_vector=0xbffff234) at eval.c:3212
   #8  0x0014954a in Ffuncall (nargs=5, args=0xbffff230) at eval.c:3082
   #9  0x0014acfa in Fapply (nargs=2, args=0xbffff2d0) at eval.c:2513
   #10 0x0014ae55 in apply1 (fn=58539929, arg=46150237) at eval.c:2777
   #11 0x00145254 in Fcall_interactively (function=58539929, record_flag=50332681, keys=59777148) at callint.c:386
   #12 0x0014975d in Ffuncall (nargs=4, args=0xbffff4b0) at eval.c:3031
   #13 0x001498f9 in call3 (fn=50443721, arg1=58539929, arg2=50332681, arg3=50332681) at eval.c:2855
   #14 0x000e68fd in command_loop_1 () at keyboard.c:1908
   #15 0x001478db in internal_condition_case (bfun=0xe64a6 <command_loop_1>, handlers=50372249, hfun=0xdf35a <cmd_error>) at eval.c:1494
   #16 0x000d8388 in command_loop_2 () at keyboard.c:1370
   #17 0x0014752d in internal_catch (tag=50368345, func=0xd8344 <command_loop_2>, arg=50332681) at eval.c:1230
   #18 0x000d812a in command_loop () at keyboard.c:1349
   #19 0x000d81e3 in recursive_edit_1 () at keyboard.c:958
   #20 0x000d832b in Frecursive_edit () at keyboard.c:1020
   #21 0x000d7369 in main (argc=1, argv=0xbffff92c) at emacs.c:1784

   Lisp Backtrace:
   "accept-process-output" (0xbfffef24)
   "ispell-accept-output" (0xbffff0a4)
   "ispell-word" (0xbffff234)
   "call-interactively" (0xbffff4b4)



Here is a more verbose session, single-stepping after Emacs hangs. At
various points, I tried "C-g" in Emacs, and after some tries the input
seems to be detected at last. When Emacs isn't run inside gdb and
begins to hang, I've never managed to unblock it. It simply consumes a
lot of CPU and is completely unresponsive then.


mt-computer:~/emacs/src mt$ gdb ./emacs
GNU gdb 6.3.50-20050815 (Apple version gdb-573) (Fri Oct 20 15:50:43 GMT 2006)
Copyright 2004 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB.  Type "show warranty" for details.
This GDB was configured as "i386-apple-darwin"...Reading symbols for shared libraries ................................. done

DISPLAY = :0.0
TERM = xterm-color
Breakpoint 1 at 0x9010d3db
Breakpoint 2 at 0xf129e: file sysdep.c, line 1317.
(gdb) r
Starting program: /Users/mt/emacs/src/emacs 
Reading symbols for shared libraries ....................................................................+++..+.++.+..+....+++.++++++++++.+++++ done
Reading symbols for shared libraries . done
^Z
Program received signal SIGTSTP, Stopped (user).
0x9000ffee in read ()
(gdb) c
Continuing.
^Z
Program received signal SIGTSTP, Stopped (user).
0x9000ffe0 in read ()
(gdb) 
Single stepping until exit from function read, 
which has no line number information.
0x901100f0 in _sysenter_trap ()
(gdb) 
Single stepping until exit from function _sysenter_trap, 
which has no line number information.
0x9000ffee in read ()
(gdb) 
Single stepping until exit from function read, 
which has no line number information.
0x90110760 in cerror ()
(gdb) 
Single stepping until exit from function cerror, 
which has no line number information.
0x90001715 in cthread_set_errno_self ()
(gdb) 
Single stepping until exit from function cthread_set_errno_self, 
which has no line number information.
0x9016a970 in __i686.get_pc_thunk.bx ()
(gdb) 
Single stepping until exit from function __i686.get_pc_thunk.bx, 
which has no line number information.
0x90001723 in cthread_set_errno_self ()
(gdb) 
Single stepping until exit from function cthread_set_errno_self, 
which has no line number information.
0x9011078b in cerror ()
(gdb) 
Single ping until exit from function cerror, 
which has no line number information.
emacs_read (fildes=0, buf=0xbfffdab0 "\350\224|\003\030", nbyte=4096) at sysdep.c:3372
3372    }
(gdb) 
read_process_output (proc=38394228, channel=0) at process.c:5032
5032          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5071      p->decoding_carryover = 0;
(gdb) 
5075      if (nbytes <= 0)
(gdb) 
5077          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5321    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, do_display=0, wait_for_cell=50332681, wait_proc=0x249d970, just_wait_proc=0) at process.c:4468
4468                  if (nread == 0)
(gdb) 
4471                  if (0 < nread)
(gdb) 
4474                  else if (nread == -1 && EIO == errno)
(gdb) 
4478                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4482                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4464              while (wait_proc->infd >= 0)
(gdb) 
4466                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=38394228, channel=0) at process.c:4975
4975      register struct buffer *old = current_buffer;
(gdb) 
4976      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
4978      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
4979      int carryover = p->decoding_carryover;
(gdb) 
5013      chars = (char *) alloca (carryover + readmax);
(gdb) 
5014      if (carryover)
(gdb) 
5020      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5028      if (proc_buffered_char[channel] < 0)
(gdb) 
5030          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffdab0 "\350\224|\003\030", nbyte=4096) at sysdep.c:3368
3368      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3372    }
(gdb) 
read_process_output (proc=38394228, channel=0) at process.c:5032
5032          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5071      p->decoding_carryover = 0;
(gdb) 
5075      if (nbytes <= 0)
(gdb) 
5077          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5321    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, do_display=0, wait_for_cell=50332681, wait_proc=0x249d970, just_wait_proc=0) at process.c:4468
4468                  if (nread == 0)
(gdb) 
4471                  if (0 < nread)
(gdb) 
4474                  else if (nread == -1 && EIO == errno)
(gdb) 
4478                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4482                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4464              while (wait_proc->infd >= 0)
(gdb) 
4466                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=38394228, channel=0) at process.c:4975
4975      register struct buffer *old = current_buffer;
(gdb) 
4976      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
4978      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
4979      int carryover = p->decoding_carryover;
(gdb) 
5013      chars = (char *) alloca (carryover + readmax);
(gdb) 
5014      if (carryover)
(gdb) 
5020      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5028      if (proc_buffered_char[channel] < 0)
(gdb) 
5030          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffdab0 "\350\224|\003\030", nbyte=4096) at sysdep.c:3368
3368      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3372    }
(gdb) 
read_process_output (proc=38394228, channel=0) at process.c:5032
5032          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5071      p->decoding_carryover = 0;
(gdb) 
5075      if (nbytes <= 0)
(gdb) 
5077          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5321    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, do_display=0, wait_for_cell=50332681, wait_proc=0x249d970, just_wait_proc=0) at process.c:4468
4468                  if (nread == 0)
(gdb) 
4471                  if (0 < nread)
(gdb) 
4474                  else if (nread == -1 && EIO == errno)
(gdb) 
4478                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4482                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4464              while (wait_proc->infd >= 0)
(gdb) 
4466                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=38394228, channel=0) at process.c:4975
4975      register struct buffer *old = current_buffer;
(gdb) 
4976      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
4978      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
4979      int carryover = p->decoding_carryover;
(gdb) 
5013      chars = (char *) alloca (carryover + readmax);
(gdb) 
5014      if (carryover)
(gdb) 
5020      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5028      if (proc_buffered_char[channel] < 0)
(gdb) 
5030          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffdab0 "\350\224|\003\030", nbyte=4096) at sysdep.c:3368
3368      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3372    }
(gdb) 
read_process_output (proc=38394228, channel=0) at process.c:5032
5032          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5071      p->decoding_carryover = 0;
(gdb) 
5075      if (nbytes <= 0)
(gdb) 
5077          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5321    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, do_display=0, wait_for_cell=50332681, wait_proc=0x249d970, just_wait_proc=0) at process.c:4468
4468                  if (nread == 0)
(gdb) 
4471                  if (0 < nread)
(gdb) 
4474                  else if (nread == -1 && EIO == errno)
(gdb) 
4478                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4482                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4464              while (wait_proc->infd >= 0)
(gdb) 
4466                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=38394228, channel=0) at process.c:4975
4975      register struct buffer *old = current_buffer;
(gdb) 
4976      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
4978      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
4979      int carryover = p->decoding_carryover;
(gdb) 
5013      chars = (char *) alloca (carryover + readmax);
(gdb) 
5014      if (carryover)
(gdb) 
5020      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5028      if (proc_buffered_char[channel] < 0)
(gdb) 
5030          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffdab0 "\350\224|\003\030", nbyte=4096) at sysdep.c:3368
3368      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3372    }
(gdb) 
read_process_output (proc=38394228, channel=0) at process.c:5032
5032          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5071      p->decoding_carryover = 0;
(gdb) 
5075      if (nbytes <= 0)
(gdb) 
5077          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5321    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, do_display=0, wait_for_cell=50332681, wait_proc=0x249d970, just_wait_proc=0) at process.c:4468
4468                  if (nread == 0)
(gdb) 
4471                  if (0 < nread)
(gdb) 
4474                  else if (nread == -1 && EIO == errno)
(gdb) 
4478                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4482                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4464              while (wait_proc->infd >= 0)
(gdb) 
4466                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=38394228, channel=0) at process.c:4975
4975      register struct buffer *old = current_buffer;
(gdb) 
4976      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
4978      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
4979      int carryover = p->decoding_carryover;
(gdb) 
5013      chars = (char *) alloca (carryover + readmax);
(gdb) 
5014      if (carryover)
(gdb) 
5020      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5028      if (proc_buffered_char[channel] < 0)
(gdb) 
5030          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffdab0 "\350\224|\003\030", nbyte=4096) at sysdep.c:3368
3368      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3372    }
(gdb) 
read_process_output (proc=38394228, channel=0) at process.c:5032
5032          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5071      p->decoding_carryover = 0;
(gdb) 
5075      if (nbytes <= 0)
(gdb) 
5077          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5321    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, do_display=0, wait_for_cell=50332681, wait_proc=0x249d970, just_wait_proc=0) at process.c:4468
4468                  if (nread == 0)
(gdb) 
4471                  if (0 < nread)
(gdb) 
4474                  else if (nread == -1 && EIO == errno)
(gdb) 
4478                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4482                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4464              while (wait_proc->infd >= 0)
(gdb) 
4466                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=38394228, channel=0) at process.c:4975
4975      register struct buffer *old = current_buffer;
(gdb) 
4976      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
4978      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
4979      int carryover = p->decoding_carryover;
(gdb) 
5013      chars = (char *) alloca (carryover + readmax);
(gdb) 
5014      if (carryover)
(gdb) 
5020      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5028      if (proc_buffered_char[channel] < 0)
(gdb) 
5030          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffdab0 "\350\224|\003\030", nbyte=4096) at sysdep.c:3368
3368      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3372    }
(gdb) 
read_process_output (proc=38394228, channel=0) at process.c:5032
5032          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5071      p->decoding_carryover = 0;
(gdb) 
5075      if (nbytes <= 0)
(gdb) 
5077          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5321    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, do_display=0, wait_for_cell=50332681, wait_proc=0x249d970, just_wait_proc=0) at process.c:4468
4468                  if (nread == 0)
(gdb) 
4471                  if (0 < nread)
(gdb) 
4474                  else if (nread == -1 && EIO == errno)
(gdb) 
4478                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4482                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4464              while (wait_proc->infd >= 0)
(gdb) 
4466                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=38394228, channel=0) at process.c:4975
4975      register struct buffer *old = current_buffer;
(gdb) 
4976      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
4978      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
4979      int carryover = p->decoding_carryover;
(gdb) 
5013      chars = (char *) alloca (carryover + readmax);
(gdb) 
5014      if (carryover)
(gdb) 
5020      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5028      if (proc_buffered_char[channel] < 0)
(gdb) 
5030          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffdab0 "\350\224|\003\030", nbyte=4096) at sysdep.c:3368
3368      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3372    }
(gdb) 
read_process_output (proc=38394228, channel=0) at process.c:5032
5032          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5071      p->decoding_carryover = 0;
(gdb) 
5075      if (nbytes <= 0)
(gdb) 
5077          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5321    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, do_display=0, wait_for_cell=50332681, wait_proc=0x249d970, just_wait_proc=0) at process.c:4468
4468                  if (nread == 0)
(gdb) 
4471                  if (0 < nread)
(gdb) 
4474                  else if (nread == -1 && EIO == errno)
(gdb) 
4478                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4482                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4464              while (wait_proc->infd >= 0)
(gdb) 
4466                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=38394228, channel=0) at process.c:4975
4975      register struct buffer *old = current_buffer;
(gdb) 
4976      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
4978      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
4979      int carryover = p->decoding_carryover;
(gdb) 
5013      chars = (char *) alloca (carryover + readmax);
(gdb) 
5014      if (carryover)
(gdb) 
5020      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5028      if (proc_buffered_char[channel] < 0)
(gdb) 
5030          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffdab0 "\350\224|\003\030", nbyte=4096) at sysdep.c:3368
3368      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3372    }
(gdb) 
read_process_output (proc=38394228, channel=0) at process.c:5032
5032          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5071      p->decoding_carryover = 0;
(gdb) 
5075      if (nbytes <= 0)
(gdb) 
5077          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5321    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, do_display=0, wait_for_cell=50332681, wait_proc=0x249d970, just_wait_proc=0) at process.c:4468
4468                  if (nread == 0)
(gdb) 
4471                  if (0 < nread)
(gdb) 
4474                  else if (nread == -1 && EIO == errno)
(gdb) 
4478                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4482                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4464              while (wait_proc->infd >= 0)
(gdb) 
4466                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=38394228, channel=0) at process.c:4975
4975      register struct buffer *old = current_buffer;
(gdb) 
4976      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
4978      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
4979      int carryover = p->decoding_carryover;
(gdb) 
5013      chars = (char *) alloca (carryover + readmax);
(gdb) 
5014      if (carryover)
(gdb) 
5020      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5028      if (proc_buffered_char[channel] < 0)
(gdb) 
5030          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffdab0 "\350\224|\003\030", nbyte=4096) at sysdep.c:3368
3368      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3372    }
(gdb) 
read_process_output (proc=38394228, channel=0) at process.c:5032
5032          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5071      p->decoding_carryover = 0;
(gdb) 
5075      if (nbytes <= 0)
(gdb) 
5077          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5321    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, do_display=0, wait_for_cell=50332681, wait_proc=0x249d970, just_wait_proc=0) at process.c:4468
4468                  if (nread == 0)
(gdb) 
4471                  if (0 < nread)
(gdb) 
4474                  else if (nread == -1 && EIO == errno)
(gdb) 
4478                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4482                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4464              while (wait_proc->infd >= 0)
(gdb) 
4466                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=38394228, channel=0) at process.c:4975
4975      register struct buffer *old = current_buffer;
(gdb) 
4976      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
4978      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
4979      int carryover = p->decoding_carryover;
(gdb) 
5013      chars = (char *) alloca (carryover + readmax);
(gdb) 
5014      if (carryover)
(gdb) 
5020      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5028      if (proc_buffered_char[channel] < 0)
(gdb) 
5030          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffdab0 "\350\224|\003\030", nbyte=4096) at sysdep.c:3368
3368      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3372    }
(gdb) 
read_process_output (proc=38394228, channel=0) at process.c:5032
5032          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5071      p->decoding_carryover = 0;
(gdb) 
5075      if (nbytes <= 0)
(gdb) 
5077          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5321    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, do_display=0, wait_for_cell=50332681, wait_proc=0x249d970, just_wait_proc=0) at process.c:4468
4468                  if (nread == 0)
(gdb) 
4471                  if (0 < nread)
(gdb) 
4474                  else if (nread == -1 && EIO == errno)
(gdb) 
4478                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4482                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4464              while (wait_proc->infd >= 0)
(gdb) 
4466                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=38394228, channel=0) at process.c:4975
4975      register struct buffer *old = current_buffer;
(gdb) 
4976      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
4978      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
4979      int carryover = p->decoding_carryover;
(gdb) 
5013      chars = (char *) alloca (carryover + readmax);
(gdb) 
5014      if (carryover)
(gdb) 
5020      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5028      if (proc_buffered_char[channel] < 0)
(gdb) 
5030          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffdab0 "\350\224|\003\030", nbyte=4096) at sysdep.c:3368
3368      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3372    }
(gdb) 
read_process_output (proc=38394228, channel=0) at process.c:5032
5032          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5071      p->decoding_carryover = 0;
(gdb) 
5075      if (nbytes <= 0)
(gdb) 
5077          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5321    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, do_display=0, wait_for_cell=50332681, wait_proc=0x249d970, just_wait_proc=0) at process.c:4468
4468                  if (nread == 0)
(gdb) 
4471                  if (0 < nread)
(gdb) 
4474                  else if (nread == -1 && EIO == errno)
(gdb) 
4478                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4482                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4464              while (wait_proc->infd >= 0)
(gdb) 
4466                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=38394228, channel=0) at process.c:4975
4975      register struct buffer *old = current_buffer;
(gdb) 
4976      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
4978      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
4979      int carryover = p->decoding_carryover;
(gdb) 
5013      chars = (char *) alloca (carryover + readmax);
(gdb) 
5014      if (carryover)
(gdb) 
5020      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5028      if (proc_buffered_char[channel] < 0)
(gdb) 
5030          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffdab0 "\350\224|\003\030", nbyte=4096) at sysdep.c:3368
3368      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3372    }
(gdb) 
read_process_output (proc=38394228, channel=0) at process.c:5032
5032          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5071      p->decoding_carryover = 0;
(gdb) 
5075      if (nbytes <= 0)
(gdb) 
5077          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5321    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, do_display=0, wait_for_cell=50332681, wait_proc=0x249d970, just_wait_proc=0) at process.c:4468
4468                  if (nread == 0)
(gdb) 
4471                  if (0 < nread)
(gdb) 
4474                  else if (nread == -1 && EIO == errno)
(gdb) 
4478                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4482                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4464              while (wait_proc->infd >= 0)
(gdb) 
4466                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=38394228, channel=0) at process.c:4975
4975      register struct buffer *old = current_buffer;
(gdb) 
4976      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
4978      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
4979      int carryover = p->decoding_carryover;
(gdb) 
5013      chars = (char *) alloca (carryover + readmax);
(gdb) 
5014      if (carryover)
(gdb) 
5020      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5028      if (proc_buffered_char[channel] < 0)
(gdb) 
5030          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffdab0 "\350\224|\003\030", nbyte=4096) at sysdep.c:3368
3368      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3372    }
(gdb) 
read_process_output (proc=38394228, channel=0) at process.c:5032
5032          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5071      p->decoding_carryover = 0;
(gdb) 
5075      if (nbytes <= 0)
(gdb) 
5077          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5321    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, do_display=0, wait_for_cell=50332681, wait_proc=0x249d970, just_wait_proc=0) at process.c:4468
4468                  if (nread == 0)
(gdb) c
Continuing.
^Z
Program received signal SIGTSTP, Stopped (user).
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, do_display=0, wait_for_cell=50332681, wait_proc=0x249d970, just_wait_proc=0) at process.c:4471
4471                  if (0 < nread)
(gdb)
4474                  else if (nread == -1 && EIO == errno)
(gdb)
4478                  else if (nread == -1 && EAGAIN == errno)
(gdb) p nread
$1 = -1610559420
(gdb) pr
^Z
Program received signal SIGTSTP, Stopped (user).
0x9001a1cc in select ()
The program being debugged was signaled while in a function called from GDB.
GDB remains in the frame where the signal was received.
To change this behavior use "set unwindonsignal on"
Evaluation of the expression containing the function (debug_print) will be abandoned.
(gdb)
Single stepping until exit from function select, 
which has no line number information.
0x90110760 in cerror ()
(gdb)
Single stepping until exit from function cerror, 
which has no line number information.
0x90001715 in cthread_set_errno_self ()
(gdb)
Single stepping until exit from function cthread_set_errno_self, 
which has no line number information.
0x9016a970 in __i686.get_pc_thunk.bx ()
(gdb)
Single stepping until exit from function __i686.get_pc_thunk.bx, 
which has no line number information.
0x90001723 in cthread_set_errno_self ()
(gdb)
Single stepping until exit from function cthread_set_errno_self, 
which has no line number information.
0x9011078b in cerror ()
(gdb)
Single stepping until exit from function cerror, 
which has no line number information.
select_wrapper (n=-1, rfd=0xffffffff, wfd=0x90001778, xfd=0x0, tmo=0xbffff098) at process.c:4207
4207    }
(gdb)
wait_reading_process_output (time_limit=30, microsecs=0, read_kbd=-1, do_display=1, wait_for_cell=50332681, wait_proc=0x0, just_wait_proc=0) at process.c:4589
4589          xerrno = errno;
(gdb)
4592          clear_waiting_for_input ();
(gdb)
clear_waiting_for_input () at keyboard.c:11010
11010     waiting_for_input = 0;
(gdb)
11011     input_available_clear_time = 0;
(gdb)
11012   }
(gdb)
wait_reading_process_output (time_limit=30, microsecs=0, read_kbd=-1, do_display=1, wait_for_cell=50332681, wait_proc=0x0, just_wait_proc=0) at process.c:4595
4595          do_pending_window_change (0);
(gdb)
do_pending_window_change (safe=0) at dispnew.c:6232
6232      if (redisplaying_p && !safe)
(gdb)
6235      while (delayed_size_change)
(gdb)
6250    }
(gdb)
wait_reading_process_output (time_limit=30, microsecs=0, read_kbd=-1, do_display=1, wait_for_cell=50332681, wait_proc=0x0, just_wait_proc=0) at process.c:4597
4597          if (time_limit && nfds == 0 && ! timeout_reduced_for_timers)
(gdb)
4600          if (nfds < 0)
(gdb)
4602              if (xerrno == EINTR)
(gdb)
4634              FD_ZERO (&Available);
(gdb) 
4670          if (read_kbd != 0)
(gdb) 
4672              int old_timers_run = timers_run;
(gdb) 
4673              struct buffer *old_buffer = current_buffer;
(gdb) 
4674              Lisp_Object old_window = selected_window;
(gdb) 
4677              if (detect_input_pending_run_timers (do_display))
(gdb) 
detect_input_pending_run_timers (do_display=1) at keyboard.c:10640
10640     int old_timers_run = timers_run;
(gdb) 
10642     if (!input_pending)
(gdb) 
10643       get_input_pending (&input_pending, READABLE_EVENTS_DO_TIMERS_NOW);
(gdb) p input_pending
$2 = 0
(gdb) 
get_input_pending (addr=0x313a90, flags=1) at keyboard.c:6972
6972      *addr = (!NILP (Vquit_flag) || readable_events (flags));
(gdb) 
readable_events (flags=1) at keyboard.c:3682
3682      if (flags & READABLE_EVENTS_DO_TIMERS_NOW)
(gdb) 
3683        timer_check (1);
(gdb) 
timer_check (do_it_now=1) at keyboard.c:4535
4535      timers = Vtimer_list;
(gdb) 
4537      if (! EMACS_TIME_NEG_P (timer_idleness_start_time))
(gdb) 
4538        idle_timers = Vtimer_idle_list;
(gdb) 
4544      if (CONSP (timers) || CONSP (idle_timers))
(gdb) 
4546          EMACS_GET_TIME (now);
(gdb) 
4547          if (! EMACS_TIME_NEG_P (timer_idleness_start_time))
(gdb) 
4548            EMACS_SUB_TIME (idleness_now, now, timer_idleness_start_time);
(gdb) 
4551      while (CONSP (timers) || CONSP (idle_timers))
(gdb) 
4554          Lisp_Object timer = Qnil, idle_timer = Qnil;
(gdb) 
4559          if (!NILP (timers))
(gdb) 
4561              timer = XCAR (timers);
(gdb) finish
Run till exit from #0  timer_check (do_it_now=1) at keyboard.c:4561
0x000d9bb6 in readable_events (flags=1) at keyboard.c:3683
3683        timer_check (1);
Value returned is $3 = {tv_sec = -1, tv_usec = -1}
(gdb) finish
Run till exit from #0  0x000d9bb6 in readable_events (flags=1) at keyboard.c:3683
0x000e0958 in get_input_pending (addr=0x313a90, flags=1) at keyboard.c:6972
6972      *addr = (!NILP (Vquit_flag) || readable_events (flags));
Value returned is $4 = 0
(gdb) finish
Run till exit from #0  0x000e0958 in get_input_pending (addr=0x313a90, flags=1) at keyboard.c:6972
0x000e0a78 in detect_input_pending_run_timers (do_display=1) at keyboard.c:10643
10643       get_input_pending (&input_pending, READABLE_EVENTS_DO_TIMERS_NOW);
(gdb) finish
Run till exit from #0  0x000e0a78 in detect_input_pending_run_timers (do_display=1) at keyboard.c:10643
0x00182416 in wait_reading_process_output (time_limit=30, microsecs=0, read_kbd=-1, do_display=1, wait_for_cell=50332681, wait_proc=0x0, just_wait_proc=0) at process.c:4677
4677              if (detect_input_pending_run_timers (do_display))
Value returned is $5 = 0
(gdb) finish
Run till exit from #0  0x00182416 in wait_reading_process_output (time_limit=30, microsecs=0, read_kbd=-1, do_display=1, wait_for_cell=50332681, wait_proc=0x0, just_wait_proc=0) at process.c:4677
sit_for (timeout=240, reading=1, do_display=1) at dispnew.c:6617
6617      return detect_input_pending () ? Qnil : Qt;
Value returned is $6 = 0
(gdb) finish
Run till exit from #0  sit_for (timeout=240, reading=1, do_display=1) at dispnew.c:6617
0x000e2850 in read_char (commandflag=1, nmaps=3, maps=0xbffff340, prev_event=50332681, used_mouse_menu=0xbffff43c, end_time=0x0) at keyboard.c:2967
2967              tem0 = sit_for (make_number (timeout), 1, 1);
Value returned is $7 = 50332729
(gdb) finish
Run till exit from #0  0x000e2850 in read_char (commandflag=1, nmaps=3, maps=0xbffff340, prev_event=50332681, used_mouse_menu=0xbffff43c, end_time=0x0) at keyboard.c:2967
0x000e4346 in read_key_sequence (keybuf=0xbffff4f8, bufsize=30, prompt=50332681, dont_downcase_last=0, can_return_switch_frame=1, fix_current_buffer=1) at keyboard.c:9458
9458                key = read_char (NILP (prompt), nmaps,
Value returned is $8 = 192
(gdb) finish
Run till exit from #0  0x000e4346 in read_key_sequence (keybuf=0xbffff4f8, bufsize=30, prompt=50332681, dont_downcase_last=0, can_return_switch_frame=1, fix_current_buffer=1) at keyboard.c:9458
0x000e66bc in command_loop_1 () at keyboard.c:1653
1653          i = read_key_sequence (keybuf, sizeof keybuf / sizeof keybuf[0],
Value returned is $9 = 1
(gdb) finish
Run till exit from #0  0x000e66bc in command_loop_1 () at keyboard.c:1653


In GNU Emacs 23.0.60.4 (i386-apple-darwin8.11.1, GTK+ Version 2.12.9)
 of 2008-03-26 on mt-computer.local
Windowing system distributor `The XFree86 Project, Inc', version 11.0.40400000
configured using `configure  '--disable-font-backend''

Important settings:
  value of $LC_ALL: nil
  value of $LC_COLLATE: nil
  value of $LC_CTYPE: nil
  value of $LC_MESSAGES: nil
  value of $LC_MONETARY: nil
  value of $LC_NUMERIC: nil
  value of $LC_TIME: nil
  value of $LANG: nil
  value of $XMODIFIERS: nil
  locale-coding-system: nil
  default-enable-multibyte-characters: t

Major mode: C/l

Minor modes in effect:
  shell-dirtrack-mode: t
  iswitchb-mode: t
  openwith-mode: t
  TeX-source-specials-mode: t
  show-paren-mode: t
  tooltip-mode: t
  mouse-wheel-mode: t
  file-name-shadow-mode: t
  global-font-lock-mode: t
  font-lock-mode: t
  blink-cursor-mode: t
  global-auto-composition-mode: t
  auto-composition-mode: t
  auto-compression-mode: t
  line-number-mode: t
  transient-mark-mode: t
  abbrev-mode: t


Recent messages:
Registering /Users/mt/gravity/ppm.tcl... done
Mark set
Press C-c C-c when you are done editing.
Enter a change comment.  Type C-c C-c when done
Checking spelling of COMMITTING...
Quit [3 times]
Mark saved where search started
Quit




^ permalink raw reply	[flat|nested] 6+ messages in thread

* Re: 23.0.60; Occasional hangs in flyspell-mode and ispell-word
  2008-03-27  5:20 23.0.60; Occasional hangs in flyspell-mode and ispell-word Markus Triska
@ 2008-03-27 21:04 ` Stefan Monnier
  2008-03-27 21:27   ` Lennart Borgman (gmail)
  2008-03-28 15:06   ` Markus Triska
  0 siblings, 2 replies; 6+ messages in thread
From: Stefan Monnier @ 2008-03-27 21:04 UTC (permalink / raw)
  To: Markus Triska; +Cc: emacs-pretest-bug

> In connection with flyspell-mode and ispell-word, sometimes Emacs
> hangs indefinitely and cannot be interrupted with C-g. When running
> Emacs inside gdb and doing a backtrace when it hangs, I get:

I personally use an Emacs patched as follows:

   Index: src/process.c
   ===================================================================
   RCS file: /sources/emacs/emacs/src/process.c,v
   retrieving revision 1.538
   diff -u -r1.538 process.c
   --- src/process.c	27 Mar 2008 20:52:24 -0000	1.538
   +++ src/process.c	27 Mar 2008 20:52:32 -0000
   @@ -4272,6 +4272,9 @@
      FD_ZERO (&Connecting);
    #endif
    
   +  if (time_limit == 0 && wait_proc && !NILP (Vinhibit_quit))
   +    error ("Blocking call to accept-process-output with quit inhibited!!");
   +
      /* If wait_proc is a process to watch, set wait_channel accordingly.  */
      if (wait_proc != NULL)
        wait_channel = wait_proc->infd;

so the accept-process-output refuses to do its job if it's run with
quit-inhibited, which is the typical cause of problems such as the one
you're describing.  But your backtrace indicates that inhibit-quit is
(most likely) not set, so your problem seems to be different.

When did this problem started?


        Stefan




^ permalink raw reply	[flat|nested] 6+ messages in thread

* Re: 23.0.60; Occasional hangs in flyspell-mode and ispell-word
  2008-03-27 21:04 ` Stefan Monnier
@ 2008-03-27 21:27   ` Lennart Borgman (gmail)
  2008-03-29 18:40     ` Stefan Monnier
  2008-03-28 15:06   ` Markus Triska
  1 sibling, 1 reply; 6+ messages in thread
From: Lennart Borgman (gmail) @ 2008-03-27 21:27 UTC (permalink / raw)
  To: Stefan Monnier; +Cc: emacs-pretest-bug, Markus Triska

Stefan Monnier wrote:
> I personally use an Emacs patched as follows:
> 
>    Index: src/process.c
>    ===================================================================
>    RCS file: /sources/emacs/emacs/src/process.c,v
>    retrieving revision 1.538
>    diff -u -r1.538 process.c
>    --- src/process.c	27 Mar 2008 20:52:24 -0000	1.538
>    +++ src/process.c	27 Mar 2008 20:52:32 -0000
>    @@ -4272,6 +4272,9 @@
>       FD_ZERO (&Connecting);
>     #endif
>     
>    +  if (time_limit == 0 && wait_proc && !NILP (Vinhibit_quit))
>    +    error ("Blocking call to accept-process-output with quit inhibited!!");
>    +
>       /* If wait_proc is a process to watch, set wait_channel accordingly.  */
>       if (wait_proc != NULL)
>         wait_channel = wait_proc->infd;
> 
> so the accept-process-output refuses to do its job if it's run with
> quit-inhibited, which is the typical cause of problems such as the one
> you're describing.  But your backtrace indicates that inhibit-quit is
> (most likely) not set, so your problem seems to be different.

It is a bit off topic but why do you not apply this to the CVS sources?




^ permalink raw reply	[flat|nested] 6+ messages in thread

* Re: 23.0.60; Occasional hangs in flyspell-mode and ispell-word
  2008-03-27 21:04 ` Stefan Monnier
  2008-03-27 21:27   ` Lennart Borgman (gmail)
@ 2008-03-28 15:06   ` Markus Triska
  2008-03-29 18:43     ` Stefan Monnier
  1 sibling, 1 reply; 6+ messages in thread
From: Markus Triska @ 2008-03-28 15:06 UTC (permalink / raw)
  To: Stefan Monnier; +Cc: emacs-pretest-bug

Stefan Monnier <monnier@iro.umontreal.ca> writes:

> so the accept-process-output refuses to do its job if it's run with
> quit-inhibited, which is the typical cause of problems such as the one

Thanks, I've applied this change locally to make sure this isn't the
cause here.

> When did this problem started?

I encountered such hangs with flyspell-mode definitely months ago
already, with Emacs.app (which was at that point quite up-to-date, and
already based on the Unicode branch plus multi-tty). I'm not certain
whether the then current trunk had the same problem, but I vaguely
remember similar problems with even earlier versions.

I get these hangs about twice or thrice a day when working on a large
LaTeX document with flyspell-mode activated. I hope you can reproduce
the problem if you enable flyspell-mode for modes that you often use.




^ permalink raw reply	[flat|nested] 6+ messages in thread

* Re: 23.0.60; Occasional hangs in flyspell-mode and ispell-word
  2008-03-27 21:27   ` Lennart Borgman (gmail)
@ 2008-03-29 18:40     ` Stefan Monnier
  0 siblings, 0 replies; 6+ messages in thread
From: Stefan Monnier @ 2008-03-29 18:40 UTC (permalink / raw)
  To: Lennart Borgman (gmail); +Cc: emacs-pretest-bug, Markus Triska

>> I personally use an Emacs patched as follows:
>> 
>> Index: src/process.c
>> ===================================================================
>> RCS file: /sources/emacs/emacs/src/process.c,v
>> retrieving revision 1.538
>> diff -u -r1.538 process.c
>> --- src/process.c	27 Mar 2008 20:52:24 -0000	1.538
>> +++ src/process.c	27 Mar 2008 20:52:32 -0000
>> @@ -4272,6 +4272,9 @@
>> FD_ZERO (&Connecting);
>> #endif
>> +  if (time_limit == 0 && wait_proc && !NILP (Vinhibit_quit))
>> +    error ("Blocking call to accept-process-output with quit inhibited!!");
>> +
>> /* If wait_proc is a process to watch, set wait_channel accordingly.  */
>> if (wait_proc != NULL)
>> wait_channel = wait_proc->infd;
>> 
>> so the accept-process-output refuses to do its job if it's run with
>> quit-inhibited, which is the typical cause of problems such as the one
>> you're describing.  But your backtrace indicates that inhibit-quit is
>> (most likely) not set, so your problem seems to be different.

> It is a bit off topic but why do you not apply this to the CVS sources?

It breaks some Elisp packages.  Those packages arguably have a bug, but
the bug may very rarely show up (if ever).


        Stefan




^ permalink raw reply	[flat|nested] 6+ messages in thread

* Re: 23.0.60; Occasional hangs in flyspell-mode and ispell-word
  2008-03-28 15:06   ` Markus Triska
@ 2008-03-29 18:43     ` Stefan Monnier
  0 siblings, 0 replies; 6+ messages in thread
From: Stefan Monnier @ 2008-03-29 18:43 UTC (permalink / raw)
  To: Markus Triska; +Cc: emacs-pretest-bug

>> When did this problem started?

> I encountered such hangs with flyspell-mode definitely months ago
> already, with Emacs.app (which was at that point quite up-to-date, and
> already based on the Unicode branch plus multi-tty).  I'm not certain
> whether the then current trunk had the same problem, but I vaguely
> remember similar problems with even earlier versions.

What's the latest trunk version you can remember using which didn't
suffer from this problem?

> I get these hangs about twice or thrice a day when working on a large
> LaTeX document with flyspell-mode activated.  I hope you can reproduce
> the problem if you enable flyspell-mode for modes that you often use.

I use flyspell pretty much everywhere (including programming modes via
flyspell-prog-mode).  Haven't seen such problem.

I'd expect it to be linked to problems with the ispell (or aspell)
process, so it may depend on which version of that program you're using.


        Stefan




^ permalink raw reply	[flat|nested] 6+ messages in thread

end of thread, other threads:[~2008-03-29 18:43 UTC | newest]

Thread overview: 6+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2008-03-27  5:20 23.0.60; Occasional hangs in flyspell-mode and ispell-word Markus Triska
2008-03-27 21:04 ` Stefan Monnier
2008-03-27 21:27   ` Lennart Borgman (gmail)
2008-03-29 18:40     ` Stefan Monnier
2008-03-28 15:06   ` Markus Triska
2008-03-29 18:43     ` Stefan Monnier

Code repositories for project(s) associated with this public inbox

	https://git.savannah.gnu.org/cgit/emacs.git

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).