#define NUMERIC_ADDR_ERROR (numeric_addr == -1)
#endif
-#if defined(BSD) || defined(STRIDE)
+#if defined(BSD_SYSTEM) || defined(STRIDE)
#include <sys/ioctl.h>
#if !defined (O_NDELAY) && defined (HAVE_PTYS) && !defined(USG5)
#include <fcntl.h>
#endif /* HAVE_PTYS and no O_NDELAY */
-#endif /* BSD or STRIDE */
+#endif /* BSD_SYSTEM || STRIDE */
#ifdef BROKEN_O_NONBLOCK
#undef O_NONBLOCK
#include "lisp.h"
#include "window.h"
#include "buffer.h"
+#include "charset.h"
+#include "coding.h"
#include "process.h"
#include "termhooks.h"
#include "termopts.h"
#include "commands.h"
#include "frame.h"
+#include "blockinput.h"
Lisp_Object Qprocessp;
Lisp_Object Qrun, Qstop, Qsignal, Qopen, Qclosed;
/* Qexit is declared and initialized in eval.c. */
/* a process object is a network connection when its childp field is neither
- Qt nor Qnil but is instead a string (name of foreign host we
- are connected to + name of port we are connected to) */
+ Qt nor Qnil but is instead a cons cell (HOSTNAME PORTNUM). */
#ifdef HAVE_SOCKETS
-static Lisp_Object stream_process;
-
-#define NETCONN_P(p) (GC_STRINGP (XPROCESS (p)->childp))
+#define NETCONN_P(p) (GC_CONSP (XPROCESS (p)->childp))
#else
#define NETCONN_P(p) 0
#endif /* HAVE_SOCKETS */
/* 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 ();
return Fnull (tem);
}
+DEFUN ("process-contact", Fprocess_contact, Sprocess_contact,
+ 1, 1, 0,
+ "Return the contact info of PROCESS; t for a real child.\n\
+For a net connection, the value is a cons cell of the form (HOST SERVICE).")
+ (process)
+ register Lisp_Object process;
+{
+ CHECK_PROCESS (process, 0);
+ return XPROCESS (process)->childp;
+}
+
#if 0 /* Turned off because we don't currently record this info
in the process. Perhaps add it. */
DEFUN ("process-connection", Fprocess_connection, Sprocess_connection, 1, 1, 0,
if (NETCONN_P (proc))
{
sprintf (tembuf, "(network stream connection to %s)\n",
- XSTRING (p->childp)->data);
+ XSTRING (XCONS (p->childp)->car)->data);
insert_string (tembuf);
}
else
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;
+ }
+ 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;
+ }
+ 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);
create_process_1 (signo)
int signo;
{
-#ifdef USG
+#if defined (USG) && !defined (POSIX_SIGNALS)
/* USG systems forget handlers when they are used;
must reestablish each time */
signal (signo, create_process_1);
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 */
#ifdef BSD4_1
sighold (SIGCHLD);
#else /* not BSD4_1 */
-#if defined (BSD) || defined (UNIPLUS) || defined (HPUX)
+#if defined (BSD_SYSTEM) || defined (UNIPLUS) || defined (HPUX)
sigsetmask (sigmask (SIGCHLD));
#else /* ordinary USG */
#if 0
processes to get their return values scrambled. */
XSETINT (XPROCESS (process)->pid, -1);
+ BLOCK_INPUT;
+
{
/* child_setup must clobber environ on systems with true vfork.
Protect it from permanent change. */
/* In order to get a controlling terminal on some versions
of BSD, it is necessary to put the process in pgrp 0
before it opens the terminal. */
-#ifdef OSF1
+#ifdef HAVE_SETPGID
setpgid (0, 0);
#else
setpgrp (0, 0);
#if !defined (RTU) && !defined (UNIPLUS) && !defined (DONT_REOPEN_PTY)
/*** There is a suggestion that this ought to be a
- conditional on TIOCSPGRP. */
+ conditional on TIOCSPGRP,
+ or !(defined (HAVE_SETSID) && defined (TIOCSCTTY)).
+ Trying the latter gave the wrong results on Debian GNU/Linux 1.1;
+ that system does seem to need this code, even though
+ both HAVE_SETSID and TIOCSCTTY are defined. */
/* Now close the pty (if we had it open) and reopen it.
This makes the pty the controlling terminal of the subprocess. */
if (pty_flag)
#ifdef BSD4_1
sigrelse (SIGCHLD);
#else /* not BSD4_1 */
-#if defined (BSD) || defined (UNIPLUS) || defined (HPUX)
+#if defined (BSD_SYSTEM) || defined (UNIPLUS) || defined (HPUX)
sigsetmask (SIGEMPTYMASK);
#else /* ordinary USG */
#if 0
environ = save_environ;
}
+ UNBLOCK_INPUT;
+
/* This runs in the Emacs process. */
if (pid < 0)
{
#ifdef BSD4_1
sigrelse (SIGCHLD);
#else /* not BSD4_1 */
-#if defined (BSD) || defined (UNIPLUS) || defined (HPUX)
+#if defined (BSD_SYSTEM) || defined (UNIPLUS) || defined (HPUX)
sigsetmask (SIGEMPTYMASK);
#else /* ordinary USG */
#if 0
#endif
#endif
- XPROCESS (proc)->childp = host;
+ XPROCESS (proc)->childp = Fcons (host, Fcons (service, Qnil));
XPROCESS (proc)->command_channel_p = Qnil;
XPROCESS (proc)->buffer = buffer;
XPROCESS (proc)->sentinel = Qnil;
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;
+ val = (CONSP (coding_systems) ? XCONS (coding_systems)->car : Qnil);
+ }
+ 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;
+ }
+ val = (CONSP (coding_systems) ? XCONS (coding_systems)->cdr : Qnil);
+ }
+ 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;
}
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))
{
int count = specpdl_ptr - specpdl;
Lisp_Object odeactivate;
Lisp_Object obuffer, okeymap;
+ int outer_running_asynch_code = running_asynch_code;
/* No need to gcpro these, because all we do with them later
is test them for EQness, and none of them should be a string. */
specbind (Qinhibit_quit, Qt);
specbind (Qlast_nonmenu_event, Qt);
+ /* In case we get recursively called,
+ and we already saved the match data nonrecursively,
+ save the same match data in safely recursive fashion. */
+ if (outer_running_asynch_code)
+ {
+ Lisp_Object tem;
+ /* Don't clobber the CURRENT match data, either! */
+ tem = Fmatch_data (Qnil, Qnil);
+ restore_match_data ();
+ record_unwind_protect (Fstore_match_data, Fmatch_data (Qnil, Qnil));
+ Fstore_match_data (tem);
+ }
+
+ /* For speed, if a search happens within this code,
+ save the match data in a special nonrecursive fashion. */
running_asynch_code = 1;
+
+ /* Read and dispose of the process output. */
internal_condition_case_1 (read_process_output_call,
Fcons (outstream,
Fcons (proc,
Qnil))),
!NILP (Vdebug_on_error) ? Qnil : Qerror,
read_process_output_error_handler);
- running_asynch_code = 0;
+
+ /* If we saved the match data nonrecursively, restore it now. */
restore_match_data ();
+ running_asynch_code = outer_running_asynch_code;
/* Handling the process output should not deactivate the mark. */
Vdeactivate_mark = odeactivate;
odeactivate = Vdeactivate_mark;
Fset_buffer (p->buffer);
- opoint = point;
+ opoint = PT;
old_read_only = current_buffer->read_only;
XSETFASTINT (old_begv, BEGV);
XSETFASTINT (old_zv, ZV);
/* If the output marker is outside of the visible region, save
the restriction and widen. */
- if (! (BEGV <= point && point <= ZV))
+ if (! (BEGV <= PT && PT <= ZV))
Fwiden ();
/* Make sure opoint floats ahead of any new text, just as point
would. */
- if (point <= opoint)
+ if (PT <= opoint)
opoint += nchars;
/* Insert after old_begv, but before old_zv. */
- if (point < XFASTINT (old_begv))
+ if (PT < XFASTINT (old_begv))
XSETFASTINT (old_begv, XFASTINT (old_begv) + nchars);
- if (point <= XFASTINT (old_zv))
+ 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);
- Fset_marker (p->mark, make_number (point), p->buffer);
+ 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++;
/* 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);
#ifdef VMS
struct Lisp_Process *p = XPROCESS (proc);
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);
offset = buf - (char *) XSTRING (object)->data;
XSETFASTINT (zero, 0);
+#ifdef EMACS_HAS_USECS
+ wait_reading_process_input (0, 20000, zero, 0);
+#else
wait_reading_process_input (1, 0, zero, 0);
+#endif
if (BUFFERP (object))
buf = (char *) BUF_CHAR_ADDRESS (XBUFFER (object), offset);
error ("SIGPIPE raised on process %s; closed it", procname);
#endif
}
+
+ UNGCPRO;
}
DEFUN ("process-send-region", Fprocess_send_region, Sprocess_send_region,
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;
/* USG systems forget handlers when they are used;
must reestablish each time */
-#ifdef USG
+#if defined (USG) && !defined (POSIX_SIGNALS)
signal (signo, sigchld_handler); /* WARNING - must come after wait3() */
#endif
#ifdef BSD4_1
Otherwise (on systems that have WNOHANG), loop around
to use up all the processes that have something to tell us. */
#if defined (USG) && ! (defined (HPUX) && defined (WNOHANG)) || defined (WINDOWSNT)
-#ifdef USG
+#if defined (USG) && ! defined (POSIX_SIGNALS)
signal (signo, sigchld_handler);
#endif
errno = old_errno;
Lisp_Object sentinel, obuffer, odeactivate, okeymap;
register struct Lisp_Process *p = XPROCESS (proc);
int count = specpdl_ptr - specpdl;
+ int outer_running_asynch_code = running_asynch_code;
/* No need to gcpro these, because all we do with them later
is test them for EQness, and none of them should be a string. */
specbind (Qinhibit_quit, Qt);
specbind (Qlast_nonmenu_event, Qt);
+ /* In case we get recursively called,
+ and we already saved the match data nonrecursively,
+ save the same match data in safely recursive fashion. */
+ if (outer_running_asynch_code)
+ {
+ Lisp_Object tem;
+ tem = Fmatch_data (Qnil, Qnil);
+ restore_match_data ();
+ record_unwind_protect (Fstore_match_data, Fmatch_data (Qnil, Qnil));
+ Fstore_match_data (tem);
+ }
+
+ /* For speed, if a search happens within this code,
+ save the match data in a special nonrecursive fashion. */
running_asynch_code = 1;
+
internal_condition_case_1 (read_process_output_call,
Fcons (sentinel,
Fcons (proc, Fcons (reason, Qnil))),
!NILP (Vdebug_on_error) ? Qnil : Qerror,
exec_sentinel_error_handler);
- running_asynch_code = 0;
+
+ /* If we saved the match data nonrecursively, restore it now. */
restore_match_data ();
+ running_asynch_code = outer_running_asynch_code;
Vdeactivate_mark = odeactivate;
#if 0
XSETINT (p->update_tick, XINT (p->tick));
/* If process is still active, read any output that remains. */
- if (XINT (p->infd) >= 0)
- while (! EQ (p->filter, Qt)
- && read_process_output (proc, XINT (p->infd)) > 0);
+ while (! EQ (p->filter, Qt)
+ && XINT (p->infd) >= 0
+ && read_process_output (proc, XINT (p->infd)) > 0);
buffer = p->buffer;
deactivate_process (proc);
}
+ /* The actions above may have further incremented p->tick.
+ So set p->update_tick again
+ so that an error in the sentinel will not cause
+ this code to be run again. */
+ XSETINT (p->update_tick, XINT (p->tick));
/* Now output the message suitably. */
if (!NILP (p->sentinel))
exec_sentinel (proc, msg);
if (NILP (XBUFFER (buffer)->name))
continue;
Fset_buffer (buffer);
- opoint = point;
+ opoint = PT;
/* Insert new output into buffer
at the current end-of-output marker,
thus preserving logical ordering of input and output. */
SET_PT (marker_position (p->mark));
else
SET_PT (ZV);
- if (point <= opoint)
+ if (PT <= opoint)
opoint += XSTRING (msg)->size + XSTRING (p->name)->size + 10;
tem = current_buffer->read_only;
insert_string (" ");
Finsert (1, &msg);
current_buffer->read_only = tem;
- Fset_marker (p->mark, make_number (point), p->buffer);
+ Fset_marker (p->mark, make_number (PT), p->buffer);
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.
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 ()
{
-#ifdef HAVE_SOCKETS
- stream_process = intern ("stream");
-#endif
Qprocessp = intern ("processp");
staticpro (&Qprocessp);
Qrun = intern ("run");
defsubr (&Sset_process_filter);
defsubr (&Sprocess_filter);
defsubr (&Sset_process_sentinel);
- defsubr (&Sset_process_window_size);
defsubr (&Sprocess_sentinel);
+ defsubr (&Sset_process_window_size);
defsubr (&Sprocess_kill_without_query);
+ defsubr (&Sprocess_contact);
defsubr (&Slist_processes);
defsubr (&Sprocess_list);
defsubr (&Sstart_process);
defsubr (&Ssignal_process);
defsubr (&Swaiting_for_user_input_p);
/* defsubr (&Sprocess_connection); */
+ defsubr (&Sset_process_coding_system);
+ defsubr (&Sprocess_coding_system);
}
\f