bug-gnu-emacs
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

bug#532: Acknowledgement (23.0.60; hang, then crash)


From: Markus Triska
Subject: bug#532: Acknowledgement (23.0.60; hang, then crash)
Date: Fri, 04 Jul 2008 21:02:20 +0200

I encountered a similar problem again; first Emacs hanged, and this time
I could un-block it by doing "pv proc" in the debugger, i.e., I tried to
inspect the value of the process Emacs was waiting for. From ps -A, I
saw that no aspell process was running, so it seems to me that Emacs
waits for output from a non-existing process here. In any case, after
Emacs ran again, it crashed a few seconds later. The complete backtrace:

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 0xee786: file sysdep.c, line 1297.
(gdb) r
Starting program: /Users/mt/emacs/src/emacs 
Reading symbols for shared libraries 
....................................................................+++..+.++.+..++.+.++++++++++++.++++.....+++
 done

Program exited normally.
(gdb) r
Starting program: /Users/mt/emacs/src/emacs 
Reading symbols for shared libraries .. done
^Z
Program received signal SIGTSTP, Stopped (user).
0x90001788 in __error ()
(gdb) bt full
#0  0x90001788 in __error ()
No symbol table info available.
#1  0x000ef5ee in emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3181
No locals.
#2  0x00181918 in read_process_output (proc=42462276, channel=0) at 
process.c:5322
        nbytes = -1
        outstream = 0
        old = (struct buffer *) 0x2a3b990
        p = (struct Lisp_Process *) 0x287ec40
        opoint = 0
        coding = (struct coding_system *) 0x2888ea0
        carryover = 0
#3  0x00188134 in wait_reading_process_output (time_limit=0, microsecs=0, 
read_kbd=0, do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, 
just_wait_proc=0) at process.c:4772
        nread = -1610559488
        total_nread = 0
        timeout_reduced_for_timers = 0
        channel = 109503590
        nfds = -1
        Available = {
  fds_bits = {0 <repeats 32 times>}
}
        Connecting = {
  fds_bits = {0 <repeats 32 times>}
}
        check_connect = 0
        check_delay = 0
        no_avail = 1
        xerrno = 0
        proc = 42462276
        timeout = {
  tv_sec = 100000, 
  tv_usec = 0
}
        end_time = {
  tv_sec = -1879027210, 
  tv_usec = 13
}
        wait_channel = 0
        got_some_input = 0
#4  0x00188f38 in Faccept_process_output (process=42462276, seconds=58721289, 
millisec=58721289, just_this_one=58721289) at process.c:4252
        secs = 0
        usecs = 0
        process = 42462276
        seconds = -1
        millisec = 0
#5  0x00144ac4 in Ffuncall (nargs=2, args=0xbfffec00) at eval.c:3052
        fun = -1073747072
        original_fun = 3069896
        funcar = -1
        numargs = 1
        val = -1879042184
        backtrace = {
  next = 0xbfffed14, 
  function = 0xbfffec00, 
  args = 0xbfffec04, 
  nargs = 1, 
  evalargs = 0 '\0', 
  debug_on_exit = 0 '\0'
}
        internal_args = (Lisp_Object *) 0xbfffeb80
        i = -1
        args = (Lisp_Object *) 0x2ed7c8
#6  0x0017dc57 in Fbyte_code (bytestr=95916739, vector=44150580, maxdepth=2) at 
bytecode.c:678
        op = -1610559488
        vectorp = (Lisp_Object *) 0x2a1af38
        stack = {
  pc = 0x5bf7f41 "address@hidden", 
  top = 0xbfffec04, 
  bottom = 0xbfffec00, 
  byte_string = 95916739, 
  byte_string_start = 0x5bf7f3c "address@hidden", 
  constants = 44150580, 
  next = 0xbfffeea4
}
        result = -1879042184
        bytestr = -1
#7  0x00143f72 in Feval (form=40689597) at eval.c:2383
        numargs = -1
        argvals = {95916739, 44150580, 16, 0, 0, 1026674, 1323343, 95916931}
        args_left = 58721289
        i = 3
        fun = -1879042184
        val = -1879042184
        original_fun = 58832137
        original_args = 40689589
        funcar = -1
        backtrace = {
  next = 0xbfffef6c, 
  function = 0xbfffed2c, 
  args = 0xbfffecf4, 
  nargs = 3, 
  evalargs = 1 '\001', 
  debug_on_exit = 0 '\0'
}
        form = 58721289
#8  0x0014655b in internal_lisp_condition_case (var=58721289, 
bodyform=40689597, handlers=40689453) at eval.c:1456
        val = -1
        c = {
  tag = 58721289, 
  val = 58721289, 
  next = 0xbffff278, 
  gcpro = 0x0, 
  jmp = {895, 1569345, 8096, 1336252, 3, 1328852, 96435557, 58721289, 
-1073746424, -1073746608, 42401823, 662, 1336418, 109379607, 58720287, 31, 
-1073807360, 55}, 
  backlist = 0xbfffef6c, 
  handlerlist = 0xbffff2ec, 
  lisp_eval_depth = 3, 
  pdlcount = 16, 
  poll_suppress_count = 1, 
  interrupt_input_blocked = 0, 
  byte_stack = 0xbfffeea4
}
        h = {
  handler = 40689453, 
  var = 58721289, 
  chosen_clause = -1073746396, 
  tag = 0xbfffed68, 
  next = 0xbffff2ec
}
#9  0x0017cb8d in Fbyte_code (bytestr=95882563, vector=44166084, maxdepth=5) at 
bytecode.c:868
        handlers = -1610559488
        body = -1
        op = -1610559488
        vectorp = (Lisp_Object *) 0x2a1ebc8
        stack = {
  pc = 0x5bf7d65 "\210\016&A\211\026&\204\372", 
  top = 0xbfffee20, 
  bottom = 0xbfffee20, 
  byte_string = 95882563, 
  byte_string_start = 0x5bf7c78 "\306 \210\212\307 
\210`\030\310\t!\032\311\211\033\034\311\211\035\036%\311\036&\n\311=\204,", 
  constants = 44166084, 
  next = 0xbffff024
}
        result = -1879042184
        bytestr = -1
#10 0x001443a7 in funcall_lambda (fun=44150772, nargs=0, arg_vector=0xbfffefb4) 
at eval.c:3229
        val = -1610559488
        syms_left = 44150768
        next = 44150768
        i = 0
        optional = 1
        rest = 0
#11 0x0014488a in Ffuncall (nargs=1, args=0xbfffefb0) at eval.c:3099
        fun = 44150772
        original_fun = 110157337
        funcar = -1
        numargs = 0
        val = -1879042184
        backtrace = {
  next = 0xbffff0ec, 
  function = 0xbfffefb0, 
  args = 0xbfffefb4, 
  nargs = 0, 
  evalargs = 0 '\0', 
  debug_on_exit = 0 '\0'
}
        internal_args = (Lisp_Object *) 0x2a1aff4
        i = -1
        args = (Lisp_Object *) 0x690de19
#12 0x0017dc57 in Fbyte_code (bytestr=95860259, vector=44112516, maxdepth=4) at 
bytecode.c:678
        op = -1610559488
        vectorp = (Lisp_Object *) 0x2a11a88
        stack = {
  pc = 0x5bf7ab7 "\210*\311 \203%", 
  top = 0xbfffefb0, 
  bottom = 0xbfffefb0, 
  byte_string = 95860259, 
  byte_string_start = 0x5bf7aa4 "\b\306\031\032\307 \203\025", 
  constants = 44112516, 
  next = 0x0
}
        result = -1879042184
        bytestr = -1
#13 0x001443a7 in funcall_lambda (fun=44109924, nargs=0, arg_vector=0xbffff190) 
at eval.c:3229
        val = -1610559488
        syms_left = 44109920
        next = 44109920
        i = 0
        optional = -1073745672
        rest = 109406212
#14 0x0014488a in Ffuncall (nargs=1, args=0xbffff18c) at eval.c:3099
        fun = 44109924
        original_fun = 110156649
        funcar = -1
        numargs = 0
        val = -1879042184
        backtrace = {
  next = 0xbffff1ec, 
  function = 0xbffff18c, 
  args = 0xbffff190, 
  nargs = 0, 
  evalargs = 0 '\0', 
  debug_on_exit = 0 '\0'
}
        internal_args = (Lisp_Object *) 0x2a11064
        i = -1
        args = (Lisp_Object *) 0x690db69
#15 0x00145e14 in run_hook_with_args (nargs=1, args=0xbffff18c, 
cond=to_completion) at eval.c:2701
        sym = 58751489
        val = -1879042184
        ret = 58721289
        globals = -1
#16 0x00145f9c in Frun_hooks (nargs=1, args=0xbffff244) at eval.c:2564
        hook = {110156649}
        i = 0
        nargs = 1
#17 0x00144a2f in Ffuncall (nargs=2, args=0xbffff240) at eval.c:3023
        fun = 3063148
        original_fun = -1073745340
        funcar = -1
        numargs = 1
        val = -1879042184
        backtrace = {
  next = 0x0, 
  function = 0xbffff240, 
  args = 0xbffff244, 
  nargs = 1, 
  evalargs = 0 '\0', 
  debug_on_exit = 0 '\0'
}
        internal_args = (Lisp_Object *) 0x2ebd6c
        i = -1
        args = (Lisp_Object *) 0xbffff244
#18 0x00145c9f in call1 (fn=58809001, arg1=58751489) at eval.c:2827
        ret_ungc_val = -1610559488
#19 0x000d6434 in safe_run_hooks_1 (hook=-1073745272) at keyboard.c:2152
No locals.
#20 0x00142c1c in internal_condition_case (bfun=0xd6402 <safe_run_hooks_1>, 
handlers=58721337, hfun=0xd643e <safe_run_hooks_error>) at eval.c:1511
        val = -1
        c = {
  tag = 58721289, 
  val = 58721289, 
  next = 0xbffff438, 
  gcpro = 0x0, 
  jmp = {-1073806465, 1250071, 8096, 1321771, -1073745192, 1250219, 3284528, 2, 
-1073745128, -1073745312, -1073807329, 662, 1321920, 1245207, 3276831, 31, 0, 
1310775}, 
  backlist = 0x0, 
  handlerlist = 0xbffff4ac, 
  lisp_eval_depth = 0, 
  pdlcount = 3, 
  poll_suppress_count = 1, 
  interrupt_input_blocked = 0, 
  byte_stack = 0x0
}
        h = {
  handler = 58721337, 
  var = 58721289, 
  chosen_clause = 58807000, 
  tag = 0xbffff278, 
  next = 0xbffff4ac
}
#21 0x000d5ac5 in safe_run_hooks (hook=58751489) at keyboard.c:2180
        hook = -1610559488
#22 0x000e3d46 in command_loop_1 () at keyboard.c:1929
        cmd = 3284528
        lose = 3284528
        nonundocount = 5
        keybuf = {256, 944, 944, 58721289, -1073744872, 903096, 41377949, 
-1073744946, -1073744904, -1879037169, 92274892, 152, -1073744946, 58721289, 
100663439, 1, 43, -1879036413, 51396120, 58721337, 51385976, -1881082098, 
5625428, 0, -1073744900, -1073745088, 0, 3342336, 58721289, 67060025}
        i = 1
        prev_modiff = 23
        prev_buffer = (struct buffer *) 0x2a3b990
        already_adjusted = 0
#23 0x00142c1c in internal_condition_case (bfun=0xe387e <command_loop_1>, 
handlers=58760929, hfun=0xdc6d9 <cmd_error>) at eval.c:1511
        val = -1
        c = {
  tag = 58721289, 
  val = 58721289, 
  next = 0xbffff53c, 
  gcpro = 0x0, 
  jmp = {895, 17831856, 8096, 1321771, 58721289, 58721289, 3297712, 3284528, 
-1073744680, -1073744864, 31, 658, 1321920, 1507351, 3276831, 3276831, 
-1073807360, -1073807305}, 
  backlist = 0x0, 
  handlerlist = 0x0, 
  lisp_eval_depth = 0, 
  pdlcount = 2, 
  poll_suppress_count = 1, 
  interrupt_input_blocked = 0, 
  byte_stack = 0x0
}
        h = {
  handler = 58760929, 
  var = 58721289, 
  chosen_clause = 58721337, 
  tag = 0xbffff438, 
  next = 0x0
}
#24 0x000d5830 in command_loop_2 () at keyboard.c:1367
        val = -1610559488
#25 0x0014286e in internal_catch (tag=58757001, func=0xd57ec <command_loop_2>, 
arg=58721289) at eval.c:1247
        c = {
  tag = 58757001, 
  val = 58721289, 
  next = 0x0, 
  gcpro = 0x0, 
  jmp = {895, 3, 8096, 1320914, 4, 20367, 3306688, 3284528, -1073744456, 
-1073744608, 58851359, 658, 1321057, 58851351, 58851359, 58720287, 51380224, 
55}, 
  backlist = 0x0, 
  handlerlist = 0x0, 
  lisp_eval_depth = 0, 
  pdlcount = 2, 
  poll_suppress_count = 1, 
  interrupt_input_blocked = 0, 
  byte_stack = 0x0
}
        tag = -1610559488
#26 0x000d55d2 in command_loop () at keyboard.c:1346
        val = -1610559488
#27 0x000d568b in recursive_edit_1 () at keyboard.c:955
        val = 0
#28 0x000d57d3 in Frecursive_edit () at keyboard.c:1017
        buffer = 58721289
#29 0x000d4813 in main (argc=1, argv=0xbffff7b8) at emacs.c:1762
        dummy = -1881117246
        stack_bottom_variable = 0 '\0'
        do_initial_setlocale = 1
        skip_args = 0
        rlim = {
  rlim_cur = 8388608, 
  rlim_max = 67108864
}
        no_loadup = 0
        junk = 0x0

Lisp Backtrace:
"accept-process-output" (0xbfffec04)
"byte-code" (0xbfffecf4)
"flyspell-word" (0xbfffefb4)
"flyspell-post-command-hook" (0xbffff190)
"run-hooks" (0xbffff244)
(gdb) c
Continuing.
^Z
Program received signal SIGTSTP, Stopped (user).
0x9000ffec in read ()
(gdb) s
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 stepping until exit from function cerror, 
which has no line number information.
emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3185
3185    }
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5324
5324          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5363      p->decoding_carryover = 0;
(gdb) 
5367      if (nbytes <= 0)
(gdb) 
5369          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5613    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, 
do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, just_wait_proc=0) at 
process.c:4774
4774                  if (nread == 0)
(gdb) 
4777                  if (0 < nread)
(gdb) 
4783                  else if (nread == -1 && EIO == errno)
(gdb) 
4787                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4791                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4770              while (wait_proc->infd >= 0)
(gdb) 
4772                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5267
5267      register struct buffer *old = current_buffer;
(gdb) 
5268      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
5270      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
5271      int carryover = p->decoding_carryover;
(gdb) 
5305      chars = (char *) alloca (carryover + readmax);
(gdb) 
5306      if (carryover)
(gdb) 
5312      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5320      if (proc_buffered_char[channel] < 0)
(gdb) 
5322          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3181
3181      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3185    }
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5324
5324          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5363      p->decoding_carryover = 0;
(gdb) 
5367      if (nbytes <= 0)
(gdb) 
5369          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5613    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, 
do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, just_wait_proc=0) at 
process.c:4774
4774                  if (nread == 0)
(gdb) 
4777                  if (0 < nread)
(gdb) 
4783                  else if (nread == -1 && EIO == errno)
(gdb) 
4787                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4791                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4770              while (wait_proc->infd >= 0)
(gdb) 
4772                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5267
5267      register struct buffer *old = current_buffer;
(gdb) 
5268      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
5270      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
5271      int carryover = p->decoding_carryover;
(gdb) 
5305      chars = (char *) alloca (carryover + readmax);
(gdb) 
5306      if (carryover)
(gdb) 
5312      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5320      if (proc_buffered_char[channel] < 0)
(gdb) 
5322          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3181
3181      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3185    }
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5324
5324          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5363      p->decoding_carryover = 0;
(gdb) 
5367      if (nbytes <= 0)
(gdb) 
5369          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5613    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, 
do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, just_wait_proc=0) at 
process.c:4774
4774                  if (nread == 0)
(gdb) 
4777                  if (0 < nread)
(gdb) 
4783                  else if (nread == -1 && EIO == errno)
(gdb) 
4787                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4791                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4770              while (wait_proc->infd >= 0)
(gdb) 
4772                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5267
5267      register struct buffer *old = current_buffer;
(gdb) 
5268      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
5270      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
5271      int carryover = p->decoding_carryover;
(gdb) 
5305      chars = (char *) alloca (carryover + readmax);
(gdb) 
5306      if (carryover)
(gdb) 
5312      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5320      if (proc_buffered_char[channel] < 0)
(gdb) 
5322          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3181
3181      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3185    }
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5324
5324          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5363      p->decoding_carryover = 0;
(gdb) 
5367      if (nbytes <= 0)
(gdb) 
5369          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5613    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, 
do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, just_wait_proc=0) at 
process.c:4774
4774                  if (nread == 0)
(gdb) 
4777                  if (0 < nread)
(gdb) 
4783                  else if (nread == -1 && EIO == errno)
(gdb) 
4787                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4791                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4770              while (wait_proc->infd >= 0)
(gdb) 
4772                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5267
5267      register struct buffer *old = current_buffer;
(gdb) 
5268      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
5270      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
5271      int carryover = p->decoding_carryover;
(gdb) 
5305      chars = (char *) alloca (carryover + readmax);
(gdb) 
5306      if (carryover)
(gdb) 
5312      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5320      if (proc_buffered_char[channel] < 0)
(gdb) 
5322          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3181
3181      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3185    }
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5324
5324          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5363      p->decoding_carryover = 0;
(gdb) 
5367      if (nbytes <= 0)
(gdb) 
5369          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5613    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, 
do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, just_wait_proc=0) at 
process.c:4774
4774                  if (nread == 0)
(gdb) 
4777                  if (0 < nread)
(gdb) 
4783                  else if (nread == -1 && EIO == errno)
(gdb) 
4787                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4791                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4770              while (wait_proc->infd >= 0)
(gdb) 
4772                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5267
5267      register struct buffer *old = current_buffer;
(gdb) 
5268      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
5270      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
5271      int carryover = p->decoding_carryover;
(gdb) 
5305      chars = (char *) alloca (carryover + readmax);
(gdb) 
5306      if (carryover)
(gdb) 
5312      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5320      if (proc_buffered_char[channel] < 0)
(gdb) 
5322          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3181
3181      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3185    }
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5324
5324          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5363      p->decoding_carryover = 0;
(gdb) 
5367      if (nbytes <= 0)
(gdb) 
5369          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5613    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, 
do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, just_wait_proc=0) at 
process.c:4774
4774                  if (nread == 0)
(gdb) 
4777                  if (0 < nread)
(gdb) 
4783                  else if (nread == -1 && EIO == errno)
(gdb) 
4787                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4791                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4770              while (wait_proc->infd >= 0)
(gdb) 
4772                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5267
5267      register struct buffer *old = current_buffer;
(gdb) 
5268      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
5270      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
5271      int carryover = p->decoding_carryover;
(gdb) 
5305      chars = (char *) alloca (carryover + readmax);
(gdb) 
5306      if (carryover)
(gdb) 
5312      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5320      if (proc_buffered_char[channel] < 0)
(gdb) 
5322          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3181
3181      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3185    }
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5324
5324          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5363      p->decoding_carryover = 0;
(gdb) 
5367      if (nbytes <= 0)
(gdb) 
5369          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5613    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, 
do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, just_wait_proc=0) at 
process.c:4774
4774                  if (nread == 0)
(gdb) 
4777                  if (0 < nread)
(gdb) 
4783                  else if (nread == -1 && EIO == errno)
(gdb) 
4787                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4791                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4770              while (wait_proc->infd >= 0)
(gdb) 
4772                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5267
5267      register struct buffer *old = current_buffer;
(gdb) 
5268      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
5270      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
5271      int carryover = p->decoding_carryover;
(gdb) 
5305      chars = (char *) alloca (carryover + readmax);
(gdb) 
5306      if (carryover)
(gdb) 
5312      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5320      if (proc_buffered_char[channel] < 0)
(gdb) 
5322          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3181
3181      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3185    }
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5324
5324          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5363      p->decoding_carryover = 0;
(gdb) 
5367      if (nbytes <= 0)
(gdb) 
5369          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5613    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, 
do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, just_wait_proc=0) at 
process.c:4774
4774                  if (nread == 0)
(gdb) 
4777                  if (0 < nread)
(gdb) 
4783                  else if (nread == -1 && EIO == errno)
(gdb) 
4787                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4791                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4770              while (wait_proc->infd >= 0)
(gdb) 
4772                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5267
5267      register struct buffer *old = current_buffer;
(gdb) 
5268      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
5270      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
5271      int carryover = p->decoding_carryover;
(gdb) 
5305      chars = (char *) alloca (carryover + readmax);
(gdb) 
5306      if (carryover)
(gdb) 
5312      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5320      if (proc_buffered_char[channel] < 0)
(gdb) 
5322          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3181
3181      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3185    }
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5324
5324          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5363      p->decoding_carryover = 0;
(gdb) 
5367      if (nbytes <= 0)
(gdb) 
5369          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5613    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, 
do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, just_wait_proc=0) at 
process.c:4774
4774                  if (nread == 0)
(gdb) 
4777                  if (0 < nread)
(gdb) 
4783                  else if (nread == -1 && EIO == errno)
(gdb) 
4787                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4791                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4770              while (wait_proc->infd >= 0)
(gdb) 
4772                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5267
5267      register struct buffer *old = current_buffer;
(gdb) 
5268      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
5270      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
5271      int carryover = p->decoding_carryover;
(gdb) 
5305      chars = (char *) alloca (carryover + readmax);
(gdb) 
5306      if (carryover)
(gdb) 
5312      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5320      if (proc_buffered_char[channel] < 0)
(gdb) 
5322          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3181
3181      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3185    }
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5324
5324          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5363      p->decoding_carryover = 0;
(gdb) 
5367      if (nbytes <= 0)
(gdb) 
5369          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5613    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, 
do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, just_wait_proc=0) at 
process.c:4774
4774                  if (nread == 0)
(gdb) 
4777                  if (0 < nread)
(gdb) 
4783                  else if (nread == -1 && EIO == errno)
(gdb) 
4787                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4791                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 

4770              while (wait_proc->infd >= 0)
(gdb) 
4772                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5267
5267      register struct buffer *old = current_buffer;
(gdb) 
5268      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
5270      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
5271      int carryover = p->decoding_carryover;
(gdb) 
5305      chars = (char *) alloca (carryover + readmax);
(gdb) 
5306      if (carryover)
(gdb) 
5312      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5320      if (proc_buffered_char[channel] < 0)
(gdb) 
5322          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3181
3181      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3185    }
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5324
5324          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5363      p->decoding_carryover = 0;
(gdb) 
5367      if (nbytes <= 0)
(gdb) 
5369          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5613    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, 
do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, just_wait_proc=0) at 
process.c:4774
4774                  if (nread == 0)
(gdb) 
4777                  if (0 < nread)
(gdb) 
4783                  else if (nread == -1 && EIO == errno)
(gdb) 
4787                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4791                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4770              while (wait_proc->infd >= 0)
(gdb) 
4772                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5267
5267      register struct buffer *old = current_buffer;
(gdb) 
5268      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
5270      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
5271      int carryover = p->decoding_carryover;
(gdb) 
5305      chars = (char *) alloca (carryover + readmax);
(gdb) 
5306      if (carryover)
(gdb) 
5312      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5320      if (proc_buffered_char[channel] < 0)
(gdb) 
5322          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3181
3181      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3185    }
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5324
5324          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5363      p->decoding_carryover = 0;
(gdb) 
5367      if (nbytes <= 0)
(gdb) 
5369          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5613    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, 
do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, just_wait_proc=0) at 
process.c:4774
4774                  if (nread == 0)
(gdb) 
4777                  if (0 < nread)
(gdb) 
4783                  else if (nread == -1 && EIO == errno)
(gdb) 
4787                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4791                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4770              while (wait_proc->infd >= 0)
(gdb) 
4772                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5267
5267      register struct buffer *old = current_buffer;
(gdb) 
5268      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
5270      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
5271      int carryover = p->decoding_carryover;
(gdb) 
5305      chars = (char *) alloca (carryover + readmax);
(gdb) 
5306      if (carryover)
(gdb) 
5312      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5320      if (proc_buffered_char[channel] < 0)
(gdb) 
5322          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3181
3181      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3185    }
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5324
5324          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5363      p->decoding_carryover = 0;
(gdb) 
5367      if (nbytes <= 0)
(gdb) 
5369          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5613    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, 
do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, just_wait_proc=0) at 
process.c:4774
4774                  if (nread == 0)
(gdb) 
4777                  if (0 < nread)
(gdb) 
4783                  else if (nread == -1 && EIO == errno)
(gdb) 
4787                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4791                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4770              while (wait_proc->infd >= 0)
(gdb) 
4772                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5267
5267      register struct buffer *old = current_buffer;
(gdb) 
5268      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
5270      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
5271      int carryover = p->decoding_carryover;
(gdb) 
5305      chars = (char *) alloca (carryover + readmax);
(gdb) 
5306      if (carryover)
(gdb) 
5312      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5320      if (proc_buffered_char[channel] < 0)
(gdb) 
5322          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3181
3181      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3185    }
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5324
5324          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5363      p->decoding_carryover = 0;
(gdb) 
5367      if (nbytes <= 0)
(gdb) 
5369          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5613    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, 
do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, just_wait_proc=0) at 
process.c:4774
4774                  if (nread == 0)
(gdb) 
4777                  if (0 < nread)
(gdb) 
4783                  else if (nread == -1 && EIO == errno)
(gdb) 
4787                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4791                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4770              while (wait_proc->infd >= 0)
(gdb) 
4772                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5267
5267      register struct buffer *old = current_buffer;
(gdb) 
5268      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
5270      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
5271      int carryover = p->decoding_carryover;
(gdb) 
5305      chars = (char *) alloca (carryover + readmax);
(gdb) 
5306      if (carryover)
(gdb) 
5312      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5320      if (proc_buffered_char[channel] < 0)
(gdb) 
5322          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3181
3181      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3185    }
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5324
5324          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5363      p->decoding_carryover = 0;
(gdb) 
5367      if (nbytes <= 0)
(gdb) 
5369          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5613    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, 
do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, just_wait_proc=0) at 
process.c:4774
4774                  if (nread == 0)
(gdb) 
4777                  if (0 < nread)
(gdb) 
4783                  else if (nread == -1 && EIO == errno)
(gdb) 
4787                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4791                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4770              while (wait_proc->infd >= 0)
(gdb) 
4772                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5267
5267      register struct buffer *old = current_buffer;
(gdb) 
5268      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
5270      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
5271      int carryover = p->decoding_carryover;
(gdb) 
5305      chars = (char *) alloca (carryover + readmax);
(gdb) 
5306      if (carryover)
(gdb) 
5312      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5320      if (proc_buffered_char[channel] < 0)
(gdb) 
5322          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3181
3181      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3185    }
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5324
5324          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5363      p->decoding_carryover = 0;
(gdb) 
5367      if (nbytes <= 0)
(gdb) 
5369          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5613    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, 
do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, just_wait_proc=0) at 
process.c:4774
4774                  if (nread == 0)
(gdb) 
4777                  if (0 < nread)
(gdb) 
4783                  else if (nread == -1 && EIO == errno)
(gdb) 
4787                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4791                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4770              while (wait_proc->infd >= 0)
(gdb) 
4772                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5267
5267      register struct buffer *old = current_buffer;
(gdb) 
5268      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
5270      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
5271      int carryover = p->decoding_carryover;
(gdb) 
5305      chars = (char *) alloca (carryover + readmax);
(gdb) 
5306      if (carryover)
(gdb) 
5312      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5320      if (proc_buffered_char[channel] < 0)
(gdb) 
5322          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3181
3181      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3185    }
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5324
5324          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5363      p->decoding_carryover = 0;
(gdb) 
5367      if (nbytes <= 0)
(gdb) 
5369          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5613    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, 
do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, just_wait_proc=0) at 
process.c:4774
4774                  if (nread == 0)
(gdb) 
4777                  if (0 < nread)
(gdb) 
4783                  else if (nread == -1 && EIO == errno)
(gdb) 
4787                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4791                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4770              while (wait_proc->infd >= 0)
(gdb) 
4772                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5267
5267      register struct buffer *old = current_buffer;
(gdb) 
5268      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
5270      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
5271      int carryover = p->decoding_carryover;
(gdb) 
5305      chars = (char *) alloca (carryover + readmax);
(gdb) 
5306      if (carryover)
(gdb) 
5312      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5320      if (proc_buffered_char[channel] < 0)
(gdb) 
5322          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3181
3181      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3185    }
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5324
5324          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5363      p->decoding_carryover = 0;
(gdb) 
5367      if (nbytes <= 0)
(gdb) 
5369          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5613    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, 
do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, just_wait_proc=0) at 
process.c:4774
4774                  if (nread == 0)
(gdb) 
4777                  if (0 < nread)
(gdb) 
4783                  else if (nread == -1 && EIO == errno)
(gdb) 
4787                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4791                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4770              while (wait_proc->infd >= 0)
(gdb) 
4772                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5267
5267      register struct buffer *old = current_buffer;
(gdb) 
5268      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
5270      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
5271      int carryover = p->decoding_carryover;
(gdb) 
5305      chars = (char *) alloca (carryover + readmax);
(gdb) 
5306      if (carryover)
(gdb) 
5312      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5320      if (proc_buffered_char[channel] < 0)
(gdb) 
5322          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3181
3181      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3185    }
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5324
5324          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5363      p->decoding_carryover = 0;
(gdb) 
5367      if (nbytes <= 0)
(gdb) 
5369          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5613    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, 
do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, just_wait_proc=0) at 
process.c:4774
4774                  if (nread == 0)
(gdb) 
4777                  if (0 < nread)
(gdb) 
4783                  else if (nread == -1 && EIO == errno)
(gdb) 
4787                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4791                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4770              while (wait_proc->infd >= 0)
(gdb) 
4772                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5267
5267      register struct buffer *old = current_buffer;
(gdb) 
5268      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
5270      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
5271      int carryover = p->decoding_carryover;
(gdb) 
5305      chars = (char *) alloca (carryover + readmax);
(gdb) 
5306      if (carryover)
(gdb) 
5312      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5320      if (proc_buffered_char[channel] < 0)
(gdb) 
5322          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3181
3181      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3185    }
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5324
5324          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5363      p->decoding_carryover = 0;
(gdb) 
5367      if (nbytes <= 0)
(gdb) 
5369          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5613    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, 
do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, just_wait_proc=0) at 
process.c:4774
4774                  if (nread == 0)
(gdb) 
4777                  if (0 < nread)
(gdb) 
4783                  else if (nread == -1 && EIO == errno)
(gdb) 
4787                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4791                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4770              while (wait_proc->infd >= 0)
(gdb) 
4772                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5267
5267      register struct buffer *old = current_buffer;
(gdb) 
5268      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
5270      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
5271      int carryover = p->decoding_carryover;
(gdb) 
5305      chars = (char *) alloca (carryover + readmax);
(gdb) 
5306      if (carryover)
(gdb) 
5312      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5320      if (proc_buffered_char[channel] < 0)
(gdb) 
5322          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3181
3181      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3185    }
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5324
5324          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5363      p->decoding_carryover = 0;
(gdb) 
5367      if (nbytes <= 0)
(gdb) 
5369          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5613    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, 
do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, just_wait_proc=0) at 
process.c:4774
4774                  if (nread == 0)
(gdb) 
4777                  if (0 < nread)
(gdb) 
4783                  else if (nread == -1 && EIO == errno)
(gdb) 
4787                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4791                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4770              while (wait_proc->infd >= 0)
(gdb) 
4772                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5267
5267      register struct buffer *old = current_buffer;
(gdb) 
5268      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
5270      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
5271      int carryover = p->decoding_carryover;
(gdb) 
5305      chars = (char *) alloca (carryover + readmax);
(gdb) 
5306      if (carryover)
(gdb) 
5312      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5320      if (proc_buffered_char[channel] < 0)
(gdb) 
5322          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3181
3181      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3185    }
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5324
5324          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5363      p->decoding_carryover = 0;
(gdb) 
5367      if (nbytes <= 0)
(gdb) 
5369          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5613    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, 
do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, just_wait_proc=0) at 
process.c:4774
4774                  if (nread == 0)
(gdb) 
4777                  if (0 < nread)
(gdb) 
4783                  else if (nread == -1 && EIO == errno)
(gdb) 
4787                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4791                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4770              while (wait_proc->infd >= 0)
(gdb) 
4772                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5267
5267      register struct buffer *old = current_buffer;
(gdb) 
5268      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
5270      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
5271      int carryover = p->decoding_carryover;
(gdb) 
5305      chars = (char *) alloca (carryover + readmax);
(gdb) 
5306      if (carryover)
(gdb) 
5312      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5320      if (proc_buffered_char[channel] < 0)
(gdb) 
5322          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3181
3181      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3185    }
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5324
5324          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5363      p->decoding_carryover = 0;
(gdb) 
5367      if (nbytes <= 0)
(gdb) 
5369          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5613    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, 
do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, just_wait_proc=0) at 
process.c:4774
4774                  if (nread == 0)
(gdb) 
4777                  if (0 < nread)
(gdb) 
4783                  else if (nread == -1 && EIO == errno)
(gdb) 
4787                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4791                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4770              while (wait_proc->infd >= 0)
(gdb) 
4772                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5267
5267      register struct buffer *old = current_buffer;
(gdb) 
5268      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
5270      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
5271      int carryover = p->decoding_carryover;
(gdb) 
5305      chars = (char *) alloca (carryover + readmax);
(gdb) 
5306      if (carryover)
(gdb) 
5312      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5320      if (proc_buffered_char[channel] < 0)
(gdb) 
5322          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3181
3181      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3185    }
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5324
5324          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5363      p->decoding_carryover = 0;
(gdb) 
5367      if (nbytes <= 0)
(gdb) 
5369          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5613    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, 
do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, just_wait_proc=0) at 
process.c:4774
4774                  if (nread == 0)
(gdb) 
4777                  if (0 < nread)
(gdb) 
4783                  else if (nread == -1 && EIO == errno)
(gdb) 
4787                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4791                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4770              while (wait_proc->infd >= 0)
(gdb) 
4772                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5267
5267      register struct buffer *old = current_buffer;
(gdb) 
5268      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
5270      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
5271      int carryover = p->decoding_carryover;
(gdb) 
5305      chars = (char *) alloca (carryover + readmax);
(gdb) 
5306      if (carryover)
(gdb) 
5312      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5320      if (proc_buffered_char[channel] < 0)
(gdb) 
5322          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3181
3181      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3185    }
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5324
5324          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5363      p->decoding_carryover = 0;
(gdb) 
5367      if (nbytes <= 0)
(gdb) 
5369          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5613    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, 
do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, just_wait_proc=0) at 
process.c:4774
4774                  if (nread == 0)
(gdb) 
4777                  if (0 < nread)
(gdb) 
4783                  else if (nread == -1 && EIO == errno)
(gdb) 
4787                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4791                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4770              while (wait_proc->infd >= 0)
(gdb) 
4772                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5267
5267      register struct buffer *old = current_buffer;
(gdb) 
5268      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
5270      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
5271      int carryover = p->decoding_carryover;
(gdb) 
5305      chars = (char *) alloca (carryover + readmax);
(gdb) 
5306      if (carryover)
(gdb) 
5312      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5320      if (proc_buffered_char[channel] < 0)
(gdb) 
5322          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3181
3181      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3185    }
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5324
5324          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5363      p->decoding_carryover = 0;
(gdb) 
5367      if (nbytes <= 0)
(gdb) 
5369          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5613    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, 
do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, just_wait_proc=0) at 
process.c:4774
4774                  if (nread == 0)
(gdb) 
4777                  if (0 < nread)
(gdb) 
4783                  else if (nread == -1 && EIO == errno)
(gdb) 
4787                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4791                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4770              while (wait_proc->infd >= 0)
(gdb) 
4772                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5267
5267      register struct buffer *old = current_buffer;
(gdb) 
5268      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
5270      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
5271      int carryover = p->decoding_carryover;
(gdb) 
5305      chars = (char *) alloca (carryover + readmax);
(gdb) 
5306      if (carryover)
(gdb) 
5312      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5320      if (proc_buffered_char[channel] < 0)
(gdb) 
5322          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3181
3181      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3185    }
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5324
5324          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5363      p->decoding_carryover = 0;
(gdb) 
5367      if (nbytes <= 0)
(gdb) 
5369          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5613    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, 
do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, just_wait_proc=0) at 
process.c:4774
4774                  if (nread == 0)
(gdb) 
4777                  if (0 < nread)
(gdb) 
4783                  else if (nread == -1 && EIO == errno)
(gdb) 
4787                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4791                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4770              while (wait_proc->infd >= 0)
(gdb) 
4772                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5267
5267      register struct buffer *old = current_buffer;
(gdb) 
5268      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
5270      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
5271      int carryover = p->decoding_carryover;
(gdb) 
5305      chars = (char *) alloca (carryover + readmax);
(gdb) 
5306      if (carryover)
(gdb) 
5312      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5320      if (proc_buffered_char[channel] < 0)
(gdb) 
5322          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3181
3181      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3185    }
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5324
5324          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5363      p->decoding_carryover = 0;
(gdb) 
5367      if (nbytes <= 0)
(gdb) 
5369          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5613    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, 
do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, just_wait_proc=0) at 
process.c:4774
4774                  if (nread == 0)
(gdb) 
4777                  if (0 < nread)
(gdb) 
4783                  else if (nread == -1 && EIO == errno)
(gdb) 
4787                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4791                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4770              while (wait_proc->infd >= 0)
(gdb) 
4772                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5267
5267      register struct buffer *old = current_buffer;
(gdb) 
5268      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
5270      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
5271      int carryover = p->decoding_carryover;
(gdb) 
5305      chars = (char *) alloca (carryover + readmax);
(gdb) 
5306      if (carryover)
(gdb) 
5312      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5320      if (proc_buffered_char[channel] < 0)
(gdb) 
5322          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3181
3181      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3185    }
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5324
5324          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5363      p->decoding_carryover = 0;
(gdb) 
5367      if (nbytes <= 0)
(gdb) 
5369          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5613    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, 
do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, just_wait_proc=0) at 
process.c:4774
4774                  if (nread == 0)
(gdb) 
4777                  if (0 < nread)
(gdb) 
4783                  else if (nread == -1 && EIO == errno)
(gdb) 
4787                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4791                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4770              while (wait_proc->infd >= 0)
(gdb) 
4772                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5267
5267      register struct buffer *old = current_buffer;
(gdb) 
5268      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
5270      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
5271      int carryover = p->decoding_carryover;
(gdb) 
5305      chars = (char *) alloca (carryover + readmax);
(gdb) 
5306      if (carryover)
(gdb) 
5312      if (DATAGRAM_CHAN_P (channel))
(gdb) 
5320      if (proc_buffered_char[channel] < 0)
(gdb) 
5322          nbytes = emacs_read (channel, chars + carryover, readmax);
(gdb) 
emacs_read (fildes=0, buf=0xbfffd780 
"\t\004\200\003\t\004\200\003\t\004\200\003\b\253\002", nbyte=4096) at 
sysdep.c:3181
3181      while ((rtnval = read (fildes, buf, nbyte)) == -1
(gdb) 
3185    }
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5324
5324          if (nbytes > 0 && p->adaptive_read_buffering)
(gdb) 
5363      p->decoding_carryover = 0;
(gdb) 
5367      if (nbytes <= 0)
(gdb) 
5369          if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
(gdb) 
5613    }
(gdb) 
wait_reading_process_output (time_limit=0, microsecs=0, read_kbd=0, 
do_display=0, wait_for_cell=58721289, wait_proc=0x287ec40, just_wait_proc=0) at 
process.c:4774
4774                  if (nread == 0)
(gdb) 
4777                  if (0 < nread)
(gdb) 
4783                  else if (nread == -1 && EIO == errno)
(gdb) 
4787                  else if (nread == -1 && EAGAIN == errno)
(gdb) 
4791                  else if (nread == -1 && EWOULDBLOCK == errno)
(gdb) 
4770              while (wait_proc->infd >= 0)
(gdb) 
4772                  nread = read_process_output (proc, wait_proc->infd);
(gdb) 
read_process_output (proc=42462276, channel=0) at process.c:5267
5267      register struct buffer *old = current_buffer;
(gdb) 
5268      register struct Lisp_Process *p = XPROCESS (proc);
(gdb) 
5270      struct coding_system *coding = proc_decode_coding_system[channel];
(gdb) 
5271      int carryover = p->decoding_carryover;
(gdb) 
5305      chars = (char *) alloca (carryover + readmax);
(gdb) 
5306      if (carryover)
(gdb) pv proc

^A^A 
Program received signal EXC_BAD_ACCESS, Could not access memory.
Reason: KERN_INVALID_ADDRESS at address: 0x02944fff
0x0016a3ad in char_quoted (charpos=1, bytepos=43274239) at syntax.c:301
301       DEC_BOTH (charpos, bytepos);
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 (safe_debug_print) will be 
abandoned.
(gdb)  c
Continuing.

Program received signal EXC_BAD_ACCESS, Could not access memory.
Reason: KERN_INVALID_ADDRESS at address: 0x02944fff
0x0016a3ad in char_quoted (charpos=1, bytepos=43274239) at syntax.c:301
301       DEC_BOTH (charpos, bytepos);
(gdb) bt full
#0  0x0016a3ad in char_quoted (charpos=1, bytepos=43274239) at syntax.c:301
        p = (unsigned char *) 0x2944fff <Address 0x2944fff out of bounds>
        beg = 1
        quoted = 0
#1  0x0016f977 in Fbackward_prefix_chars () at syntax.c:2883
        beg = 1
        opoint = 2
        opoint_byte = 2
        pos = 3284528
        pos_byte = 44299280
        c = 58721289
#2  0x00144b50 in Ffuncall (nargs=1, args=0xbfffe950) at eval.c:3039
        fun = -1073747628
        original_fun = 3068760
        funcar = 43274239
        numargs = 0
        val = 44299280
        backtrace = {
  next = 0xbfffea8c, 
  function = 0xbfffe950, 
  args = 0xbfffe954, 
  nargs = 0, 
  evalargs = 0 '\0', 
  debug_on_exit = 0 '\0'
}
        internal_args = (Lisp_Object *) 0xbfffe954
        i = 43274239
        args = (Lisp_Object *) 0x2ed358
#3  0x0017dc57 in Fbyte_code (bytestr=2163507, vector=2163524, maxdepth=3) at 
bytecode.c:678
        op = 43274240
        vectorp = (Lisp_Object *) 0x210348
        stack = {
  pc = 0x2af9aa "\207", 
  top = 0xbfffe950, 
  bottom = 0xbfffe950, 
  byte_string = 2163507, 
  byte_string_start = 0x2af99e "\300\301!\210\302\303\304 \"\210\305 \207", 
  constants = 2163524, 
  next = 0xbfffeb54
}
        result = 44299280
        bytestr = 43274239
#4  0x001443a7 in funcall_lambda (fun=2163476, nargs=0, arg_vector=0xbfffead4) 
at eval.c:3229
        val = 43274240
        syms_left = 2163472
        next = 2163472
        i = 0
        optional = -1073747224
        rest = 44299280
#5  0x0014488a in Ffuncall (nargs=1, args=0xbfffead0) at eval.c:3099
        fun = 2163476
        original_fun = 66924649
        funcar = 43274239
        numargs = 0
        val = 44299280
        backtrace = {
  next = 0xbfffec1c, 
  function = 0xbfffead0, 
  args = 0xbfffead4, 
  nargs = 0, 
  evalargs = 0 '\0', 
  debug_on_exit = 0 '\0'
}
        internal_args = (Lisp_Object *) 0x210314
        i = 43274239
        args = (Lisp_Object *) 0x3fd3069
#6  0x0017dc57 in Fbyte_code (bytestr=2298267, vector=2298284, maxdepth=5) at 
bytecode.c:678
        op = 43274240
        vectorp = (Lisp_Object *) 0x2311b0
        stack = {
  pc = 0x29bd52 "\210\302\b\303m\203\024", 
  top = 0xbfffead0, 
  bottom = 0xbfffead0, 
  byte_string = 2298267, 
  byte_string_start = 0x29bd4f "\212\301 \210\302\b\303m\203\024", 
  constants = 2298284, 
  next = 0xbfffecd4
}
        result = 44299280
        bytestr = 43274239
#7  0x001443a7 in funcall_lambda (fun=2298236, nargs=0, arg_vector=0xbfffec64) 
at eval.c:3229
        val = 43274240
        syms_left = 2298232
        next = 2298232
        i = 0
        optional = -1073746984
        rest = 1045451
#8  0x0014488a in Ffuncall (nargs=1, args=0xbfffec60) at eval.c:3099
        fun = 2298236
        original_fun = 75603017
        funcar = 43274239
        numargs = 0
        val = 44299280
        backtrace = {
  next = 0xbfffed9c, 
  function = 0xbfffec60, 
  args = 0xbfffec64, 
  nargs = 0, 
  evalargs = 0 '\0', 
  debug_on_exit = 0 '\0'
}
        internal_args = (Lisp_Object *) 0x23117c
        i = 43274239
        args = (Lisp_Object *) 0x4819c49
#9  0x0017dc57 in Fbyte_code (bytestr=2298363, vector=2298380, maxdepth=3) at 
bytecode.c:678
        op = 43274240
        vectorp = (Lisp_Object *) 0x231210
        stack = {
  pc = 0x29bd29 "i\031\032\t\nV\2037", 
  top = 0xbfffec60, 
  bottom = 0xbfffec60, 
  byte_string = 2298363, 
  byte_string_start = 0x29bd09 "\304\b!\210\305\306w\210\307p!\203\036", 
  constants = 2298380, 
  next = 0xbfffee64
}
        result = 44299280
        bytestr = 43274239
#10 0x001443a7 in funcall_lambda (fun=2298308, nargs=2, arg_vector=0xbfffede4) 
at eval.c:3229
        val = 43274240
        syms_left = 2298304
        next = 2298304
        i = 2
        optional = 1
        rest = 0
#11 0x0014488a in Ffuncall (nargs=3, args=0xbfffede0) at eval.c:3099
        fun = 2298308
        original_fun = 75603041
        funcar = 43274239
        numargs = 2
        val = 44299280
        backtrace = {
  next = 0xbfffef2c, 
  function = 0xbfffede0, 
  args = 0xbfffede4, 
  nargs = 2, 
  evalargs = 0 '\0', 
  debug_on_exit = 0 '\0'
}
        internal_args = (Lisp_Object *) 0x2311c4
        i = 43274239
        args = (Lisp_Object *) 0x4819c61
#12 0x0017dc57 in Fbyte_code (bytestr=2161363, vector=2161380, maxdepth=5) at 
bytecode.c:678
        op = 43274240
        vectorp = (Lisp_Object *) 0x20fae8
        stack = {
  pc = 0x2afdb9 "\210+\335\207", 
  top = 0xbfffede8, 
  bottom = 0xbfffede0, 
  byte_string = 2161363, 
  byte_string_start = 0x2afcec "\306 \210o?\205i", 
  constants = 2161380, 
  next = 0xbfffefe4
}
        result = 44299280
        bytestr = 43274239
#13 0x001443a7 in funcall_lambda (fun=2161316, nargs=0, arg_vector=0xbfffef74) 
at eval.c:3229
        val = 43274240
        syms_left = 2161312
        next = 2161312
        i = 0
        optional = 1
        rest = 0
#14 0x0014488a in Ffuncall (nargs=1, args=0xbfffef70) at eval.c:3099
        fun = 2161316
        original_fun = 66907081
        funcar = 43274239
        numargs = 0
        val = 44299280
        backtrace = {
  next = 0xbffff0ac, 
  function = 0xbfffef70, 
  args = 0xbfffef74, 
  nargs = 0, 
  evalargs = 0 '\0', 
  debug_on_exit = 0 '\0'
}
        internal_args = (Lisp_Object *) 0x20faa4
        i = 43274239
        args = (Lisp_Object *) 0x3fcebc9
#15 0x0017dc57 in Fbyte_code (bytestr=2162891, vector=2162908, maxdepth=2) at 
bytecode.c:678
        op = 43274240
        vectorp = (Lisp_Object *) 0x2100e0
        stack = {
  pc = 0x2afa8b "\210\303 \207", 
  top = 0xbfffef70, 
  bottom = 0xbfffef70, 
  byte_string = 2162891, 
  byte_string_start = 0x2afa85 "\300\301!\210\302 \210\303 \207", 
  constants = 2162908, 
  next = 0x0
}
        result = 44299280
        bytestr = 43274239
#16 0x001443a7 in funcall_lambda (fun=2162860, nargs=0, arg_vector=0xbffff144) 
at eval.c:3229
        val = 43274240
        syms_left = 2162856
        next = 2162856
        i = 0
        optional = 1360858
        rest = 1250071
#17 0x0014488a in Ffuncall (nargs=1, args=0xbffff140) at eval.c:3099
        fun = 2162860
        original_fun = 66907057
        funcar = 43274239
        numargs = 0
        val = 44299280
        backtrace = {
  next = 0xbffff2ec, 
  function = 0xbffff140, 
  args = 0xbffff144, 
  nargs = 0, 
  evalargs = 0 '\0', 
  debug_on_exit = 0 '\0'
}
        internal_args = (Lisp_Object *) 0x2100ac
        i = 43274239
        args = (Lisp_Object *) 0x3fcebb1
#18 0x00140f6a in Fcall_interactively (function=66907057, record_flag=58721289, 
keys=51388540) at callint.c:857
        val = 43274240
        specs = -1073745340
        filter_specs = 2162931
        teml = 58761289
        up_event = 58721289
        enable = 58721289
        next_event = 1
        prefix_arg = 58721289
        string = (unsigned char *) 0xbffff161 ""
        tem = (unsigned char *) 0x2944fff <Address 0x2944fff out of bounds>
        i = 44299280
        j = 0
        foo = -1073745567
        prompt1 = 
"\000\000\000\0001v\200\003M\375\005\002X\362\377\277\376\310\030\000 
address@hidden", '\0' <repeats 11 times>
        arg_from_tty = 0
        key_count = 1
        record_then_fail = 0
        save_this_command = 66907057
        save_last_command = 58761289
        save_this_original_command = 66907057
        save_real_this_command = 66907057
#19 0x00144a9d in Ffuncall (nargs=4, args=0xbffff340) at eval.c:3048
        fun = -1073745084
        original_fun = 58832329
        funcar = 43274239
        numargs = 3
        val = 44299280
        backtrace = {
  next = 0x0, 
  function = 0xbffff340, 
  args = 0xbffff344, 
  nargs = 3, 
  evalargs = 0 '\0', 
  debug_on_exit = 0 '\0'
}
        internal_args = (Lisp_Object *) 0xbffff344
        i = 43274239
        args = (Lisp_Object *) 0x381b5c9
#20 0x00144c39 in call3 (fn=58832329, arg1=66907057, arg2=58721289, 
arg3=58721289) at eval.c:2872
        ret_ungc_val = 43274240
#21 0x000e3cdd in command_loop_1 () at keyboard.c:1910
        cmd = 2
        lose = 2
        nonundocount = 0
        keybuf = {104, 784, 3307184, 58721289, -1073744872, 903096, 39280077, 
-1073744946, -1073744904, -1879037169, 92274892, 152, -1073744946, 58721289, 
100663439, 1, 43, -1879036413, 51396120, 58721337, 51385976, -1881082098, 
5625428, 0, -1073744900, -1073745088, 0, 3342336, 58721289, 67060025}
        i = 1
        prev_modiff = 63
        prev_buffer = (struct buffer *) 0x2a3f410
        already_adjusted = 0
#22 0x00142c1c in internal_condition_case (bfun=0xe387e <command_loop_1>, 
handlers=58760929, hfun=0xdc6d9 <cmd_error>) at eval.c:1511
        val = 43274239
        c = {
  tag = 58721289, 
  val = 58721289, 
  next = 0xbffff53c, 
  gcpro = 0x0, 
  jmp = {895, 17831856, 8096, 1321771, 58721289, 58721289, 3297712, 3284528, 
-1073744680, -1073744864, 31, 658, 1321920, 1507351, 3276831, 3276831, 
-1073807360, -1073807305}, 
  backlist = 0x0, 
  handlerlist = 0x0, 
  lisp_eval_depth = 0, 
  pdlcount = 2, 
  poll_suppress_count = 1, 
  interrupt_input_blocked = 0, 
  byte_stack = 0x0
}
        h = {
  handler = 58760929, 
  var = 58721289, 
  chosen_clause = 58721337, 
  tag = 0xbffff438, 
  next = 0x0
}
#23 0x000d5830 in command_loop_2 () at keyboard.c:1367
        val = 43274240
#24 0x0014286e in internal_catch (tag=58757001, func=0xd57ec <command_loop_2>, 
arg=58721289) at eval.c:1247
        c = {
  tag = 58757001, 
  val = 58721289, 
  next = 0x0, 
  gcpro = 0x0, 
  jmp = {895, 3, 8096, 1320914, 4, 20367, 3306688, 3284528, -1073744456, 
-1073744608, 58851359, 658, 1321057, 58851351, 58851359, 58720287, 51380224, 
55}, 
  backlist = 0x0, 
  handlerlist = 0x0, 
  lisp_eval_depth = 0, 
  pdlcount = 2, 
  poll_suppress_count = 1, 
  interrupt_input_blocked = 0, 
  byte_stack = 0x0
}
        tag = 43274240
#25 0x000d55d2 in command_loop () at keyboard.c:1346
        val = 43274240
#26 0x000d568b in recursive_edit_1 () at keyboard.c:955
        val = 0
#27 0x000d57d3 in Frecursive_edit () at keyboard.c:1017
        buffer = 58721289
#28 0x000d4813 in main (argc=1, argv=0xbffff7b8) at emacs.c:1762
        dummy = -1881117246
        stack_bottom_variable = 0 '\0'
        do_initial_setlocale = 1
        skip_args = 0
        rlim = {
  rlim_cur = 8388608, 
  rlim_max = 67108864
}
        no_loadup = 0
        junk = 0x0

Lisp Backtrace:
"backward-prefix-chars" (0xbfffe954)
"back-to-indentation" (0xbfffead4)
"current-left-margin" (0xbfffec64)
"move-to-left-margin" (0xbfffede4)
"newline" (0xbfffef74)
"newline-and-indent" (0xbffff144)
"call-interactively" (0xbffff344)
(gdb) 









reply via email to

[Prev in Thread] Current Thread [Next in Thread]