/* Asynchronous subprocess control for GNU Emacs.
- Copyright (C) 1985, 86, 87, 88, 93, 94, 95 Free Software Foundation, Inc.
+ Copyright (C) 1985, 86, 87, 88, 93, 94, 95, 96, 1998
+ Free Software Foundation, Inc.
This file is part of GNU Emacs.
You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING. If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
#include <signal.h>
#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"
+#include "keyboard.h"
+#include "dispextern.h"
+
+#define max(a, b) ((a) > (b) ? (a) : (b))
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 */
#include "sysselect.h"
-/* If we support X Windows, turn on the code to poll periodically
+/* If we support a window system, turn on the code to poll periodically
to detect C-g. It isn't actually used when doing interrupt input. */
-#ifdef HAVE_X_WINDOWS
+#ifdef HAVE_WINDOW_SYSTEM
#define POLL_FOR_INPUT
#endif
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 ();
+extern int timers_run;
+
/* Maximum number of bytes to send to a pty without an eof. */
static int pty_max_bytes;
+extern Lisp_Object Vfile_name_coding_system, Vdefault_file_name_coding_system;
+
#ifdef HAVE_PTYS
/* The file name of the pty opened by allocate_pty. */
Lisp_Object status_convert ();
+void
update_status (p)
struct Lisp_Process *p;
{
allocate_pty ()
{
struct stat stb;
- register c, i;
+ register int c, i;
int fd;
/* Some systems name their pseudoterminals so that there are gaps in
return val;
}
+void
remove_process (proc)
register Lisp_Object proc;
{
pair = Frassq (proc, Vprocess_alist);
Vprocess_alist = Fdelq (pair, Vprocess_alist);
- Fset_marker (XPROCESS (proc)->mark, Qnil, Qnil);
deactivate_process (proc);
}
\f
DEFUN ("processp", Fprocessp, Sprocessp, 1, 1, 0,
"Return t if OBJECT is a process.")
- (obj)
- Lisp_Object obj;
+ (object)
+ Lisp_Object object;
{
- return PROCESSP (obj) ? Qt : Qnil;
+ return PROCESSP (object) ? Qt : Qnil;
}
DEFUN ("get-process", Fget_process, Sget_process, 1, 1, 0,
DEFUN ("get-buffer-process", Fget_buffer_process, Sget_buffer_process, 1, 1, 0,
"Return the (or, a) process associated with BUFFER.\n\
BUFFER may be a buffer or the name of one.")
- (name)
- register Lisp_Object name;
+ (buffer)
+ register Lisp_Object buffer;
{
register Lisp_Object buf, tail, proc;
- if (NILP (name)) return Qnil;
- buf = Fget_buffer (name);
+ if (NILP (buffer)) return Qnil;
+ buf = Fget_buffer (buffer);
if (NILP (buf)) return Qnil;
for (tail = Vprocess_alist; !NILP (tail); tail = Fcdr (tail))
"Delete PROCESS: kill it and forget about it immediately.\n\
PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
nil, indicating the current buffer's process.")
- (proc)
- register Lisp_Object proc;
+ (process)
+ register Lisp_Object process;
{
- proc = get_process (proc);
- XPROCESS (proc)->raw_status_low = Qnil;
- XPROCESS (proc)->raw_status_high = Qnil;
- if (NETCONN_P (proc))
+ process = get_process (process);
+ XPROCESS (process)->raw_status_low = Qnil;
+ XPROCESS (process)->raw_status_high = Qnil;
+ if (NETCONN_P (process))
{
- XPROCESS (proc)->status = Fcons (Qexit, Fcons (make_number (0), Qnil));
- XSETINT (XPROCESS (proc)->tick, ++process_tick);
+ XPROCESS (process)->status = Fcons (Qexit, Fcons (make_number (0), Qnil));
+ XSETINT (XPROCESS (process)->tick, ++process_tick);
}
- else if (XINT (XPROCESS (proc)->infd) >= 0)
+ else if (XINT (XPROCESS (process)->infd) >= 0)
{
- Fkill_process (proc, Qnil);
+ Fkill_process (process, Qnil);
/* Do this now, since remove_process will make sigchld_handler do nothing. */
- XPROCESS (proc)->status
+ XPROCESS (process)->status
= Fcons (Qsignal, Fcons (make_number (SIGKILL), Qnil));
- XSETINT (XPROCESS (proc)->tick, ++process_tick);
+ XSETINT (XPROCESS (process)->tick, ++process_tick);
status_notify ();
}
- remove_process (proc);
+ remove_process (process);
return Qnil;
}
\f
nil -- if arg is a process name and no such process exists.\n\
PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
nil, indicating the current buffer's process.")
- (proc)
- register Lisp_Object proc;
+ (process)
+ register Lisp_Object process;
{
register struct Lisp_Process *p;
register Lisp_Object status;
- if (STRINGP (proc))
- proc = Fget_process (proc);
+ if (STRINGP (process))
+ process = Fget_process (process);
else
- proc = get_process (proc);
+ process = get_process (process);
- if (NILP (proc))
- return proc;
+ if (NILP (process))
+ return process;
- p = XPROCESS (proc);
+ p = XPROCESS (process);
if (!NILP (p->raw_status_low))
update_status (p);
status = p->status;
if (CONSP (status))
status = XCONS (status)->car;
- if (NETCONN_P (proc))
+ if (NETCONN_P (process))
{
if (EQ (status, Qrun))
status = Qopen;
1, 1, 0,
"Return the exit status of PROCESS or the signal number that killed it.\n\
If PROCESS has not yet exited or died, return 0.")
- (proc)
- register Lisp_Object proc;
+ (process)
+ register Lisp_Object process;
{
- CHECK_PROCESS (proc, 0);
- if (!NILP (XPROCESS (proc)->raw_status_low))
- update_status (XPROCESS (proc));
- if (CONSP (XPROCESS (proc)->status))
- return XCONS (XCONS (XPROCESS (proc)->status)->cdr)->car;
+ CHECK_PROCESS (process, 0);
+ if (!NILP (XPROCESS (process)->raw_status_low))
+ update_status (XPROCESS (process));
+ if (CONSP (XPROCESS (process)->status))
+ return XCONS (XCONS (XPROCESS (process)->status)->cdr)->car;
return make_number (0);
}
"Return the process id of PROCESS.\n\
This is the pid of the Unix process which PROCESS uses or talks to.\n\
For a network connection, this value is nil.")
- (proc)
- register Lisp_Object proc;
+ (process)
+ register Lisp_Object process;
{
- CHECK_PROCESS (proc, 0);
- return XPROCESS (proc)->pid;
+ CHECK_PROCESS (process, 0);
+ return XPROCESS (process)->pid;
}
DEFUN ("process-name", Fprocess_name, Sprocess_name, 1, 1, 0,
"Return the name of PROCESS, as a string.\n\
This is the name of the program invoked in PROCESS,\n\
possibly modified to make it unique among process names.")
- (proc)
- register Lisp_Object proc;
+ (process)
+ register Lisp_Object process;
{
- CHECK_PROCESS (proc, 0);
- return XPROCESS (proc)->name;
+ CHECK_PROCESS (process, 0);
+ return XPROCESS (process)->name;
}
DEFUN ("process-command", Fprocess_command, Sprocess_command, 1, 1, 0,
This is a list of strings, the first string being the program executed\n\
and the rest of the strings being the arguments given to it.\n\
For a non-child channel, this is nil.")
- (proc)
- register Lisp_Object proc;
+ (process)
+ register Lisp_Object process;
{
- CHECK_PROCESS (proc, 0);
- return XPROCESS (proc)->command;
+ CHECK_PROCESS (process, 0);
+ return XPROCESS (process)->command;
}
DEFUN ("process-tty-name", Fprocess_tty_name, Sprocess_tty_name, 1, 1, 0,
"Return the name of the terminal PROCESS uses, or nil if none.\n\
This is the terminal that the process itself reads and writes on,\n\
not the name of the pty that Emacs uses to talk with that terminal.")
- (proc)
- register Lisp_Object proc;
+ (process)
+ register Lisp_Object process;
{
- CHECK_PROCESS (proc, 0);
- return XPROCESS (proc)->tty_name;
+ CHECK_PROCESS (process, 0);
+ return XPROCESS (process)->tty_name;
}
DEFUN ("set-process-buffer", Fset_process_buffer, Sset_process_buffer,
2, 2, 0,
"Set buffer associated with PROCESS to BUFFER (a buffer, or nil).")
- (proc, buffer)
- register Lisp_Object proc, buffer;
+ (process, buffer)
+ register Lisp_Object process, buffer;
{
- CHECK_PROCESS (proc, 0);
+ CHECK_PROCESS (process, 0);
if (!NILP (buffer))
CHECK_BUFFER (buffer, 1);
- XPROCESS (proc)->buffer = buffer;
+ XPROCESS (process)->buffer = buffer;
return buffer;
}
"Return the buffer PROCESS is associated with.\n\
Output from PROCESS is inserted in this buffer\n\
unless PROCESS has a filter.")
- (proc)
- register Lisp_Object proc;
+ (process)
+ register Lisp_Object process;
{
- CHECK_PROCESS (proc, 0);
- return XPROCESS (proc)->buffer;
+ CHECK_PROCESS (process, 0);
+ return XPROCESS (process)->buffer;
}
DEFUN ("process-mark", Fprocess_mark, Sprocess_mark,
1, 1, 0,
"Return the marker for the end of the last output from PROCESS.")
- (proc)
- register Lisp_Object proc;
+ (process)
+ register Lisp_Object process;
{
- CHECK_PROCESS (proc, 0);
- return XPROCESS (proc)->mark;
+ CHECK_PROCESS (process, 0);
+ return XPROCESS (process)->mark;
}
DEFUN ("set-process-filter", Fset_process_filter, Sset_process_filter,
the entire string of output is passed to the filter.\n\
The filter gets two arguments: the process and the string of output.\n\
If the process has a filter, its buffer is not used for output.")
- (proc, filter)
- register Lisp_Object proc, filter;
+ (process, filter)
+ register Lisp_Object process, filter;
{
- CHECK_PROCESS (proc, 0);
+ CHECK_PROCESS (process, 0);
if (EQ (filter, Qt))
{
- FD_CLR (XINT (XPROCESS (proc)->infd), &input_wait_mask);
- FD_CLR (XINT (XPROCESS (proc)->infd), &non_keyboard_wait_mask);
+ FD_CLR (XINT (XPROCESS (process)->infd), &input_wait_mask);
+ FD_CLR (XINT (XPROCESS (process)->infd), &non_keyboard_wait_mask);
}
- else if (EQ (XPROCESS (proc)->filter, Qt))
+ else if (EQ (XPROCESS (process)->filter, Qt))
{
- FD_SET (XINT (XPROCESS (proc)->infd), &input_wait_mask);
- FD_SET (XINT (XPROCESS (proc)->infd), &non_keyboard_wait_mask);
+ FD_SET (XINT (XPROCESS (process)->infd), &input_wait_mask);
+ FD_SET (XINT (XPROCESS (process)->infd), &non_keyboard_wait_mask);
}
- XPROCESS (proc)->filter = filter;
+ XPROCESS (process)->filter = filter;
return filter;
}
1, 1, 0,
"Returns the filter function of PROCESS; nil if none.\n\
See `set-process-filter' for more info on filter functions.")
- (proc)
- register Lisp_Object proc;
+ (process)
+ register Lisp_Object process;
{
- CHECK_PROCESS (proc, 0);
- return XPROCESS (proc)->filter;
+ CHECK_PROCESS (process, 0);
+ return XPROCESS (process)->filter;
}
DEFUN ("set-process-sentinel", Fset_process_sentinel, Sset_process_sentinel,
"Give PROCESS the sentinel SENTINEL; nil for none.\n\
The sentinel is called as a function when the process changes state.\n\
It gets two arguments: the process, and a string describing the change.")
- (proc, sentinel)
- register Lisp_Object proc, sentinel;
+ (process, sentinel)
+ register Lisp_Object process, sentinel;
{
- CHECK_PROCESS (proc, 0);
- XPROCESS (proc)->sentinel = sentinel;
+ CHECK_PROCESS (process, 0);
+ XPROCESS (process)->sentinel = sentinel;
return sentinel;
}
1, 1, 0,
"Return the sentinel of PROCESS; nil if none.\n\
See `set-process-sentinel' for more info on sentinels.")
- (proc)
- register Lisp_Object proc;
+ (process)
+ register Lisp_Object process;
{
- CHECK_PROCESS (proc, 0);
- return XPROCESS (proc)->sentinel;
+ CHECK_PROCESS (process, 0);
+ return XPROCESS (process)->sentinel;
}
DEFUN ("set-process-window-size", Fset_process_window_size,
Sset_process_window_size, 3, 3, 0,
"Tell PROCESS that it has logical window size HEIGHT and WIDTH.")
- (proc, height, width)
- register Lisp_Object proc, height, width;
+ (process, height, width)
+ register Lisp_Object process, height, width;
{
- CHECK_PROCESS (proc, 0);
+ CHECK_PROCESS (process, 0);
CHECK_NATNUM (height, 0);
CHECK_NATNUM (width, 0);
- if (set_window_size (XINT (XPROCESS (proc)->infd),
+ if (set_window_size (XINT (XPROCESS (process)->infd),
XINT (height), XINT(width)) <= 0)
return Qnil;
else
"Say no query needed if PROCESS is running when Emacs is exited.\n\
Optional second argument if non-nil says to require a query.\n\
Value is t if a query was formerly required.")
- (proc, value)
- register Lisp_Object proc, value;
+ (process, value)
+ register Lisp_Object process, value;
{
Lisp_Object tem;
- CHECK_PROCESS (proc, 0);
- tem = XPROCESS (proc)->kill_without_query;
- XPROCESS (proc)->kill_without_query = Fnull (value);
+ CHECK_PROCESS (process, 0);
+ tem = XPROCESS (process)->kill_without_query;
+ XPROCESS (process)->kill_without_query = Fnull (value);
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\
-Third arg is program file name. It is searched for as in the shell.\n\
+ with any buffer.\n\
+Third arg is program file name. It is searched for in PATH.\n\
Remaining arguments are strings to give program as arguments.")
(nargs, args)
int nargs;
#ifdef VMS
/* Make a one member argv with all args concatenated
together separated by a blank. */
- len = XSTRING (program)->size + 2;
+ len = STRING_BYTES (XSTRING (program)) + 2;
for (i = 3; i < nargs; i++)
{
tem = args[i];
CHECK_STRING (tem, i);
- len += XSTRING (tem)->size + 1; /* count the blank */
+ len += STRING_BYTES (XSTRING (tem)) + 1; /* count the blank */
}
new_argv = (unsigned char *) alloca (len);
strcpy (new_argv, XSTRING (program)->data);
/* 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)));
+
+ 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 = Qraw_text;
+ 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;
- create_process (proc, new_argv, current_dir);
+ 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)->decoding_carryover = make_number (0);
+ XPROCESS (proc)->encoding_buf = make_uninit_string (0);
+ XPROCESS (proc)->encoding_carryover = make_number (0);
+
+ create_process (proc, (char **) new_argv, current_dir);
return unbind_to (count, proc);
}
/* This function is the unwind_protect form for Fstart_process. If
- PROC doesn't have its pid set, then we know someone has signalled
+ PROC doesn't have its pid set, then we know someone has signaled
an error and the process wasn't started successfully, so we should
remove it from the process list. */
static Lisp_Object
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);
#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;
{
int pid, inchannel, outchannel;
int sv[2];
+#ifdef POSIX_SIGNALS
+ sigset_t procmask;
+ sigset_t blocked;
+ struct sigaction sigint_action;
+ struct sigaction sigquit_action;
+#ifdef AIX
+ struct sigaction sighup_action;
+#endif
+#else /* !POSIX_SIGNALS */
#ifdef SIGCHLD
SIGTYPE (*sigchld)();
#endif
+#endif /* !POSIX_SIGNALS */
/* Use volatile to protect variables from being clobbered by longjmp. */
volatile int forkin, forkout;
volatile int pty_flag = 0;
}
#else /* not SKTPAIR */
{
-#ifdef WINDOWSNT
- pipe_with_inherited_out (sv);
- inchannel = sv[0];
- forkout = sv[1];
-
- pipe_with_inherited_in (sv);
- forkin = sv[0];
- outchannel = sv[1];
-#else /* not WINDOWSNT */
pipe (sv);
inchannel = sv[0];
forkout = sv[1];
pipe (sv);
outchannel = sv[1];
forkin = sv[0];
-#endif /* not WINDOWSNT */
}
#endif /* not SKTPAIR */
#ifdef O_NONBLOCK
fcntl (inchannel, F_SETFL, O_NONBLOCK);
+ fcntl (outchannel, F_SETFL, O_NONBLOCK);
#else
#ifdef O_NDELAY
fcntl (inchannel, F_SETFL, O_NDELAY);
+ fcntl (outchannel, F_SETFL, O_NDELAY);
#endif
#endif
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->mode |= CODING_MODE_LAST_BLOCK;
+ 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);
+
+ encode_coding (coding, new_argv[i], buf, len, size);
+ buf[coding->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->mode &= ~CODING_MODE_LAST_BLOCK;
+ }
/* Delay interrupts until we have a chance to store
the new fork's pid in its process structure */
+#ifdef POSIX_SIGNALS
+ sigemptyset (&blocked);
+#ifdef SIGCHLD
+ sigaddset (&blocked, SIGCHLD);
+#endif
+#ifdef HAVE_VFORK
+ /* On many hosts (e.g. Solaris 2.4), if a vforked child calls `signal',
+ this sets the parent's signal handlers as well as the child's.
+ So delay all interrupts whose handlers the child might munge,
+ and record the current handlers so they can be restored later. */
+ sigaddset (&blocked, SIGINT ); sigaction (SIGINT , 0, &sigint_action );
+ sigaddset (&blocked, SIGQUIT); sigaction (SIGQUIT, 0, &sigquit_action);
+#ifdef AIX
+ sigaddset (&blocked, SIGHUP ); sigaction (SIGHUP , 0, &sighup_action );
+#endif
+#endif /* HAVE_VFORK */
+ sigprocmask (SIG_BLOCK, &blocked, &procmask);
+#else /* !POSIX_SIGNALS */
#ifdef SIGCHLD
#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
#endif /* ordinary USG */
#endif /* not BSD4_1 */
#endif /* SIGCHLD */
+#endif /* !POSIX_SIGNALS */
FD_SET (inchannel, &input_wait_mask);
FD_SET (inchannel, &non_keyboard_wait_mask);
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 = ENCODE_FILE (current_dir);
+
#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);
}
#endif /* TIOCNOTTY */
-#if !defined (RTU) && !defined (UNIPLUS)
+#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)
ioctl (xforkout, TIOCSPGRP, &pgrp);
#endif
}
-#endif /* not UNIPLUS and not RTU */
+#endif /* not UNIPLUS and not RTU and not DONT_REOPEN_PTY */
+
#ifdef SETUP_SLAVE_PTY
if (pty_flag)
{
#endif
#endif /* HAVE_PTYS */
+ signal (SIGINT, SIG_DFL);
+ signal (SIGQUIT, SIG_DFL);
+
+ /* Stop blocking signals in the child. */
+#ifdef POSIX_SIGNALS
+ sigprocmask (SIG_SETMASK, &procmask, 0);
+#else /* !POSIX_SIGNALS */
#ifdef SIGCHLD
#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 /* ordinary USG */
#endif /* not BSD4_1 */
#endif /* SIGCHLD */
-
- signal (SIGINT, SIG_DFL);
- signal (SIGQUIT, SIG_DFL);
+#endif /* !POSIX_SIGNALS */
if (pty_flag)
child_setup_tty (xforkout);
environ = save_environ;
}
+ UNBLOCK_INPUT;
+
+ /* This runs in the Emacs process. */
if (pid < 0)
{
if (forkin >= 0)
close (forkin);
if (forkin != forkout && forkout >= 0)
close (forkout);
- report_file_error ("Doing vfork", Qnil);
}
-
- XSETFASTINT (XPROCESS (process)->pid, pid);
+ else
+ {
+ /* vfork succeeded. */
+ XSETFASTINT (XPROCESS (process)->pid, pid);
#ifdef WINDOWSNT
- register_child (pid, inchannel);
+ register_child (pid, inchannel);
#endif /* WINDOWSNT */
- /* If the subfork execv fails, and it exits,
- this close hangs. I don't know why.
- So have an interrupt jar it loose. */
- stop_polling ();
- signal (SIGALRM, create_process_1);
- alarm (1);
- XPROCESS (process)->subtty = Qnil;
- if (forkin >= 0)
- close (forkin);
- alarm (0);
- start_polling ();
- if (forkin != forkout && forkout >= 0)
- close (forkout);
+ /* If the subfork execv fails, and it exits,
+ this close hangs. I don't know why.
+ So have an interrupt jar it loose. */
+ stop_polling ();
+ signal (SIGALRM, create_process_1);
+ alarm (1);
+ XPROCESS (process)->subtty = Qnil;
+ if (forkin >= 0)
+ close (forkin);
+ alarm (0);
+ start_polling ();
+ if (forkin != forkout && forkout >= 0)
+ close (forkout);
#ifdef HAVE_PTYS
- if (pty_flag)
- XPROCESS (process)->tty_name = build_string (pty_name);
- else
+ if (pty_flag)
+ XPROCESS (process)->tty_name = build_string (pty_name);
+ else
#endif
- XPROCESS (process)->tty_name = Qnil;
+ XPROCESS (process)->tty_name = Qnil;
+ }
+ /* Restore the signal state whether vfork succeeded or not.
+ (We will signal an error, below, if it failed.) */
+#ifdef POSIX_SIGNALS
+#ifdef HAVE_VFORK
+ /* Restore the parent's signal handlers. */
+ sigaction (SIGINT, &sigint_action, 0);
+ sigaction (SIGQUIT, &sigquit_action, 0);
+#ifdef AIX
+ sigaction (SIGHUP, &sighup_action, 0);
+#endif
+#endif /* HAVE_VFORK */
+ /* Stop blocking signals in the parent. */
+ sigprocmask (SIG_SETMASK, &procmask, 0);
+#else /* !POSIX_SIGNALS */
#ifdef SIGCHLD
#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 /* ordinary USG */
#endif /* not BSD4_1 */
#endif /* SIGCHLD */
+#endif /* !POSIX_SIGNALS */
+
+ /* Now generate the error if vfork failed. */
+ if (pid < 0)
+ report_file_error ("Doing vfork", Qnil);
}
#endif /* not VMS */
int retry = 0;
int count = specpdl_ptr - specpdl;
+#ifdef WINDOWSNT
+ /* Ensure socket support is loaded if available. */
+ init_winsock (TRUE);
+#endif
+
GCPRO4 (name, buffer, host, service);
CHECK_STRING (name, 0);
CHECK_STRING (host, 0);
port = svc_info->s_port;
}
+ /* Slow down polling to every ten seconds.
+ Some kernels have a bug which causes retrying connect to fail
+ after a connect. Polling can interfere with gethostbyname too. */
+#ifdef POLL_FOR_INPUT
+ bind_polling_period (10);
+#endif
+
#ifndef TERM
while (1)
{
#ifdef TRY_AGAIN
h_errno = 0;
#endif
+ immediate_quit = 1;
+ QUIT;
host_info_ptr = gethostbyname (XSTRING (host)->data);
+ immediate_quit = 0;
#ifdef TRY_AGAIN
if (! (host_info_ptr == 0 && h_errno == TRY_AGAIN))
#endif
#endif
host_info.h_addr = (char*)(&numeric_addr);
addr_list[1] = 0;
- host_info.h_length = strlen (addr_list[0]);
+ /* numeric_addr isn't null-terminated; it has fixed length. */
+ host_info.h_length = sizeof (numeric_addr);
}
bzero (&address, sizeof address);
if (interrupt_input)
unrequest_sigio ();
- /* Slow down polling to every ten seconds.
- Some kernels have a bug which causes retrying connect to fail
- after a connect. */
-#ifdef POLL_FOR_INPUT
- bind_polling_period (10);
-#endif
-
loop:
+
+ immediate_quit = 1;
+ QUIT;
+
if (connect (s, (struct sockaddr *) &address, sizeof address) == -1
&& errno != EISCONN)
{
int xerrno = errno;
+ immediate_quit = 0;
+
if (errno == EINTR)
goto loop;
if (errno == EADDRINUSE && retry < 20)
Fcons (host, Fcons (name, Qnil)));
}
+ immediate_quit = 0;
+
#ifdef POLL_FOR_INPUT
unbind_to (count, Qnil);
#endif
#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);
#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;
XPROCESS (proc)->filter = Qnil;
XPROCESS (proc)->command = Qnil;
XPROCESS (proc)->pid = Qnil;
- XSETINT (XPROCESS (proc)->infd, s);
+ XSETINT (XPROCESS (proc)->infd, inch);
XSETINT (XPROCESS (proc)->outfd, outch);
XPROCESS (proc)->status = Qrun;
FD_SET (inch, &input_wait_mask);
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
+ Qraw_text, 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)->decoding_carryover = make_number (0);
+ XPROCESS (proc)->encoding_buf = make_uninit_string (0);
+ XPROCESS (proc)->encoding_carryover = make_number (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
seconds and microseconds to wait; return after that much time whether\n\
or not there is input.\n\
Return non-nil iff we received any output before the timeout expired.")
- (proc, timeout, timeout_msecs)
- register Lisp_Object proc, timeout, timeout_msecs;
+ (process, timeout, timeout_msecs)
+ register Lisp_Object process, timeout, timeout_msecs;
{
int seconds;
int useconds;
{
CHECK_NUMBER (timeout, 1);
seconds = XINT (timeout);
- if (seconds <= 0)
+ if (seconds < 0 || (seconds == 0 && useconds == 0))
seconds = -1;
}
else
{
- if (NILP (proc))
+ if (NILP (process))
seconds = -1;
else
seconds = 0;
}
- if (NILP (proc))
- XSETFASTINT (proc, 0);
+ if (NILP (process))
+ XSETFASTINT (process, 0);
return
- (wait_reading_process_input (seconds, useconds, proc, 0)
+ (wait_reading_process_input (seconds, useconds, process, 0)
? Qt : Qnil);
}
when not inside wait_reading_process_input. */
static int waiting_for_user_input_p;
+/* This is here so breakpoints can be put on it. */
+static void
+wait_reading_process_input_1 ()
+{
+}
+
/* Read and dispose of subprocess output while waiting for timeout to
elapse and/or keyboard input to be available.
before the timeout elapsed.
Otherwise, return true iff we received input from any process. */
+int
wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
int time_limit, microsecs;
Lisp_Object read_kbd;
EMACS_SET_SECS_USECS (timeout, time_limit, microsecs);
EMACS_ADD_TIME (end_time, end_time, timeout);
}
+#ifdef hpux
+ /* AlainF 5-Jul-1996
+ HP-UX 10.10 seem to have problems with signals coming in
+ Causes "poll: interrupted system call" messages when Emacs is run
+ in an X window
+ Turn off periodic alarms (in case they are in use) */
+ stop_polling ();
+#endif
while (1)
{
+ int timeout_reduced_for_timers = 0;
+
/* If calling from keyboard input, do not quit
since we want to return C-g as an input character.
Otherwise, do pending quit if requested. */
EMACS_SET_SECS_USECS (timeout, 100000, 0);
}
+ /* Normally we run timers here.
+ But not if wait_for_cell; in those cases,
+ the wait is supposed to be short,
+ and those callers cannot handle running arbitrary Lisp code here. */
+ if (! wait_for_cell)
+ {
+ EMACS_TIME timer_delay;
+ int old_timers_run;
+
+ retry:
+ old_timers_run = timers_run;
+ timer_delay = timer_check (1);
+ if (timers_run != old_timers_run && do_display)
+ {
+ redisplay_preserve_echo_area ();
+ /* We must retry, since a timer may have requeued itself
+ and that could alter the time_delay. */
+ 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;
+ EMACS_SUB_TIME (difference, timer_delay, timeout);
+ if (EMACS_TIME_NEG_P (difference))
+ {
+ timeout = timer_delay;
+ timeout_reduced_for_timers = 1;
+ }
+ }
+ /* If time_limit is -1, we are not going to wait at all. */
+ else if (time_limit != -1)
+ {
+ /* This is so a breakpoint can be put here. */
+ wait_reading_process_input_1 ();
+ }
+ }
+
/* Cause C-g and alarm signals to take immediate action,
and cause input available signals to zero out timeout.
{
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;
/* If we woke up due to SIGWINCH, actually change size now. */
do_pending_window_change ();
- if (time_limit && nfds == 0) /* timeout elapsed */
+ if (time_limit && nfds == 0 && ! timeout_reduced_for_timers)
+ /* We wanted the full specified time, so return now. */
break;
if (nfds < 0)
{
#endif
}
else
- error("select error: %s", strerror (xerrno));
+ error ("select error: %s", strerror (xerrno));
}
#if defined(sun) && !defined(USG5_4)
else if (nfds > 0 && keyboard_bit_set (&Available)
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 */
- /* We used to do this if wait_for_cell,
- but that caused infinite recursion in selection request events. */
- if ((XINT (read_kbd) || wait_for_cell)
- && detect_input_pending ())
+ if (XINT (read_kbd) != 0
+ && detect_input_pending_run_timers (do_display))
{
- swallow_events ();
+ swallow_events (do_display);
+ if (detect_input_pending_run_timers (do_display))
+ break;
+ }
+
+ /* 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)))
- kill (0, SIGIO);
+ && keyboard_bit_set (&Available))
+ kill (getpid (), SIGIO);
#endif
if (! wait_proc)
#ifdef EWOULDBLOCK
else if (nread == -1 && errno == EWOULDBLOCK)
;
-#else
+#endif
+ /* ISC 4.1 defines both EWOULDBLOCK and O_NONBLOCK,
+ and Emacs uses O_NONBLOCK, so what we get is EAGAIN. */
#ifdef O_NONBLOCK
else if (nread == -1 && errno == EAGAIN)
;
;
#endif /* O_NDELAY */
#endif /* O_NONBLOCK */
-#endif /* EWOULDBLOCK */
#ifdef HAVE_PTYS
/* On some OSs with ptys, when the process on one end of
a pty exits, the other end gets an error reading with
clear_input_pending ();
QUIT;
}
-
+#ifdef hpux
+ /* AlainF 5-Jul-1996
+ HP-UX 10.10 seems to have problems with signals coming in
+ Causes "poll: interrupted system call" messages when Emacs is run
+ in an X window
+ Turn periodic alarms back on */
+ start_polling ();
+#endif
+
return got_some_input;
}
\f
/* 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. */
+int
read_process_output (proc, channel)
Lisp_Object proc;
register int channel;
{
- register int nchars;
-#ifdef VMS
+ register int nchars, nbytes;
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. */
+ int carryover = XINT (p->decoding_carryover);
#ifdef VMS
VMS_PROC_STUFF *vs, *get_vms_process_pointer();
else
error ("Could not get VMS process pointer");
chars = vs->inputBuffer;
- nchars = clean_vms_buffer (chars, vs->iosb[1]);
- if (nchars <= 0)
+ nbytes = clean_vms_buffer (chars, vs->iosb[1]);
+ if (nbytes <= 0)
{
start_vms_process_read (vs); /* Crank up the next read on the process */
return 1; /* Nothing worth printing, say we got 1 */
}
+ if (carryover > 0)
+ {
+ /* The data carried over in the previous decoding (which are at
+ the tail of decoding buffer) should be prepended to the new
+ data read to decode all together. */
+ char *buf = (char *) xmalloc (nbytes + carryover);
+
+ bcopy (XSTRING (p->decoding_buf)->data
+ + STRING_BYTES (XSTRING (p->decoding_buf)) - carryover,
+ buf, carryover);
+ bcopy (chars, buf + carryover, nbytes);
+ chars = buf;
+ chars_allocated = 1;
+ }
#else /* not VMS */
+ if (carryover)
+ /* See the comment above. */
+ bcopy (XSTRING (p->decoding_buf)->data
+ + STRING_BYTES (XSTRING (p->decoding_buf)) - carryover,
+ buf, carryover);
+
if (proc_buffered_char[channel] < 0)
-#ifdef WINDOWSNT
- nchars = read_child_output (channel, chars, sizeof (chars));
-#else
- nchars = read (channel, chars, sizeof chars);
-#endif
+ nbytes = read (channel, buf + carryover, (sizeof buf) - carryover);
else
{
- chars[0] = proc_buffered_char[channel];
+ buf[carryover] = proc_buffered_char[channel];
proc_buffered_char[channel] = -1;
-#ifdef WINDOWSNT
- nchars = read_child_output (channel, chars + 1, sizeof (chars) - 1);
-#else
- nchars = read (channel, chars + 1, sizeof chars - 1);
-#endif
- if (nchars < 0)
- nchars = 1;
+ nbytes = read (channel, buf + carryover + 1,
+ (sizeof buf) - carryover - 1);
+ if (nbytes < 0)
+ nbytes = 1;
else
- nchars = nchars + 1;
+ nbytes = nbytes + 1;
}
+ chars = buf;
#endif /* not VMS */
- if (nchars <= 0) return nchars;
+ /* At this point, NBYTES holds number of characters just received
+ (including the one in proc_buffered_char[channel]). */
+ if (nbytes <= 0) return nbytes;
+
+ /* Now set NBYTES how many bytes we must decode. */
+ nbytes += carryover;
+ nchars = nbytes;
+
+ if (CODING_MAY_REQUIRE_DECODING (coding))
+ {
+ int require = decoding_buffer_size (coding, nbytes);
+ int result;
+
+ if (STRING_BYTES (XSTRING (p->decoding_buf)) < require)
+ p->decoding_buf = make_uninit_string (require);
+ result = decode_coding (coding, chars, XSTRING (p->decoding_buf)->data,
+ nbytes, STRING_BYTES (XSTRING (p->decoding_buf)));
+ carryover = nbytes - coding->consumed;
+
+ /* A 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 a 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 (coding->produced == 0)
+ return 0;
+ chars = (char *) XSTRING (p->decoding_buf)->data;
+ nbytes = coding->produced;
+ nchars = (coding->fake_multibyte
+ ? multibyte_chars_in_text (chars, nbytes)
+ : coding->produced_char);
+ 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)
+ || STRING_BYTES (XSTRING (p->decoding_buf)) < nbytes)
+ p->decoding_buf = make_uninit_string (nbytes);
+ bcopy (chars, XSTRING (p->decoding_buf)->data, nbytes);
+ free (chars);
+ chars = XSTRING (p->decoding_buf)->data;
+ nchars = multibyte_chars_in_text (chars, nbytes);
+ chars_in_decoding_buf = 1;
+ carryover = 0;
+ }
+#endif
+
+ XSETINT (p->decoding_carryover, carryover);
+ Vlast_coding_system_used = coding->symbol;
+ /* Read and dispose of the process output. */
outstream = p->filter;
if (!NILP (outstream))
{
int count = specpdl_ptr - specpdl;
Lisp_Object odeactivate;
Lisp_Object obuffer, okeymap;
+ Lisp_Object text;
+ 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 (Fset_match_data, Fmatch_data (Qnil, Qnil));
+ Fset_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;
+
+ text = make_string_from_bytes (chars, nchars, nbytes);
internal_condition_case_1 (read_process_output_call,
Fcons (outstream,
- Fcons (proc,
- Fcons (make_string (chars,
- nchars),
- Qnil))),
+ Fcons (proc, Fcons (text, 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 0 /* Call record_asynch_buffer_change unconditionally,
+ because we might have changed minor modes or other things
+ that affect key bindings. */
if (! EQ (Fcurrent_buffer (), obuffer)
|| ! EQ (current_buffer->keymap, okeymap))
- record_asynch_buffer_change ();
-
- if (waiting_for_user_input_p)
- prepare_menu_bars ();
+#endif
+ /* But do it only if the caller is actually going to read events.
+ Otherwise there's no need to make him wake up, and it could
+ cause trouble (for example it would make Fsit_for return). */
+ if (waiting_for_user_input_p == -1)
+ record_asynch_buffer_change ();
#ifdef VMS
start_vms_process_read (vs);
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 = point;
+ 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 <= 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)
- opoint += nchars;
-
- /* Insert after old_begv, but before old_zv. */
- if (point < XFASTINT (old_begv))
- XSETFASTINT (old_begv, XFASTINT (old_begv) + nchars);
- if (point <= 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)
+ {
+ /* Since multibyteness of p->docoding_buf is corrupted, we
+ can't use insert_from_string_before_markers. */
+ char *temp_buf;
+
+ temp_buf = (char *) alloca (nbytes);
+ bcopy (XSTRING (p->decoding_buf)->data, temp_buf, nbytes);
+ insert_before_markers (temp_buf, nbytes);
+ }
+ else
+ insert_1_both (chars, nchars, nbytes, 0, 1, 1);
+ 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
start_vms_process_read (vs);
#endif
- return nchars;
+ return nbytes;
}
DEFUN ("waiting-for-user-input-p", Fwaiting_for_user_input_p, Swaiting_for_user_input_p,
/* 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? */
+void
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;
+ int carryover = XINT (XPROCESS (proc)->encoding_carryover);
+
+ 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)];
+ 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 (carryover > 0)
+ {
+ temp_buf = (unsigned char *) xmalloc (len + carryover);
+
+ 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 ((XSTRING (XPROCESS (proc)->encoding_buf)->data
+ + STRING_BYTES (XSTRING (XPROCESS (proc)->encoding_buf))
+ - carryover),
+ temp_buf,
+ carryover);
+ bcopy (buf, temp_buf + carryover, len);
+ buf = temp_buf;
+ }
+
+ if (STRING_BYTES (XSTRING (XPROCESS (proc)->encoding_buf)) < 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;
+ encode_coding (coding, buf, XSTRING (object)->data,
+ len, STRING_BYTES (XSTRING (object)));
+ len = coding->produced;
+ 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;
}
error ("SIGPIPE raised on process %s; closed it", procname);
#endif
}
+
+ UNGCPRO;
}
DEFUN ("process-send-region", Fprocess_send_region, Sprocess_send_region,
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;
Lisp_Object proc;
CHECK_STRING (string, 1);
proc = get_process (process);
- send_process (proc, XSTRING (string)->data, XSTRING (string)->size, string);
+ send_process (proc, XSTRING (string)->data,
+ STRING_BYTES (XSTRING (string)), string);
return Qnil;
}
\f
#undef handle_signal
-#ifdef WINDOWSNT
- /* Only works for kill-type signals */
- return make_number (win32_kill_process (XINT (pid), XINT (sigcode)));
-#else
return make_number (kill (XINT (pid), XINT (sigcode)));
-#endif
}
DEFUN ("process-send-eof", Fprocess_send_eof, Sprocess_send_eof, 0, 1, 0,
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;
{
/* 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
/* Find the process that signaled us, and record its status. */
p = 0;
- for (tail = Vprocess_alist; XSYMBOL (tail) != XSYMBOL (Qnil); tail = XCONS (tail)->cdr)
+ for (tail = Vprocess_alist; CONSP (tail); tail = XCONS (tail)->cdr)
{
proc = XCONS (XCONS (tail)->car)->cdr;
p = XPROCESS (proc);
/* Look for an asynchronous process whose pid hasn't been filled
in yet. */
if (p == 0)
- for (tail = Vprocess_alist; XSYMBOL (tail) != XSYMBOL (Qnil); tail = XCONS (tail)->cdr)
+ for (tail = Vprocess_alist; CONSP (tail); tail = XCONS (tail)->cdr)
{
proc = XCONS (XCONS (tail)->car)->cdr;
p = XPROCESS (proc);
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 (Fset_match_data, Fmatch_data (Qnil, Qnil));
+ Fset_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
if (! EQ (Fcurrent_buffer (), obuffer)
|| ! EQ (current_buffer->keymap, okeymap))
- record_asynch_buffer_change ();
+#endif
+ /* But do it only if the caller is actually going to read events.
+ Otherwise there's no need to make him wake up, and it could
+ cause trouble (for example it would make Fsit_for return). */
+ if (waiting_for_user_input_p == -1)
+ record_asynch_buffer_change ();
- if (waiting_for_user_input_p)
- prepare_menu_bars ();
unbind_to (count, Qnil);
}
(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 = point;
+
+ 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 (point <= 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 (point), 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++)
return 0;
}
\f
+void
init_process ()
{
register int i;
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);
}
+void
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
extern int frame_garbaged;
+extern EMACS_TIME timer_check ();
+extern int timers_run;
/* As described above, except assuming that there are no subprocesses:
1 to return when input is available, or
-1 means caller will actually read the input, so don't throw to
the quit handler.
+ a cons cell, meaning wait until its car is non-nil
+ (and gobble terminal input into the buffer if any arrives), or
We know that read_kbd will never be a Lisp_Process, since
`subprocesses' isn't defined.
Lisp_Object read_kbd;
int do_display;
{
- EMACS_TIME end_time, timeout, *timeout_p;
- int waitchannels;
+ EMACS_TIME end_time, timeout;
+ SELECT_TYPE waitchannels;
+ int xerrno;
+ Lisp_Object *wait_for_cell = 0;
+
+ /* If waiting for non-nil in a cell, record where. */
+ if (CONSP (read_kbd))
+ {
+ wait_for_cell = &XCONS (read_kbd)->car;
+ XSETFASTINT (read_kbd, 0);
+ }
/* What does time_limit really mean? */
if (time_limit || microsecs)
{
- /* It's not infinite. */
- timeout_p = &timeout;
-
if (time_limit == -1)
/* In fact, it's zero. */
EMACS_SET_SECS_USECS (timeout, 0, 0);
}
else
/* It's infinite. */
- timeout_p = 0;
-
- /* This must come before stop_polling. */
- prepare_menu_bars ();
+ EMACS_SET_SECS_USECS (timeout, 100000, 0);
/* Turn off periodic alarms (in case they are in use)
because the select emulator uses alarms. */
for (;;)
{
int nfds;
-
- waitchannels = XINT (read_kbd) ? 1 : 0;
+ int timeout_reduced_for_timers = 0;
/* If calling from keyboard input, do not quit
since we want to return C-g as an input character.
if (XINT (read_kbd) >= 0)
QUIT;
- if (timeout_p)
+ /* Exit now if the cell we're waiting for became non-nil. */
+ if (wait_for_cell && ! NILP (*wait_for_cell))
+ break;
+
+ /* Compute time from now till when time limit is up */
+ /* Exit if already run out */
+ if (time_limit > 0 || microsecs)
{
- EMACS_GET_TIME (*timeout_p);
- EMACS_SUB_TIME (*timeout_p, end_time, *timeout_p);
- if (EMACS_TIME_NEG_P (*timeout_p))
+ EMACS_GET_TIME (timeout);
+ EMACS_SUB_TIME (timeout, end_time, timeout);
+ if (EMACS_TIME_NEG_P (timeout))
break;
}
+ /* If our caller will not immediately handle keyboard events,
+ run timer events directly.
+ (Callers that will immediately read keyboard events
+ call timer_delay on their own.) */
+ if (! wait_for_cell)
+ {
+ EMACS_TIME timer_delay;
+ int old_timers_run;
+
+ retry:
+ old_timers_run = timers_run;
+ timer_delay = timer_check (1);
+ if (timers_run != old_timers_run && do_display)
+ {
+ redisplay_preserve_echo_area ();
+ /* We must retry, since a timer may have requeued itself
+ and that could alter the time delay. */
+ goto retry;
+ }
+
+ if (! EMACS_TIME_NEG_P (timer_delay) && time_limit != -1)
+ {
+ EMACS_TIME difference;
+ EMACS_SUB_TIME (difference, timer_delay, timeout);
+ if (EMACS_TIME_NEG_P (difference))
+ {
+ timeout = timer_delay;
+ timeout_reduced_for_timers = 1;
+ }
+ }
+ }
+
/* Cause C-g and alarm signals to take immediate action,
and cause input available signals to zero out timeout. */
if (XINT (read_kbd) < 0)
set_waiting_for_input (&timeout);
+ /* Wait till there is something to do. */
+
+ if (! XINT (read_kbd) && wait_for_cell == 0)
+ FD_ZERO (&waitchannels);
+ else
+ FD_SET (0, &waitchannels);
+
/* If a frame has been newly mapped and needs updating,
reprocess its display stuff. */
if (frame_garbaged && do_display)
- redisplay_preserve_echo_area ();
+ {
+ clear_waiting_for_input ();
+ redisplay_preserve_echo_area ();
+ if (XINT (read_kbd) < 0)
+ set_waiting_for_input (&timeout);
+ }
if (XINT (read_kbd) && detect_input_pending ())
- nfds = 0;
+ {
+ nfds = 0;
+ FD_ZERO (&waitchannels);
+ }
else
nfds = select (1, &waitchannels, (SELECT_TYPE *)0, (SELECT_TYPE *)0,
- timeout_p);
+ &timeout);
+
+ xerrno = errno;
/* Make C-g and alarm signals set flags again */
clear_waiting_for_input ();
/* If we woke up due to SIGWINCH, actually change size now. */
do_pending_window_change ();
+ if (time_limit && nfds == 0 && ! timeout_reduced_for_timers)
+ /* We waited the full specified time, so return now. */
+ break;
+
if (nfds == -1)
{
/* If the system call was interrupted, then go around the
loop again. */
- if (errno == EINTR)
- waitchannels = 0;
+ if (xerrno == EINTR)
+ FD_ZERO (&waitchannels);
+ else
+ error ("select error: %s", strerror (xerrno));
}
#ifdef sun
else if (nfds > 0 && (waitchannels & 1) && interrupt_input)
#endif
#ifdef SIGIO
if (XINT (read_kbd) && interrupt_input && (waitchannels & 1))
- kill (0, SIGIO);
+ kill (getpid (), SIGIO);
#endif
- /* If we have timed out (nfds == 0) or found some input (nfds > 0),
- we should exit. */
- if (nfds >= 0)
+ /* Check for keyboard input */
+
+ if ((XINT (read_kbd) != 0)
+ && detect_input_pending_run_timers (do_display))
+ {
+ swallow_events (do_display);
+ if (detect_input_pending_run_timers (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 ())
+ {
+ swallow_events (do_display);
+ if (detect_input_pending ())
+ break;
+ }
+
+ /* Exit now if the cell we're waiting for became non-nil. */
+ if (wait_for_cell && ! NILP (*wait_for_cell))
break;
}
If `buffer' is nil, kill all processes.
Since we have no subprocesses, this does nothing. */
+void
kill_buffer_processes (buffer)
Lisp_Object buffer;
{
HCoop / bpt / emacs.git / blobdiff