#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"
+
+#define max(a, b) ((a) > (b) ? (a) : (b))
Lisp_Object Qprocessp;
Lisp_Object Qrun, Qstop, Qsignal, Qopen, Qclosed;
Qt nor Qnil but is instead a cons cell (HOSTNAME PORTNUM). */
#ifdef HAVE_SOCKETS
-static Lisp_Object stream_process;
-
#define NETCONN_P(p) (GC_CONSP (XPROCESS (p)->childp))
#else
#define NETCONN_P(p) 0
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 ();
/* Maximum number of bytes to send to a pty without an eof. */
static int pty_max_bytes;
+extern Lisp_Object Vfile_name_coding_system;
+
#ifdef HAVE_PTYS
/* The file name of the pty opened by allocate_pty. */
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)
/* Make the process marker point into the process buffer (if any). */
if (!NILP (buffer))
- Fset_marker (XPROCESS (proc)->mark,
- make_number (BUF_ZV (XBUFFER (buffer))), buffer);
+ set_marker_both (XPROCESS (proc)->mark, buffer,
+ BUF_ZV (XBUFFER (buffer)),
+ BUF_ZV_BYTE (XBUFFER (buffer)));
- create_process (proc, new_argv, current_dir);
+ 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 we have not yet called Ffind_operation_coding_system. */
+ Lisp_Object coding_systems = Qt;
+ Lisp_Object val, *args2;
+ struct gcpro gcpro1;
+
+ if (!NILP (Vcoding_system_for_read))
+ val = Vcoding_system_for_read;
+ else if (NILP (current_buffer->enable_multibyte_characters))
+ val = Qemacs_mule;
+ else
+ {
+ 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_operation_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;
+ else
+ val = Qnil;
+ }
+ XPROCESS (proc)->decode_coding_system = val;
+
+ if (!NILP (Vcoding_system_for_write))
+ val = Vcoding_system_for_write;
+ else if (NILP (current_buffer->enable_multibyte_characters))
+ val = Qnil;
+ else
+ {
+ 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_operation_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;
+ else
+ val = Qnil;
+ }
+ 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, (char **) new_argv, current_dir);
return unbind_to (count, proc);
}
#endif
#ifndef VMS /* VMS version of this function is in vmsproc.c. */
+void
create_process (process, new_argv, current_dir)
Lisp_Object process;
char **new_argv;
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]);
+
+ if (CODING_REQUIRE_ENCODING (proc_encode_coding_system[outchannel]))
+ {
+ /* Here we encode arguments by the coding system used for
+ sending data to the process. We don't support using
+ different coding systems for encoding arguments and for
+ encoding data sent to the process. */
+ struct gcpro gcpro1;
+ int i = 1;
+ struct coding_system *coding = proc_encode_coding_system[outchannel];
+
+ coding->last_block = 1;
+ GCPRO1 (process);
+ while (new_argv[i] != 0)
+ {
+ int len = strlen (new_argv[i]);
+ int size = encoding_buffer_size (coding, len);
+ unsigned char *buf = (unsigned char *) alloca (size);
+ int produced, dmy;
+
+ produced = encode_coding (coding, new_argv[i], buf, len, size, &dmy);
+ buf[produced] = 0;
+ /* We don't have to free new_argv[i] because it points to a
+ Lisp string given as an argument to `start-process'. */
+ new_argv[i++] = buf;
+ }
+ UNGCPRO;
+ coding->last_block = 0;
+ }
/* 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. */
char **save_environ = environ;
+ current_dir
+ = Fencode_coding_string (current_dir, Vfile_name_coding_system, Qt);
+
#ifndef WINDOWSNT
pid = vfork ();
if (pid == 0)
/* 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);
#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 /* 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 we have not yet called Ffind_operation_coding_system. */
+ Lisp_Object coding_systems = Qt;
+ Lisp_Object args[5], val;
+
+ if (!NILP (Vcoding_system_for_read))
+ val = Vcoding_system_for_read;
+ else if (NILP (current_buffer->enable_multibyte_characters))
+ /* We dare not decode end-of-line format by setting VAL to
+ Qemacs_mule, because the existing Emacs Lisp libraries
+ assume that they receive bare code including a sequene of
+ CR LF. */
+ val = Qnil;
+ else
+ {
+ args[0] = Qopen_network_stream, args[1] = name,
+ args[2] = buffer, args[3] = host, args[4] = service;
+ GCPRO1 (proc);
+ coding_systems = Ffind_operation_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;
+ else
+ val = Qnil;
+ }
+ XPROCESS (proc)->decode_coding_system = val;
+
+ if (!NILP (Vcoding_system_for_write))
+ val = Vcoding_system_for_write;
+ else if (NILP (current_buffer->enable_multibyte_characters))
+ val = Qnil;
+ else
+ {
+ 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_operation_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;
+ else
+ val = 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;
}
#endif /* HAVE_SOCKETS */
+void
deactivate_process (proc)
Lisp_Object proc;
{
with subprocess. This is used in a newly-forked subprocess
to get rid of irrelevant descriptors. */
+void
close_process_descs ()
{
#ifndef WINDOWSNT
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;
{
Atemp = input_wait_mask;
EMACS_SET_SECS_USECS (timeout, 0, 0);
- if ((select (MAXDESC, &Atemp, (SELECT_TYPE *)0, (SELECT_TYPE *)0,
+ if ((select (max (max_process_desc, max_keyboard_desc) + 1,
+ &Atemp, (SELECT_TYPE *)0, (SELECT_TYPE *)0,
&timeout)
<= 0))
{
if (wait_proc != 0
&& ! EQ (wait_proc->status, Qrun))
{
+ int nread, total_nread = 0;
+
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))))
+ {
+ if (0 < nread)
+ total_nread += nread;
+#ifdef EIO
+ else if (nread == -1 && EIO == errno)
+ break;
+#endif
+ }
+ 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;
FD_ZERO (&Available);
}
else
- nfds = select (MAXDESC, &Available, (SELECT_TYPE *)0, (SELECT_TYPE *)0,
+ nfds = select (max (max_process_desc, max_keyboard_desc) + 1,
+ &Available, (SELECT_TYPE *)0, (SELECT_TYPE *)0,
&timeout);
xerrno = errno;
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 */
- if ((XINT (read_kbd) != 0)
+ if (XINT (read_kbd) != 0
&& detect_input_pending_run_timers (do_display))
{
swallow_events (do_display);
break;
}
- /* If wait_for_cell. check for keyboard input
- but don't run any timers.
- ??? (It seems wrong to me to check for keyboard
- input at all when wait_for_cell, but the code
- has been this way since July 1994.
- Try changing this after version 19.31.) */
- if (wait_for_cell
- && detect_input_pending ())
+ /* If there is unread keyboard input, also return. */
+ if (XINT (read_kbd) != 0
+ && requeued_events_pending_p ())
+ break;
+
+ /* If we are not checking for keyboard input now,
+ do process events (but don't run any timers).
+ This is so that X events will be processed.
+ Otherwise they may have to wait until polling takes place.
+ That would causes delays in pasting selections, for example.
+
+ (We used to do this only if wait_for_cell.) */
+ if (XINT (read_kbd) == 0 && detect_input_pending ())
{
swallow_events (do_display);
+#if 0 /* Exiting when read_kbd doesn't request that seems wrong, though. */
if (detect_input_pending ())
break;
+#endif
}
/* Exit now if the cell we're waiting for became non-nil. */
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;
/* 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 (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 (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_DECODING (coding)
+ || CODING_REQUIRE_DETECTION (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;
+
+ /* Don't call setup_coding_system for
+ proc_decode_coding_system[channel] here. It is done in
+ detect_coding called via decode_coding above. */
+
+ /* If coding-system for encoding is not yet decided, we set
+ it as the same as coding-system for decoding.
+
+ But, before doing that we must check if
+ proc_encode_coding_system[p->outfd] surely points to a
+ valid memory because p->outfd will be changed once EOF is
+ sent to the process. */
+ if (NILP (p->encode_coding_system)
+ && proc_encode_coding_system[p->outfd])
+ {
+ p->encode_coding_system = coding->symbol;
+ setup_coding_system (coding->symbol,
+ proc_encode_coding_system[p->outfd]);
+ }
+ }
+#ifdef VMS
+ /* Now we don't need the contents of `chars'. */
+ if (chars_allocated)
+ free (chars);
+#endif
+ if (produced == 0)
+ return 0;
+ chars = (char *) 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
+
+ Vlast_coding_system_used = coding->symbol;
+
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;
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;
+ int old_begv_byte, old_zv_byte;
Lisp_Object odeactivate;
+ int before, before_byte;
+ int opoint_byte;
odeactivate = Vdeactivate_mark;
Fset_buffer (p->buffer);
opoint = PT;
+ opoint_byte = PT_BYTE;
old_read_only = current_buffer->read_only;
- XSETFASTINT (old_begv, BEGV);
- XSETFASTINT (old_zv, ZV);
+ old_begv = BEGV;
+ old_zv = ZV;
+ old_begv_byte = BEGV_BYTE;
+ old_zv_byte = ZV_BYTE;
current_buffer->read_only = Qnil;
at the current end-of-output marker,
thus preserving logical ordering of input and output. */
if (XMARKER (p->mark)->buffer)
- SET_PT (clip_to_bounds (BEGV, marker_position (p->mark), ZV));
+ SET_PT_BOTH (clip_to_bounds (BEGV, marker_position (p->mark), ZV),
+ clip_to_bounds (BEGV_BYTE, marker_byte_position (p->mark),
+ ZV_BYTE));
else
- SET_PT (ZV);
+ SET_PT_BOTH (ZV, ZV_BYTE);
+ before = PT;
+ before_byte = PT_BYTE;
/* 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);
- Fset_marker (p->mark, make_number (PT), p->buffer);
+ if (chars_in_decoding_buf)
+ insert_from_string_before_markers (p->decoding_buf, 0, nchars, 0);
+ else
+ insert_before_markers (chars, nchars);
+ set_marker_both (p->mark, p->buffer, PT, PT_BYTE);
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;
+ opoint_byte += PT_BYTE - before_byte;
+ }
+ if (old_begv > before)
+ {
+ old_begv += PT - before;
+ old_begv_byte += PT_BYTE - before_byte;
+ }
+ if (old_zv >= before)
+ {
+ old_zv += PT - before;
+ old_zv_byte += PT_BYTE - before_byte;
+ }
+
/* 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;
current_buffer->read_only = old_read_only;
- SET_PT (opoint);
+ SET_PT_BOTH (opoint, opoint_byte);
set_buffer_internal (old);
}
#ifdef VMS
/* 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;
- char *buf;
+ unsigned char *buf;
int len;
Lisp_Object object;
{
/* 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)];
+ Vlast_coding_system_used = coding->symbol;
+
+ if (CODING_REQUIRE_ENCODING (coding))
+ {
+ int require = encoding_buffer_size (coding, len);
+ int offset, dummy;
+ unsigned 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_BYTE_POS (XBUFFER (object), buf)
+ : (STRINGP (object)
+ ? offset = buf - XSTRING (object)->data
+ : -1));
+
+ if (coding->carryover_size > 0)
+ {
+ temp_buf = (unsigned char *) xmalloc (len + coding->carryover_size);
+
+ if (offset >= 0)
+ {
+ if (BUFFERP (object))
+ buf = BUF_BYTE_ADDRESS (XBUFFER (object), offset);
+ else if (STRINGP (object))
+ buf = offset + 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 = BUF_BYTE_ADDRESS (XBUFFER (object), offset);
+ else if (STRINGP (object))
+ buf = offset + 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);
If that proves worth handling, we need to save linepos
in the process object. */
int linepos = 0;
- char *ptr = buf;
- char *end = buf + len;
+ unsigned char *ptr = buf;
+ unsigned char *end = buf + len;
/* Scan through this text for a line that is too long. */
while (ptr != end && linepos < pty_max_bytes)
/* Running filters might relocate buffers or strings.
Arrange to relocate BUF. */
if (BUFFERP (object))
- offset = BUF_PTR_CHAR_POS (XBUFFER (object),
- (unsigned char *) buf);
+ offset = BUF_PTR_BYTE_POS (XBUFFER (object), buf);
else if (STRINGP (object))
- offset = buf - (char *) XSTRING (object)->data;
+ offset = buf - 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);
+ buf = BUF_BYTE_ADDRESS (XBUFFER (object), offset);
else if (STRINGP (object))
- buf = offset + (char *) XSTRING (object)->data;
+ buf = offset + XSTRING (object)->data;
rv = 0;
}
Lisp_Object process, start, end;
{
Lisp_Object proc;
- int start1;
+ int start1, end1;
proc = get_process (process);
validate_region (&start, &end);
if (XINT (start) < GPT && XINT (end) > GPT)
- move_gap (start);
+ move_gap (XINT (start));
- start1 = XINT (start);
- send_process (proc, &FETCH_CHAR (start1), XINT (end) - XINT (start),
+ start1 = CHAR_TO_BYTE (XINT (start));
+ end1 = CHAR_TO_BYTE (XINT (end));
+ send_process (proc, BYTE_POS_ADDR (start1), end1 - start1,
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 */
/* Kill all processes associated with `buffer'.
If `buffer' is nil, kill all processes */
+void
kill_buffer_processes (buffer)
Lisp_Object buffer;
{
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
(either run the sentinel or output a message).
This is done while Emacs is waiting for keyboard input. */
+void
status_notify ()
{
register Lisp_Object proc, buffer;
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);
{
Lisp_Object ro, tem;
struct buffer *old = current_buffer;
- int opoint;
+ int opoint, opoint_byte;
+ int before, before_byte;
ro = XBUFFER (buffer)->read_only;
if (NILP (XBUFFER (buffer)->name))
continue;
Fset_buffer (buffer);
+
opoint = PT;
+ opoint_byte = PT_BYTE;
/* Insert new output into buffer
at the current end-of-output marker,
thus preserving logical ordering of input and output. */
if (XMARKER (p->mark)->buffer)
- SET_PT (marker_position (p->mark));
+ Fgoto_char (p->mark);
else
- SET_PT (ZV);
- if (PT <= opoint)
- opoint += XSTRING (msg)->size + XSTRING (p->name)->size + 10;
+ SET_PT_BOTH (ZV, ZV_BYTE);
+
+ before = PT;
+ before_byte = PT_BYTE;
tem = current_buffer->read_only;
current_buffer->read_only = Qnil;
insert_string (" ");
Finsert (1, &msg);
current_buffer->read_only = tem;
- Fset_marker (p->mark, make_number (PT), p->buffer);
+ set_marker_both (p->mark, p->buffer, PT, PT_BYTE);
+
+ if (opoint >= before)
+ SET_PT_BOTH (opoint + (PT - before),
+ opoint_byte + (PT_BYTE - before_byte));
+ else
+ SET_PT_BOTH (opoint, opoint_byte);
- 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 systems 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 ()
{
-#ifdef HAVE_SOCKETS
- stream_process = intern ("stream");
-#endif
Qprocessp = intern ("processp");
staticpro (&Qprocessp);
Qrun = intern ("run");
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