#include "lisp.h"
#include "window.h"
#include "buffer.h"
+#include "charset.h"
+#include "coding.h"
#include "process.h"
#include "termhooks.h"
#include "termopts.h"
static SELECT_TYPE non_keyboard_wait_mask;
+/* Mask that excludes process input descriptor (s). */
+
+static SELECT_TYPE non_process_wait_mask;
+
/* The largest descriptor currently in use for a process object. */
static int max_process_desc;
/* Don't make static; need to access externally. */
int proc_buffered_char[MAXDESC];
+/* Table of `struct coding-system' for each process. */
+static struct coding_system *proc_decode_coding_system[MAXDESC];
+static struct coding_system *proc_encode_coding_system[MAXDESC];
+
static Lisp_Object get_process ();
extern EMACS_TIME timer_check ();
Process output goes at end of that buffer, unless you specify\n\
an output stream or filter function to handle the output.\n\
BUFFER may be also nil, meaning that this process is not associated\n\
- with any buffer\n\
+ with any buffer.\n\
Third arg is program file name. It is searched for as in the shell.\n\
Remaining arguments are strings to give program as arguments.")
(nargs, args)
Fset_marker (XPROCESS (proc)->mark,
make_number (BUF_ZV (XBUFFER (buffer))), buffer);
+ if (!NILP (buffer) && NILP (XBUFFER (buffer)->enable_multibyte_characters)
+ || NILP (buffer) && NILP (buffer_defaults.enable_multibyte_characters))
+ {
+ XPROCESS (proc)->decode_coding_system = Qnil;
+ XPROCESS (proc)->encode_coding_system = Qnil;
+ }
+ else
+ {
+ /* Setup coding systems for communicating with the process. */
+ /* Qt denotes that we have not yet called Ffind_coding_system. */
+ Lisp_Object coding_systems = Qt;
+ Lisp_Object val, *args2;
+ struct gcpro gcpro1;
+
+ if (NILP (val = Vcoding_system_for_read))
+ {
+ args2 = (Lisp_Object *) alloca ((nargs + 1) * sizeof *args2);
+ args2[0] = Qstart_process;
+ for (i = 0; i < nargs; i++) args2[i + 1] = args[i];
+ GCPRO1 (proc);
+ coding_systems = Ffind_coding_system (nargs + 1, args2);
+ UNGCPRO;
+ if (CONSP (coding_systems))
+ val = XCONS (coding_systems)->car;
+ else if (CONSP (Vdefault_process_coding_system))
+ val = XCONS (Vdefault_process_coding_system)->car;
+ }
+ XPROCESS (proc)->decode_coding_system = val;
+
+ if (NILP (val = Vcoding_system_for_write))
+ {
+ if (EQ (coding_systems, Qt))
+ {
+ args2 = (Lisp_Object *) alloca ((nargs + 1) * sizeof args2);
+ args2[0] = Qstart_process;
+ for (i = 0; i < nargs; i++) args2[i + 1] = args[i];
+ GCPRO1 (proc);
+ coding_systems = Ffind_coding_system (nargs + 1, args2);
+ UNGCPRO;
+ }
+ if (CONSP (coding_systems))
+ val = XCONS (coding_systems)->cdr;
+ else if (CONSP (Vdefault_process_coding_system))
+ val = XCONS (Vdefault_process_coding_system)->cdr;
+ }
+ XPROCESS (proc)->encode_coding_system = val;
+ }
+
+ XPROCESS (proc)->decoding_buf = make_uninit_string (0);
+ XPROCESS (proc)->encoding_buf = make_uninit_string (0);
+
create_process (proc, new_argv, current_dir);
return unbind_to (count, proc);
XSETFASTINT (XPROCESS (process)->subtty, forkin);
XPROCESS (process)->pty_flag = (pty_flag ? Qt : Qnil);
XPROCESS (process)->status = Qrun;
+ if (!proc_decode_coding_system[inchannel])
+ proc_decode_coding_system[inchannel]
+ = (struct coding_system *) xmalloc (sizeof (struct coding_system));
+ setup_coding_system (XPROCESS (process)->decode_coding_system,
+ proc_decode_coding_system[inchannel]);
+ if (!proc_encode_coding_system[outchannel])
+ proc_encode_coding_system[outchannel]
+ = (struct coding_system *) xmalloc (sizeof (struct coding_system));
+ setup_coding_system (XPROCESS (process)->encode_coding_system,
+ proc_encode_coding_system[outchannel]);
/* Delay interrupts until we have a chance to store
the new fork's pid in its process structure */
#endif /* TERM */
inch = s;
- outch = dup (s);
- if (outch < 0)
- report_file_error ("error duplicating socket", Fcons (name, Qnil));
+ outch = s;
if (!NILP (buffer))
buffer = Fget_buffer_create (buffer);
if (inch > max_process_desc)
max_process_desc = inch;
+ if (!NILP (buffer) && NILP (XBUFFER (buffer)->enable_multibyte_characters)
+ || NILP (buffer) && NILP (buffer_defaults.enable_multibyte_characters))
+ {
+ XPROCESS (proc)->decode_coding_system = Qnil;
+ XPROCESS (proc)->encode_coding_system = Qnil;
+ }
+ else
+ {
+ /* Setup coding systems for communicating with the network stream. */
+ struct gcpro gcpro1;
+ /* Qt denotes that we have not yet called Ffind_coding_system. */
+ Lisp_Object coding_systems = Qt;
+ Lisp_Object args[5], val;
+
+ if (NILP (val = Vcoding_system_for_read))
+ {
+ args[0] = Qopen_network_stream, args[1] = name,
+ args[2] = buffer, args[3] = host, args[4] = service;
+ GCPRO1 (proc);
+ coding_systems = Ffind_coding_system (5, args);
+ UNGCPRO;
+ if (CONSP (coding_systems))
+ val = XCONS (coding_systems)->car;
+ else if (CONSP (Vdefault_process_coding_system))
+ val = XCONS (Vdefault_process_coding_system)->car;
+ }
+ XPROCESS (proc)->decode_coding_system = val;
+
+ if (NILP (val = Vcoding_system_for_write))
+ {
+ if (EQ (coding_systems, Qt))
+ {
+ args[0] = Qopen_network_stream, args[1] = name,
+ args[2] = buffer, args[3] = host, args[4] = service;
+ GCPRO1 (proc);
+ coding_systems = Ffind_coding_system (5, args);
+ UNGCPRO;
+ }
+ if (CONSP (coding_systems))
+ val = XCONS (coding_systems)->cdr;
+ else if (CONSP (Vdefault_process_coding_system))
+ val = XCONS (Vdefault_process_coding_system)->cdr;
+ }
+ XPROCESS (proc)->encode_coding_system = val;
+ }
+
+ if (!proc_decode_coding_system[inch])
+ proc_decode_coding_system[inch]
+ = (struct coding_system *) xmalloc (sizeof (struct coding_system));
+ setup_coding_system (XPROCESS (proc)->decode_coding_system,
+ proc_decode_coding_system[inch]);
+ if (!proc_encode_coding_system[outch])
+ proc_encode_coding_system[outch]
+ = (struct coding_system *) xmalloc (sizeof (struct coding_system));
+ setup_coding_system (XPROCESS (proc)->encode_coding_system,
+ proc_encode_coding_system[outch]);
+
+ XPROCESS (proc)->decoding_buf = make_uninit_string (0);
+ XPROCESS (proc)->encoding_buf = make_uninit_string (0);
+
UNGCPRO;
return proc;
}
goto retry;
}
+ /* If there is unread keyboard input, also return. */
+ if (XINT (read_kbd) != 0
+ && requeued_events_pending_p ())
+ break;
+
if (! EMACS_TIME_NEG_P (timer_delay) && time_limit != -1)
{
EMACS_TIME difference;
if (wait_proc != 0
&& ! EQ (wait_proc->status, Qrun))
{
+ int nread, total_nread;
+
clear_waiting_for_input ();
+ XSETPROCESS (proc, wait_proc);
+
+ /* Read data from the process, until we exhaust it. */
+ while (XINT (wait_proc->infd) >= 0
+ && (nread
+ = read_process_output (proc, XINT (wait_proc->infd))))
+ total_nread += nread;
+ if (total_nread > 0 && do_display)
+ redisplay_preserve_echo_area ();
+
break;
}
/* Wait till there is something to do */
- if (! XINT (read_kbd) && wait_for_cell == 0)
+ if (wait_for_cell)
+ Available = non_process_wait_mask;
+ else if (! XINT (read_kbd))
Available = non_keyboard_wait_mask;
else
Available = input_wait_mask;
kill (getpid (), SIGIO);
#endif
+#if 0 /* When polling is used, interrupt_input is 0,
+ so get_input_pending should read the input.
+ So this should not be needed. */
+ /* If we are using polling for input,
+ and we see input available, make it get read now.
+ Otherwise it might not actually get read for a second.
+ And on hpux, since we turn off polling in wait_reading_process_input,
+ it might never get read at all if we don't spend much time
+ outside of wait_reading_process_input. */
+ if (XINT (read_kbd) && interrupt_input
+ && keyboard_bit_set (&Available)
+ && input_polling_used ())
+ kill (getpid (), SIGALRM);
+#endif
+
/* Check for keyboard input */
/* If there is any, return immediately
to give it higher priority than subprocesses */
break;
}
+ /* If there is unread keyboard input, also return. */
+ if (XINT (read_kbd) != 0
+ && requeued_events_pending_p ())
+ break;
+
+#if 0
/* If wait_for_cell. check for keyboard input
but don't run any timers.
??? (It seems wrong to me to check for keyboard
if (detect_input_pending ())
break;
}
+#endif
/* Exit now if the cell we're waiting for became non-nil. */
if (wait_for_cell && ! NILP (*wait_for_cell))
break;
#ifdef SIGIO
- /* If we think we have keyboard input waiting, but didn't get SIGIO
+ /* If we think we have keyboard input waiting, but didn't get SIGIO,
go read it. This can happen with X on BSD after logging out.
In that case, there really is no input and no SIGIO,
but select says there is input. */
if (XINT (read_kbd) && interrupt_input
- && (keyboard_bit_set (&Available)))
+ && keyboard_bit_set (&Available))
kill (getpid (), SIGIO);
#endif
Causes "poll: interrupted system call" messages when Emacs is run
in an X window
Turn periodic alarms back on */
- start_polling();
+ start_polling ();
#endif
return got_some_input;
Fsleep_for (make_number (2), Qnil);
}
+#ifdef WINDOWSNT
+#define READ_CHILD_OUTPUT read_child_output
+#else
+#define READ_CHILD_OUTPUT read
+#endif
+
/* Read pending output from the process channel,
starting with our buffered-ahead character if we have one.
- Yield number of characters read.
+ Yield number of decoded characters read.
This function reads at most 1024 characters.
If you want to read all available subprocess output,
- you must call it repeatedly until it returns zero. */
+ you must call it repeatedly until it returns zero.
+
+ The characters read are decoded according to PROC's coding-system
+ for decoding. */
read_process_output (proc, channel)
Lisp_Object proc;
register int channel;
{
register int nchars;
-#ifdef VMS
char *chars;
+#ifdef VMS
+ int chars_allocated = 0; /* If 1, `chars' should be freed later. */
#else
- char chars[1024];
+ char buf[1024];
#endif
register Lisp_Object outstream;
register struct buffer *old = current_buffer;
register struct Lisp_Process *p = XPROCESS (proc);
register int opoint;
+ struct coding_system *coding = proc_decode_coding_system[channel];
+ int chars_in_decoding_buf = 0; /* If 1, `chars' points
+ XSTRING (p->decoding_buf)->data. */
#ifdef VMS
VMS_PROC_STUFF *vs, *get_vms_process_pointer();
start_vms_process_read (vs); /* Crank up the next read on the process */
return 1; /* Nothing worth printing, say we got 1 */
}
+ if (coding->carryover_size)
+ {
+ /* The data carried over in the previous decoding should be
+ prepended to the new data read to decode all together. */
+ char *buf = (char *) xmalloc (nchars + coding->carryover_size);
+
+ bcopy (coding->carryover, buf, coding->carryover_size);
+ bcopy (chars, buf + coding->carryover_size, nchars);
+ chars = buf;
+ chars_allocated = 1;
+ }
#else /* not VMS */
+ if (coding->carryover_size)
+ /* The data carried over in the previous decoding should be
+ prepended to the new data read to decode all together. */
+ bcopy (coding->carryover, buf, coding->carryover_size);
+
if (proc_buffered_char[channel] < 0)
- nchars = read (channel, chars, sizeof (chars));
+ nchars = READ_CHILD_OUTPUT (channel, buf + coding->carryover_size,
+ (sizeof buf) - coding->carryover_size);
else
{
- chars[0] = proc_buffered_char[channel];
+ buf[coding->carryover_size] = proc_buffered_char[channel];
proc_buffered_char[channel] = -1;
- nchars = read (channel, chars + 1, sizeof (chars) - 1);
+ nchars = READ_CHILD_OUTPUT (channel, buf + coding->carryover_size + 1,
+ (sizeof buf) - coding->carryover_size - 1);
if (nchars < 0)
nchars = 1;
else
nchars = nchars + 1;
}
+ chars = buf;
#endif /* not VMS */
+ /* At this point, NCHARS holds number of characters just received
+ (including the one in proc_buffered_char[channel]). */
if (nchars <= 0) return nchars;
+ /* Now set NCHARS how many bytes we must decode. */
+ nchars += coding->carryover_size;
+
+ if (CODING_REQUIRE_CONVERSION (coding))
+ {
+ int require = decoding_buffer_size (coding, nchars);
+ int consumed, produced;
+
+ if (XSTRING (p->decoding_buf)->size < require)
+ p->decoding_buf = make_uninit_string (require);
+ produced = decode_coding (coding, chars, XSTRING (p->decoding_buf)->data,
+ nchars, XSTRING (p->decoding_buf)->size,
+ &consumed);
+
+ /* New coding-system might be found by `decode_coding'. */
+ if (!EQ (p->decode_coding_system, coding->symbol))
+ {
+ p->decode_coding_system = coding->symbol;
+ setup_coding_system (coding->symbol,
+ proc_decode_coding_system[channel]);
+ /* If coding-system for encoding is not yet decided, we set it
+ as the same as coding-system for decoding. */
+ if (NILP (p->encode_coding_system))
+ {
+ p->encode_coding_system = coding->symbol;
+ setup_coding_system (coding->symbol,
+ proc_encode_coding_system[channel]);
+ }
+ }
+#ifdef VMS
+ /* Now we don't need the contents of `chars'. */
+ if (chars_allocated)
+ free (chars);
+#endif
+ if (produced == 0)
+ return 0;
+ chars = XSTRING (p->decoding_buf)->data;
+ nchars = produced;
+ chars_in_decoding_buf = 1;
+ }
+#ifdef VMS
+ else if (chars_allocated)
+ {
+ /* Although we don't have to decode the received data, we must
+ move it to an area which we don't have to free. */
+ if (! STRINGP (p->decoding_buf)
+ || XSTRING (p->decoding_buf)->size < nchars)
+ p->decoding_buf = make_uninit_string (nchars);
+ bcopy (chars, XSTRING (p->decoding_buf)->data, nchars);
+ free (chars);
+ chars = XSTRING (p->decoding_buf)->data;
+ chars_in_decoding_buf = 1;
+ }
+#endif
+
outstream = p->filter;
if (!NILP (outstream))
{
if (!NILP (p->buffer) && !NILP (XBUFFER (p->buffer)->name))
{
Lisp_Object old_read_only;
- Lisp_Object old_begv, old_zv;
+ int old_begv, old_zv;
Lisp_Object odeactivate;
+ int before;
odeactivate = Vdeactivate_mark;
Fset_buffer (p->buffer);
opoint = PT;
old_read_only = current_buffer->read_only;
- XSETFASTINT (old_begv, BEGV);
- XSETFASTINT (old_zv, ZV);
+ old_begv = BEGV;
+ old_zv = ZV;
current_buffer->read_only = Qnil;
SET_PT (clip_to_bounds (BEGV, marker_position (p->mark), ZV));
else
SET_PT (ZV);
+ before = PT;
/* If the output marker is outside of the visible region, save
the restriction and widen. */
if (! (BEGV <= PT && PT <= ZV))
Fwiden ();
- /* Make sure opoint floats ahead of any new text, just as point
- would. */
- if (PT <= opoint)
- opoint += nchars;
-
- /* Insert after old_begv, but before old_zv. */
- if (PT < XFASTINT (old_begv))
- XSETFASTINT (old_begv, XFASTINT (old_begv) + nchars);
- if (PT <= XFASTINT (old_zv))
- XSETFASTINT (old_zv, XFASTINT (old_zv) + nchars);
-
/* Insert before markers in case we are inserting where
the buffer's mark is, and the user's next command is Meta-y. */
- insert_before_markers (chars, nchars);
+ if (chars_in_decoding_buf)
+ insert_from_string_before_markers (p->decoding_buf, 0, nchars, 0);
+ else
+ insert_before_markers (chars, nchars);
Fset_marker (p->mark, make_number (PT), p->buffer);
update_mode_lines++;
+ /* Make sure opoint and the old restrictions
+ float ahead of any new text just as point would. */
+ if (opoint >= before)
+ opoint += PT - before;
+ if (old_begv > before)
+ old_begv += PT - before;
+ if (old_zv >= before)
+ old_zv += PT - before;
+
/* If the restriction isn't what it should be, set it. */
- if (XFASTINT (old_begv) != BEGV || XFASTINT (old_zv) != ZV)
- Fnarrow_to_region (old_begv, old_zv);
+ if (old_begv != BEGV || old_zv != ZV)
+ Fnarrow_to_region (make_number (old_begv), make_number (old_zv));
/* Handling the process output should not deactivate the mark. */
Vdeactivate_mark = odeactivate;
/* Send some data to process PROC.
BUF is the beginning of the data; LEN is the number of characters.
- OBJECT is the Lisp object that the data comes from. */
+ OBJECT is the Lisp object that the data comes from.
+
+ The data is encoded by PROC's coding-system for encoding before it
+ is sent. But if the data ends at the middle of multi-byte
+ representation, that incomplete sequence of bytes are sent without
+ being encoded. Should we store them in a buffer to prepend them to
+ the data send later? */
send_process (proc, buf, len, object)
volatile Lisp_Object proc;
/* Use volatile to protect variables from being clobbered by longjmp. */
int rv;
volatile unsigned char *procname = XSTRING (XPROCESS (proc)->name)->data;
+ struct coding_system *coding;
struct gcpro gcpro1;
GCPRO1 (object);
update_status (XPROCESS (proc));
if (! EQ (XPROCESS (proc)->status, Qrun))
error ("Process %s not running", procname);
+ if (XINT (XPROCESS (proc)->outfd) < 0)
+ error ("Output file descriptor of %s is closed", procname);
+
+ coding = proc_encode_coding_system[XINT (XPROCESS (proc)->outfd)];
+ if (CODING_REQUIRE_CONVERSION (coding))
+ {
+ int require = encoding_buffer_size (coding, len);
+ int offset, dummy;
+ char *temp_buf = NULL;
+
+ /* Remember the offset of data because a string or a buffer may
+ be relocated. Setting OFFSET to -1 means we don't have to
+ care relocation. */
+ offset = (BUFFERP (object)
+ ? BUF_PTR_CHAR_POS (XBUFFER (object), (unsigned char *) buf)
+ : (STRINGP (object)
+ ? offset = buf - (char *) XSTRING (object)->data
+ : -1));
+
+ if (coding->carryover_size > 0)
+ {
+ temp_buf = (char *) xmalloc (len + coding->carryover_size);
+
+ if (offset >= 0)
+ {
+ if (BUFFERP (object))
+ buf = (char *) BUF_CHAR_ADDRESS (XBUFFER (object), offset);
+ else if (STRINGP (object))
+ buf = offset + (char *) XSTRING (object)->data;
+ /* Now we don't have to care relocation. */
+ offset = -1;
+ }
+ bcopy (coding->carryover, temp_buf, coding->carryover_size);
+ bcopy (buf, temp_buf + coding->carryover_size, len);
+ buf = temp_buf;
+ }
+
+ if (XSTRING (XPROCESS (proc)->encoding_buf)->size < require)
+ {
+ XPROCESS (proc)->encoding_buf = make_uninit_string (require);
+
+ if (offset >= 0)
+ {
+ if (BUFFERP (object))
+ buf = (char *) BUF_CHAR_ADDRESS (XBUFFER (object), offset);
+ else if (STRINGP (object))
+ buf = offset + (char *) XSTRING (object)->data;
+ }
+ }
+ object = XPROCESS (proc)->encoding_buf;
+ len = encode_coding (coding, buf, XSTRING (object)->data,
+ len, XSTRING (object)->size, &dummy);
+ buf = XSTRING (object)->data;
+ if (temp_buf)
+ xfree (temp_buf);
+ }
#ifdef VMS
vs = get_vms_process_pointer (p->pid);
move_gap (start);
start1 = XINT (start);
- send_process (proc, &FETCH_CHAR (start1), XINT (end) - XINT (start),
+ send_process (proc, POS_ADDR (start1), XINT (end) - XINT (start),
Fcurrent_buffer ());
return Qnil;
send_process (proc, "\004", 1, Qnil);
else
{
+#ifdef HAVE_SHUTDOWN
+ /* If this is a network connection, or socketpair is used
+ for communication with the subprocess, call shutdown to cause EOF.
+ (In some old system, shutdown to socketpair doesn't work.
+ Then we just can't win.) */
+ if (NILP (XPROCESS (proc)->pid)
+ || XINT (XPROCESS (proc)->outfd) == XINT (XPROCESS (proc)->infd))
+ shutdown (XINT (XPROCESS (proc)->outfd), 1);
+ /* In case of socketpair, outfd == infd, so don't close it. */
+ if (XINT (XPROCESS (proc)->outfd) != XINT (XPROCESS (proc)->infd))
+ close (XINT (XPROCESS (proc)->outfd));
+#else /* not HAVE_SHUTDOWN */
close (XINT (XPROCESS (proc)->outfd));
+#endif /* not HAVE_SHUTDOWN */
XSETINT (XPROCESS (proc)->outfd, open (NULL_DEVICE, O_WRONLY));
}
#endif /* VMS */
Lisp_Object ro, tem;
struct buffer *old = current_buffer;
int opoint;
+ int before;
ro = XBUFFER (buffer)->read_only;
if (NILP (XBUFFER (buffer)->name))
continue;
Fset_buffer (buffer);
+
opoint = PT;
/* Insert new output into buffer
at the current end-of-output marker,
SET_PT (marker_position (p->mark));
else
SET_PT (ZV);
- if (PT <= opoint)
- opoint += XSTRING (msg)->size + XSTRING (p->name)->size + 10;
+
+ before = PT;
tem = current_buffer->read_only;
current_buffer->read_only = Qnil;
current_buffer->read_only = tem;
Fset_marker (p->mark, make_number (PT), p->buffer);
- SET_PT (opoint);
+ if (opoint >= before)
+ SET_PT (opoint + (PT - before));
+ else
+ SET_PT (opoint);
+
set_buffer_internal (old);
}
}
UNGCPRO;
}
+
+\f
+DEFUN ("set-process-coding-system", Fset_process_coding_system,
+ Sset_process_coding_system, 1, 3, 0,
+ "Set coding-systems of PROCESS to DECODING (input from the process) and\n\
+ENCODING (output to the process).")
+ (proc, decoding, encoding)
+ register Lisp_Object proc, decoding, encoding;
+{
+ register struct Lisp_Process *p;
+
+ CHECK_PROCESS (proc, 0);
+ p = XPROCESS (proc);
+ if (XINT (p->infd) < 0)
+ error ("Input file descriptor of %s closed", XSTRING (p->name)->data);
+ if (XINT (p->outfd) < 0)
+ error ("Output file descriptor of %s closed", XSTRING (p->name)->data);
+
+ p->decode_coding_system = Fcheck_coding_system (decoding);
+ p->encode_coding_system = Fcheck_coding_system (encoding);
+ setup_coding_system (decoding,
+ proc_decode_coding_system[XINT (p->infd)]);
+ setup_coding_system (encoding,
+ proc_encode_coding_system[XINT (p->outfd)]);
+
+ return Qnil;
+}
+
+DEFUN ("process-coding-system",
+ Fprocess_coding_system, Sprocess_coding_system, 1, 1, 0,
+ "Return a cons of coding-system for decoding and encoding of PROCESS.")
+ (proc)
+ register Lisp_Object proc;
+{
+ CHECK_PROCESS (proc, 0);
+ return Fcons (XPROCESS (proc)->decode_coding_system,
+ XPROCESS (proc)->encode_coding_system);
+}
\f
/* The first time this is called, assume keyboard input comes from DESC
instead of from where we used to expect it.
FD_CLR (0, &input_wait_mask);
add_keyboard_wait_descriptor_called_flag = 1;
FD_SET (desc, &input_wait_mask);
+ FD_SET (desc, &non_process_wait_mask);
if (desc > max_keyboard_desc)
max_keyboard_desc = desc;
}
int lim = max_keyboard_desc;
FD_CLR (desc, &input_wait_mask);
+ FD_CLR (desc, &non_process_wait_mask);
if (desc == max_keyboard_desc)
for (fd = 0; fd < lim; fd++)
FD_ZERO (&input_wait_mask);
FD_ZERO (&non_keyboard_wait_mask);
+ FD_ZERO (&non_process_wait_mask);
max_process_desc = 0;
FD_SET (0, &input_wait_mask);
chan_process[i] = Qnil;
proc_buffered_char[i] = -1;
}
+ bzero (proc_decode_coding_system, sizeof proc_decode_coding_system);
+ bzero (proc_encode_coding_system, sizeof proc_encode_coding_system);
}
syms_of_process ()
defsubr (&Ssignal_process);
defsubr (&Swaiting_for_user_input_p);
/* defsubr (&Sprocess_connection); */
+ defsubr (&Sset_process_coding_system);
+ defsubr (&Sprocess_coding_system);
}
\f
HCoop / bpt / emacs.git / blobdiff