#include <config.h>
-#include <signal.h>
+
+#define PROCESS_INLINE EXTERN_INLINE
+
#include <stdio.h>
#include <errno.h>
#include <setjmp.h>
#include "gnutls.h"
#endif
+#ifdef HAVE_WINDOW_SYSTEM
+#include TERM_HEADER
+#endif /* HAVE_WINDOW_SYSTEM */
+
#if defined (USE_GTK) || defined (HAVE_GCONF) || defined (HAVE_GSETTINGS)
#include "xgselect.h"
#endif
-#ifdef HAVE_NS
-#include "nsterm.h"
+
+#ifndef WNOHANG
+# undef waitpid
+# define waitpid(pid, status, options) wait (status)
+#endif
+#ifndef WUNTRACED
+# define WUNTRACED 0
#endif
/* Work around GCC 4.7.0 bug with strict overflow checking; see
static Lisp_Object QCserver, QCnowait, QCnoquery, QCstop;
static Lisp_Object QCsentinel, QClog, QCoptions, QCplist;
static Lisp_Object Qlast_nonmenu_event;
-/* QCfamily is declared and initialized in xfaces.c,
- QCfilter in keyboard.c. */
-extern Lisp_Object QCfamily, QCfilter;
-
-/* Qexit is declared and initialized in eval.c. */
-
-/* QCfamily is defined in xfaces.c. */
-extern Lisp_Object QCfamily;
-/* QCfilter is defined in keyboard.c. */
-extern Lisp_Object QCfilter;
-#define NETCONN_P(p) (EQ (PVAR (XPROCESS (p), type), Qnetwork))
-#define NETCONN1_P(p) (EQ (PVAR (p, type), Qnetwork))
-#define SERIALCONN_P(p) (EQ (PVAR (XPROCESS (p), type), Qserial))
-#define SERIALCONN1_P(p) (EQ (PVAR (p, type), Qserial))
+#define NETCONN_P(p) (EQ (XPROCESS (p)->type, Qnetwork))
+#define NETCONN1_P(p) (EQ (p->type, Qnetwork))
+#define SERIALCONN_P(p) (EQ (XPROCESS (p)->type, Qserial))
+#define SERIALCONN1_P(p) (EQ (p->type, Qserial))
#ifndef HAVE_H_ERRNO
extern int h_errno;
/* Maximum number of bytes to send to a pty without an eof. */
static int pty_max_bytes;
+/* These setters are used only in this file, so they can be private. */
+static inline void
+pset_buffer (struct Lisp_Process *p, Lisp_Object val)
+{
+ p->buffer = val;
+}
+static inline void
+pset_command (struct Lisp_Process *p, Lisp_Object val)
+{
+ p->command = val;
+}
+static inline void
+pset_decode_coding_system (struct Lisp_Process *p, Lisp_Object val)
+{
+ p->decode_coding_system = val;
+}
+static inline void
+pset_decoding_buf (struct Lisp_Process *p, Lisp_Object val)
+{
+ p->decoding_buf = val;
+}
+static inline void
+pset_encode_coding_system (struct Lisp_Process *p, Lisp_Object val)
+{
+ p->encode_coding_system = val;
+}
+static inline void
+pset_encoding_buf (struct Lisp_Process *p, Lisp_Object val)
+{
+ p->encoding_buf = val;
+}
+static inline void
+pset_filter (struct Lisp_Process *p, Lisp_Object val)
+{
+ p->filter = val;
+}
+static inline void
+pset_log (struct Lisp_Process *p, Lisp_Object val)
+{
+ p->log = val;
+}
+static inline void
+pset_mark (struct Lisp_Process *p, Lisp_Object val)
+{
+ p->mark = val;
+}
+static inline void
+pset_name (struct Lisp_Process *p, Lisp_Object val)
+{
+ p->name = val;
+}
+static inline void
+pset_plist (struct Lisp_Process *p, Lisp_Object val)
+{
+ p->plist = val;
+}
+static inline void
+pset_sentinel (struct Lisp_Process *p, Lisp_Object val)
+{
+ p->sentinel = val;
+}
+static inline void
+pset_status (struct Lisp_Process *p, Lisp_Object val)
+{
+ p->status = val;
+}
+static inline void
+pset_tty_name (struct Lisp_Process *p, Lisp_Object val)
+{
+ p->tty_name = val;
+}
+static inline void
+pset_type (struct Lisp_Process *p, Lisp_Object val)
+{
+ p->type = val;
+}
+static inline void
+pset_write_queue (struct Lisp_Process *p, Lisp_Object val)
+{
+ p->write_queue = val;
+}
+
\f
static struct fd_callback_data
update_status (struct Lisp_Process *p)
{
eassert (p->raw_status_new);
- PVAR (p, status) = status_convert (p->raw_status);
+ pset_status (p, status_convert (p->raw_status));
p->raw_status_new = 0;
}
static Lisp_Object
status_message (struct Lisp_Process *p)
{
- Lisp_Object status = PVAR (p, status);
+ Lisp_Object status = p->status;
Lisp_Object symbol;
int code, coredump;
Lisp_Object string, string2;
p = allocate_process ();
/* Initialize Lisp data. Note that allocate_process initializes all
Lisp data to nil, so do it only for slots which should not be nil. */
- PVAR (p, status) = Qrun;
- PVAR (p, mark) = Fmake_marker ();
+ pset_status (p, Qrun);
+ pset_mark (p, Fmake_marker ());
/* Initialize non-Lisp data. Note that allocate_process zeroes out all
non-Lisp data, so do it only for slots which should not be zero. */
name1 = concat2 (name, make_formatted_string (suffix, "<%"pMd">", i));
}
name = name1;
- PVAR (p, name) = name;
+ pset_name (p, name);
XSETPROCESS (val, p);
Vprocess_alist = Fcons (Fcons (name, val), Vprocess_alist);
return val;
#ifdef SIGCHLD
/* Fdelete_process promises to immediately forget about the process, but in
reality, Emacs needs to remember those processes until they have been
- treated by sigchld_handler; otherwise this handler would consider the
+ treated by the SIGCHLD handler; otherwise this handler would consider the
process as being synchronous and say that the synchronous process is
dead. */
static Lisp_Object deleted_pid_list;
p->raw_status_new = 0;
if (NETCONN1_P (p) || SERIALCONN1_P (p))
{
- PVAR (p, status) = Fcons (Qexit, Fcons (make_number (0), Qnil));
+ pset_status (p, Fcons (Qexit, Fcons (make_number (0), Qnil)));
p->tick = ++process_tick;
status_notify (p);
redisplay_preserve_echo_area (13);
/* If the process has already signaled, remove it from the list. */
if (p->raw_status_new)
update_status (p);
- symbol = PVAR (p, status);
- if (CONSP (PVAR (p, status)))
- symbol = XCAR (PVAR (p, status));
+ symbol = p->status;
+ if (CONSP (p->status))
+ symbol = XCAR (p->status);
if (EQ (symbol, Qsignal) || EQ (symbol, Qexit))
deleted_pid_list
= Fdelete (make_fixnum_or_float (pid), deleted_pid_list);
#endif
{
Fkill_process (process, Qnil);
- /* Do this now, since remove_process will make sigchld_handler do nothing. */
- PVAR (p, status)
- = Fcons (Qsignal, Fcons (make_number (SIGKILL), Qnil));
+ /* Do this now, since remove_process will make the
+ SIGCHLD handler do nothing. */
+ pset_status (p, Fcons (Qsignal, Fcons (make_number (SIGKILL), Qnil)));
p->tick = ++process_tick;
status_notify (p);
redisplay_preserve_echo_area (13);
p = XPROCESS (process);
if (p->raw_status_new)
update_status (p);
- status = PVAR (p, status);
+ status = p->status;
if (CONSP (status))
status = XCAR (status);
if (NETCONN1_P (p) || SERIALCONN1_P (p))
{
if (EQ (status, Qexit))
status = Qclosed;
- else if (EQ (PVAR (p, command), Qt))
+ else if (EQ (p->command, Qt))
status = Qstop;
else if (EQ (status, Qrun))
status = Qopen;
CHECK_PROCESS (process);
if (XPROCESS (process)->raw_status_new)
update_status (XPROCESS (process));
- if (CONSP (PVAR (XPROCESS (process), status)))
- return XCAR (XCDR (PVAR (XPROCESS (process), status)));
+ if (CONSP (XPROCESS (process)->status))
+ return XCAR (XCDR (XPROCESS (process)->status));
return make_number (0);
}
(register Lisp_Object process)
{
CHECK_PROCESS (process);
- return PVAR (XPROCESS (process), name);
+ return XPROCESS (process)->name;
}
DEFUN ("process-command", Fprocess_command, Sprocess_command, 1, 1, 0,
(register Lisp_Object process)
{
CHECK_PROCESS (process);
- return PVAR (XPROCESS (process), command);
+ return XPROCESS (process)->command;
}
DEFUN ("process-tty-name", Fprocess_tty_name, Sprocess_tty_name, 1, 1, 0,
(register Lisp_Object process)
{
CHECK_PROCESS (process);
- return PVAR (XPROCESS (process), tty_name);
+ return XPROCESS (process)->tty_name;
}
DEFUN ("set-process-buffer", Fset_process_buffer, Sset_process_buffer,
if (!NILP (buffer))
CHECK_BUFFER (buffer);
p = XPROCESS (process);
- PVAR (p, buffer) = buffer;
+ pset_buffer (p, buffer);
if (NETCONN1_P (p) || SERIALCONN1_P (p))
- PVAR (p, childp) = Fplist_put (PVAR (p, childp), QCbuffer, buffer);
+ pset_childp (p, Fplist_put (p->childp, QCbuffer, buffer));
setup_process_coding_systems (process);
return buffer;
}
(register Lisp_Object process)
{
CHECK_PROCESS (process);
- return PVAR (XPROCESS (process), buffer);
+ return XPROCESS (process)->buffer;
}
DEFUN ("process-mark", Fprocess_mark, Sprocess_mark,
(register Lisp_Object process)
{
CHECK_PROCESS (process);
- return PVAR (XPROCESS (process), mark);
+ return XPROCESS (process)->mark;
}
DEFUN ("set-process-filter", Fset_process_filter, Sset_process_filter,
if (p->infd >= 0)
{
- if (EQ (filter, Qt) && !EQ (PVAR (p, status), Qlisten))
+ if (EQ (filter, Qt) && !EQ (p->status, Qlisten))
{
FD_CLR (p->infd, &input_wait_mask);
FD_CLR (p->infd, &non_keyboard_wait_mask);
}
- else if (EQ (PVAR (p, filter), Qt)
+ else if (EQ (p->filter, Qt)
/* Network or serial process not stopped: */
- && !EQ (PVAR (p, command), Qt))
+ && !EQ (p->command, Qt))
{
FD_SET (p->infd, &input_wait_mask);
FD_SET (p->infd, &non_keyboard_wait_mask);
}
}
- PVAR (p, filter) = filter;
+ pset_filter (p, filter);
if (NETCONN1_P (p) || SERIALCONN1_P (p))
- PVAR (p, childp) = Fplist_put (PVAR (p, childp), QCfilter, filter);
+ pset_childp (p, Fplist_put (p->childp, QCfilter, filter));
setup_process_coding_systems (process);
return filter;
}
(register Lisp_Object process)
{
CHECK_PROCESS (process);
- return PVAR (XPROCESS (process), filter);
+ return XPROCESS (process)->filter;
}
DEFUN ("set-process-sentinel", Fset_process_sentinel, Sset_process_sentinel,
CHECK_PROCESS (process);
p = XPROCESS (process);
- PVAR (p, sentinel) = sentinel;
+ pset_sentinel (p, sentinel);
if (NETCONN1_P (p) || SERIALCONN1_P (p))
- PVAR (p, childp) = Fplist_put (PVAR (p, childp), QCsentinel, sentinel);
+ pset_childp (p, Fplist_put (p->childp, QCsentinel, sentinel));
return sentinel;
}
(register Lisp_Object process)
{
CHECK_PROCESS (process);
- return PVAR (XPROCESS (process), sentinel);
+ return XPROCESS (process)->sentinel;
}
DEFUN ("set-process-window-size", Fset_process_window_size,
Lisp_Object contact;
CHECK_PROCESS (process);
- contact = PVAR (XPROCESS (process), childp);
+ contact = XPROCESS (process)->childp;
#ifdef DATAGRAM_SOCKETS
if (DATAGRAM_CONN_P (process)
(register Lisp_Object process)
{
CHECK_PROCESS (process);
- return PVAR (XPROCESS (process), plist);
+ return XPROCESS (process)->plist;
}
DEFUN ("set-process-plist", Fset_process_plist, Sset_process_plist,
CHECK_PROCESS (process);
CHECK_LIST (plist);
- PVAR (XPROCESS (process), plist) = plist;
+ pset_plist (XPROCESS (process), plist);
return plist;
}
a socket connection. */)
(Lisp_Object process)
{
- return PVAR (XPROCESS (process), type);
+ return XPROCESS (process)->type;
}
#endif
{
Lisp_Object proc;
proc = get_process (process);
- return PVAR (XPROCESS (proc), type);
+ return XPROCESS (proc)->type;
}
DEFUN ("format-network-address", Fformat_network_address, Sformat_network_address,
itself; it's all taken care of here. */
record_unwind_protect (start_process_unwind, proc);
- PVAR (XPROCESS (proc), childp) = Qt;
- PVAR (XPROCESS (proc), plist) = Qnil;
- PVAR (XPROCESS (proc), type) = Qreal;
- PVAR (XPROCESS (proc), buffer) = buffer;
- PVAR (XPROCESS (proc), sentinel) = Qnil;
- PVAR (XPROCESS (proc), filter) = Qnil;
- PVAR (XPROCESS (proc), command) = Flist (nargs - 2, args + 2);
+ pset_childp (XPROCESS (proc), Qt);
+ pset_plist (XPROCESS (proc), Qnil);
+ pset_type (XPROCESS (proc), Qreal);
+ pset_buffer (XPROCESS (proc), buffer);
+ pset_sentinel (XPROCESS (proc), Qnil);
+ pset_filter (XPROCESS (proc), Qnil);
+ pset_command (XPROCESS (proc), Flist (nargs - 2, args + 2));
#ifdef HAVE_GNUTLS
/* AKA GNUTLS_INITSTAGE(proc). */
XPROCESS (proc)->gnutls_initstage = GNUTLS_STAGE_EMPTY;
- XPROCESS (proc)->gnutls_cred_type = Qnil;
+ pset_gnutls_cred_type (XPROCESS (proc), Qnil);
#endif
#ifdef ADAPTIVE_READ_BUFFERING
/* Make the process marker point into the process buffer (if any). */
if (BUFFERP (buffer))
- set_marker_both (PVAR (XPROCESS (proc), mark), buffer,
+ set_marker_both (XPROCESS (proc)->mark, buffer,
BUF_ZV (XBUFFER (buffer)),
BUF_ZV_BYTE (XBUFFER (buffer)));
else if (CONSP (Vdefault_process_coding_system))
val = XCAR (Vdefault_process_coding_system);
}
- PVAR (XPROCESS (proc), decode_coding_system) = val;
+ pset_decode_coding_system (XPROCESS (proc), val);
val = Vcoding_system_for_write;
if (NILP (val))
else if (CONSP (Vdefault_process_coding_system))
val = XCDR (Vdefault_process_coding_system);
}
- PVAR (XPROCESS (proc), encode_coding_system) = val;
+ pset_encode_coding_system (XPROCESS (proc), val);
/* Note: At this moment, the above coding system may leave
text-conversion or eol-conversion unspecified. They will be
decided after we read output from the process and decode it by
}
- PVAR (XPROCESS (proc), decoding_buf) = empty_unibyte_string;
+ pset_decoding_buf (XPROCESS (proc), empty_unibyte_string);
XPROCESS (proc)->decoding_carryover = 0;
- PVAR (XPROCESS (proc), encoding_buf) = empty_unibyte_string;
+ pset_encoding_buf (XPROCESS (proc), empty_unibyte_string);
XPROCESS (proc)->inherit_coding_system_flag
= !(NILP (buffer) || !inherit_process_coding_system);
{
if (NILP (arg_encoding))
arg_encoding = (complement_process_encoding_system
- (PVAR (XPROCESS (proc), encode_coding_system)));
+ (XPROCESS (proc)->encode_coding_system));
XSETCAR (tem,
code_convert_string_norecord
(XCAR (tem), arg_encoding, 1));
start_process_unwind (Lisp_Object proc)
{
if (!PROCESSP (proc))
- abort ();
+ emacs_abort ();
/* Was PROC started successfully?
-2 is used for a pty with no process, eg for gdb. */
#if !defined (WINDOWSNT) && defined (FD_CLOEXEC)
int wait_child_setup[2];
#endif
- sigset_t procmask;
- sigset_t blocked;
+ sigset_t blocked, procmask;
struct sigaction sigint_action;
struct sigaction sigquit_action;
struct sigaction sigpipe_action;
/* Use volatile to protect variables from being clobbered by longjmp. */
volatile int forkin, forkout;
volatile int pty_flag = 0;
-#ifndef USE_CRT_DLL
- extern char **environ;
-#endif
inchannel = outchannel = -1;
more portable (see USG_SUBTTY_WORKS above). */
XPROCESS (process)->pty_flag = pty_flag;
- PVAR (XPROCESS (process), status) = Qrun;
+ pset_status (XPROCESS (process), Qrun);
/* Delay interrupts until we have a chance to store
the new fork's pid in its process structure */
if (inchannel > max_process_desc)
max_process_desc = inchannel;
- /* Until we store the proper pid, enable sigchld_handler
+ /* Until we store the proper pid, enable the SIGCHLD handler
to recognize an unknown pid as standing for this process.
It is very important not to let this `marker' value stay
in the table after this function has returned; if it does
int xforkin = forkin;
int xforkout = forkout;
-#if 0 /* This was probably a mistake--it duplicates code later on,
- but fails to handle all the cases. */
- /* Make sure SIGCHLD is not blocked in the child. */
- sigsetmask (SIGEMPTYMASK);
-#endif
-
/* Make the pty be the controlling terminal of the process. */
#ifdef HAVE_PTYS
/* First, disconnect its current controlling terminal. */
#ifdef HAVE_PTYS
if (pty_flag)
- PVAR (XPROCESS (process), tty_name) = build_string (pty_name);
+ pset_tty_name (XPROCESS (process), build_string (pty_name));
else
#endif
- PVAR (XPROCESS (process), tty_name) = Qnil;
+ pset_tty_name (XPROCESS (process), Qnil);
#if !defined (WINDOWSNT) && defined (FD_CLOEXEC)
/* Wait for child_setup to complete in case that vfork is
more portable (see USG_SUBTTY_WORKS above). */
XPROCESS (process)->pty_flag = pty_flag;
- PVAR (XPROCESS (process), status) = Qrun;
+ pset_status (XPROCESS (process), Qrun);
setup_process_coding_systems (process);
FD_SET (inchannel, &input_wait_mask);
XPROCESS (process)->pid = -2;
#ifdef HAVE_PTYS
if (pty_flag)
- PVAR (XPROCESS (process), tty_name) = build_string (pty_name);
+ pset_tty_name (XPROCESS (process), build_string (pty_name));
else
#endif
- PVAR (XPROCESS (process), tty_name) = Qnil;
+ pset_tty_name (XPROCESS (process), Qnil);
}
\f
if (set_socket_option (s, option, value))
{
- PVAR (p, childp) = Fplist_put (PVAR (p, childp), option, value);
+ pset_childp (p, Fplist_put (p->childp, option, value));
return Qt;
}
proc = Fplist_get (contact, QCport);
proc = get_process (proc);
p = XPROCESS (proc);
- if (!EQ (PVAR (p, type), Qserial))
+ if (!EQ (p->type, Qserial))
error ("Not a serial process");
- if (NILP (Fplist_get (PVAR (p, childp), QCspeed)))
+ if (NILP (Fplist_get (p->childp, QCspeed)))
{
UNGCPRO;
return Qnil;
make_serial_process_unwind (Lisp_Object proc)
{
if (!PROCESSP (proc))
- abort ();
+ emacs_abort ();
remove_process (proc);
return Qnil;
}
if (NILP (buffer))
buffer = name;
buffer = Fget_buffer_create (buffer);
- PVAR (p, buffer) = buffer;
-
- PVAR (p, childp) = contact;
- PVAR (p, plist) = Fcopy_sequence (Fplist_get (contact, QCplist));
- PVAR (p, type) = Qserial;
- PVAR (p, sentinel) = Fplist_get (contact, QCsentinel);
- PVAR (p, filter) = Fplist_get (contact, QCfilter);
- PVAR (p, log) = Qnil;
+ pset_buffer (p, buffer);
+
+ pset_childp (p, contact);
+ pset_plist (p, Fcopy_sequence (Fplist_get (contact, QCplist)));
+ pset_type (p, Qserial);
+ pset_sentinel (p, Fplist_get (contact, QCsentinel));
+ pset_filter (p, Fplist_get (contact, QCfilter));
+ pset_log (p, Qnil);
if (tem = Fplist_get (contact, QCnoquery), !NILP (tem))
p->kill_without_query = 1;
if (tem = Fplist_get (contact, QCstop), !NILP (tem))
- PVAR (p, command) = Qt;
+ pset_command (p, Qt);
p->pty_flag = 0;
- if (!EQ (PVAR (p, command), Qt))
+ if (!EQ (p->command, Qt))
{
FD_SET (fd, &input_wait_mask);
FD_SET (fd, &non_keyboard_wait_mask);
if (BUFFERP (buffer))
{
- set_marker_both (PVAR (p, mark), buffer,
+ set_marker_both (p->mark, buffer,
BUF_ZV (XBUFFER (buffer)),
BUF_ZV_BYTE (XBUFFER (buffer)));
}
else if ((!NILP (buffer) && NILP (BVAR (XBUFFER (buffer), enable_multibyte_characters)))
|| (NILP (buffer) && NILP (BVAR (&buffer_defaults, enable_multibyte_characters))))
val = Qnil;
- PVAR (p, decode_coding_system) = val;
+ pset_decode_coding_system (p, val);
val = Qnil;
if (!NILP (tem))
else if ((!NILP (buffer) && NILP (BVAR (XBUFFER (buffer), enable_multibyte_characters)))
|| (NILP (buffer) && NILP (BVAR (&buffer_defaults, enable_multibyte_characters))))
val = Qnil;
- PVAR (p, encode_coding_system) = val;
+ pset_encode_coding_system (p, val);
setup_process_coding_systems (proc);
- PVAR (p, decoding_buf) = empty_unibyte_string;
+ pset_decoding_buf (p, empty_unibyte_string);
p->decoding_carryover = 0;
- PVAR (p, encoding_buf) = empty_unibyte_string;
+ pset_encoding_buf (p, empty_unibyte_string);
p->inherit_coding_system_flag
= !(!NILP (tem) || NILP (buffer) || !inherit_process_coding_system);
if (socktype == SOCK_DGRAM)
{
if (datagram_address[s].sa)
- abort ();
+ emacs_abort ();
datagram_address[s].sa = xmalloc (lres->ai_addrlen);
datagram_address[s].len = lres->ai_addrlen;
if (is_server)
p = XPROCESS (proc);
- PVAR (p, childp) = contact;
- PVAR (p, plist) = Fcopy_sequence (Fplist_get (contact, QCplist));
- PVAR (p, type) = Qnetwork;
+ pset_childp (p, contact);
+ pset_plist (p, Fcopy_sequence (Fplist_get (contact, QCplist)));
+ pset_type (p, Qnetwork);
- PVAR (p, buffer) = buffer;
- PVAR (p, sentinel) = sentinel;
- PVAR (p, filter) = filter;
- PVAR (p, log) = Fplist_get (contact, QClog);
+ pset_buffer (p, buffer);
+ pset_sentinel (p, sentinel);
+ pset_filter (p, filter);
+ pset_log (p, Fplist_get (contact, QClog));
if (tem = Fplist_get (contact, QCnoquery), !NILP (tem))
p->kill_without_query = 1;
if ((tem = Fplist_get (contact, QCstop), !NILP (tem)))
- PVAR (p, command) = Qt;
+ pset_command (p, Qt);
p->pid = 0;
p->infd = inch;
p->outfd = outch;
if (is_server && socktype != SOCK_DGRAM)
- PVAR (p, status) = Qlisten;
+ pset_status (p, Qlisten);
/* Make the process marker point into the process buffer (if any). */
if (BUFFERP (buffer))
- set_marker_both (PVAR (p, mark), buffer,
+ set_marker_both (p->mark, buffer,
BUF_ZV (XBUFFER (buffer)),
BUF_ZV_BYTE (XBUFFER (buffer)));
/* We may get here if connect did succeed immediately. However,
in that case, we still need to signal this like a non-blocking
connection. */
- PVAR (p, status) = Qconnect;
+ pset_status (p, Qconnect);
if (!FD_ISSET (inch, &connect_wait_mask))
{
FD_SET (inch, &connect_wait_mask);
#endif
/* A server may have a client filter setting of Qt, but it must
still listen for incoming connects unless it is stopped. */
- if ((!EQ (PVAR (p, filter), Qt) && !EQ (PVAR (p, command), Qt))
- || (EQ (PVAR (p, status), Qlisten) && NILP (PVAR (p, command))))
+ if ((!EQ (p->filter, Qt) && !EQ (p->command, Qt))
+ || (EQ (p->status, Qlisten) && NILP (p->command)))
{
FD_SET (inch, &input_wait_mask);
FD_SET (inch, &non_keyboard_wait_mask);
else
val = Qnil;
}
- PVAR (p, decode_coding_system) = val;
+ pset_decode_coding_system (p, val);
if (!NILP (tem))
{
else
val = Qnil;
}
- PVAR (p, encode_coding_system) = val;
+ pset_encode_coding_system (p, val);
}
setup_process_coding_systems (proc);
- PVAR (p, decoding_buf) = empty_unibyte_string;
+ pset_decoding_buf (p, empty_unibyte_string);
p->decoding_carryover = 0;
- PVAR (p, encoding_buf) = empty_unibyte_string;
+ pset_encoding_buf (p, empty_unibyte_string);
p->inherit_coding_system_flag
= !(!NILP (tem) || NILP (buffer) || !inherit_process_coding_system);
FD_CLR (inchannel, &connect_wait_mask);
FD_CLR (inchannel, &write_mask);
if (--num_pending_connects < 0)
- abort ();
+ emacs_abort ();
}
#endif
if (inchannel == max_process_desc)
return;
#endif
- if (!NILP (PVAR (ps, log)))
- call3 (PVAR (ps, log), server, Qnil,
+ if (!NILP (ps->log))
+ call3 (ps->log, server, Qnil,
concat3 (build_string ("accept failed with code"),
Fnumber_to_string (make_number (code)),
build_string ("\n")));
process name of the server process concatenated with the caller
identification. */
- if (!NILP (PVAR (ps, filter)) && !EQ (PVAR (ps, filter), Qt))
+ if (!NILP (ps->filter) && !EQ (ps->filter, Qt))
buffer = Qnil;
else
{
- buffer = PVAR (ps, buffer);
+ buffer = ps->buffer;
if (!NILP (buffer))
buffer = Fbuffer_name (buffer);
else
- buffer = PVAR (ps, name);
+ buffer = ps->name;
if (!NILP (buffer))
{
buffer = concat2 (buffer, caller);
/* Generate a unique name for the new server process. Combine the
server process name with the caller identification. */
- name = concat2 (PVAR (ps, name), caller);
+ name = concat2 (ps->name, caller);
proc = make_process (name);
chan_process[s] = proc;
p = XPROCESS (proc);
/* Build new contact information for this setup. */
- contact = Fcopy_sequence (PVAR (ps, childp));
+ contact = Fcopy_sequence (ps->childp);
contact = Fplist_put (contact, QCserver, Qnil);
contact = Fplist_put (contact, QChost, host);
if (!NILP (service))
conv_sockaddr_to_lisp (&saddr.sa, len));
#endif
- PVAR (p, childp) = contact;
- PVAR (p, plist) = Fcopy_sequence (PVAR (ps, plist));
- PVAR (p, type) = Qnetwork;
+ pset_childp (p, contact);
+ pset_plist (p, Fcopy_sequence (ps->plist));
+ pset_type (p, Qnetwork);
- PVAR (p, buffer) = buffer;
- PVAR (p, sentinel) = PVAR (ps, sentinel);
- PVAR (p, filter) = PVAR (ps, filter);
- PVAR (p, command) = Qnil;
+ pset_buffer (p, buffer);
+ pset_sentinel (p, ps->sentinel);
+ pset_filter (p, ps->filter);
+ pset_command (p, Qnil);
p->pid = 0;
p->infd = s;
p->outfd = s;
- PVAR (p, status) = Qrun;
+ pset_status (p, Qrun);
/* Client processes for accepted connections are not stopped initially. */
- if (!EQ (PVAR (p, filter), Qt))
+ if (!EQ (p->filter, Qt))
{
FD_SET (s, &input_wait_mask);
FD_SET (s, &non_keyboard_wait_mask);
of the new process should reflect the settings at the time the
server socket was opened; not the current settings. */
- PVAR (p, decode_coding_system) = PVAR (ps, decode_coding_system);
- PVAR (p, encode_coding_system) = PVAR (ps, encode_coding_system);
+ pset_decode_coding_system (p, ps->decode_coding_system);
+ pset_encode_coding_system (p, ps->encode_coding_system);
setup_process_coding_systems (proc);
- PVAR (p, decoding_buf) = empty_unibyte_string;
+ pset_decoding_buf (p, empty_unibyte_string);
p->decoding_carryover = 0;
- PVAR (p, encoding_buf) = empty_unibyte_string;
+ pset_encoding_buf (p, empty_unibyte_string);
p->inherit_coding_system_flag
= (NILP (buffer) ? 0 : ps->inherit_coding_system_flag);
- if (!NILP (PVAR (ps, log)))
- call3 (PVAR (ps, log), server, proc,
+ if (!NILP (ps->log))
+ call3 (ps->log, server, proc,
concat3 (build_string ("accept from "),
(STRINGP (host) ? host : build_string ("-")),
build_string ("\n")));
- if (!NILP (PVAR (p, sentinel)))
+ if (!NILP (p->sentinel))
exec_sentinel (proc,
concat3 (build_string ("open from "),
(STRINGP (host) ? host : build_string ("-")),
FD_ZERO (&Writeok);
if (time_limit == 0 && nsecs == 0 && wait_proc && !NILP (Vinhibit_quit)
- && !(CONSP (PVAR (wait_proc, status))
- && EQ (XCAR (PVAR (wait_proc, status)), Qexit)))
+ && !(CONSP (wait_proc->status)
+ && EQ (XCAR (wait_proc->status), Qexit)))
message ("Blocking call to accept-process-output with quit inhibited!!");
/* If wait_proc is a process to watch, set wait_channel accordingly. */
if (wait_proc && wait_proc->raw_status_new)
update_status (wait_proc);
if (wait_proc
- && ! EQ (PVAR (wait_proc, status), Qrun)
- && ! EQ (PVAR (wait_proc, status), Qconnect))
+ && ! EQ (wait_proc->status, Qrun)
+ && ! EQ (wait_proc->status, Qconnect))
{
int nread, total_nread = 0;
Cleanup occurs c/o status_notify after SIGCLD. */
no_avail = 1; /* Cannot depend on values returned */
#else
- abort ();
+ emacs_abort ();
#endif
}
else
for (channel = 0; channel <= max_input_desc; ++channel)
{
struct fd_callback_data *d = &fd_callback_info[channel];
- if (FD_ISSET (channel, &Available)
- && d->func != 0
- && (d->condition & FOR_READ) != 0)
- d->func (channel, d->data, 1);
- if (FD_ISSET (channel, &write_mask)
- && d->func != 0
- && (d->condition & FOR_WRITE) != 0)
- d->func (channel, d->data, 0);
- }
+ if (d->func
+ && ((d->condition & FOR_READ
+ && FD_ISSET (channel, &Available))
+ || (d->condition & FOR_WRITE
+ && FD_ISSET (channel, &write_mask))))
+ d->func (channel, d->data);
+ }
for (channel = 0; channel <= max_process_desc; channel++)
{
continue;
/* If this is a server stream socket, accept connection. */
- if (EQ (PVAR (XPROCESS (proc), status), Qlisten))
+ if (EQ (XPROCESS (proc)->status, Qlisten))
{
server_accept_connection (proc, channel);
continue;
if (p->pid == -2)
{
- /* If the EIO occurs on a pty, sigchld_handler's
- waitpid() will not find the process object to
+ /* If the EIO occurs on a pty, the SIGCHLD handler's
+ waitpid call will not find the process object to
delete. Do it here. */
p->tick = ++process_tick;
- PVAR (p, status) = Qfailed;
+ pset_status (p, Qfailed);
}
else
kill (getpid (), SIGCHLD);
deactivate_process (proc);
if (XPROCESS (proc)->raw_status_new)
update_status (XPROCESS (proc));
- if (EQ (PVAR (XPROCESS (proc), status), Qrun))
- PVAR (XPROCESS (proc), status)
- = Fcons (Qexit, Fcons (make_number (256), Qnil));
+ if (EQ (XPROCESS (proc)->status, Qrun))
+ pset_status (XPROCESS (proc),
+ list2 (Qexit, make_number (256)));
}
}
#ifdef NON_BLOCKING_CONNECT
FD_CLR (channel, &connect_wait_mask);
FD_CLR (channel, &write_mask);
if (--num_pending_connects < 0)
- abort ();
+ emacs_abort ();
proc = chan_process[channel];
if (NILP (proc))
if (xerrno)
{
p->tick = ++process_tick;
- PVAR (p, status)
- = Fcons (Qfailed, Fcons (make_number (xerrno), Qnil));
+ pset_status (p, list2 (Qfailed, make_number (xerrno)));
deactivate_process (proc);
}
else
{
- PVAR (p, status) = Qrun;
+ pset_status (p, Qrun);
/* Execute the sentinel here. If we had relied on
status_notify to do it later, it will read input
from the process before calling the sentinel. */
exec_sentinel (proc, build_string ("open\n"));
- if (!EQ (PVAR (p, filter), Qt) && !EQ (PVAR (p, command), Qt))
+ if (!EQ (p->filter, Qt) && !EQ (p->command, Qt))
{
FD_SET (p->infd, &input_wait_mask);
FD_SET (p->infd, &non_keyboard_wait_mask);
chars = alloca (carryover + readmax);
if (carryover)
/* See the comment above. */
- memcpy (chars, SDATA (PVAR (p, decoding_buf)), carryover);
+ memcpy (chars, SDATA (p->decoding_buf), carryover);
#ifdef DATAGRAM_SOCKETS
/* We have a working select, so proc_buffered_char is always -1. */
/* There's no good reason to let process filters change the current
buffer, and many callers of accept-process-output, sit-for, and
friends don't expect current-buffer to be changed from under them. */
- record_unwind_protect (set_buffer_if_live, Fcurrent_buffer ());
+ record_unwind_current_buffer ();
/* Read and dispose of the process output. */
- outstream = PVAR (p, filter);
+ outstream = p->filter;
if (!NILP (outstream))
{
Lisp_Object text;
- int outer_running_asynch_code = running_asynch_code;
+ bool outer_running_asynch_code = running_asynch_code;
int waiting = waiting_for_user_input_p;
/* No need to gcpro these, because all we do with them later
text = coding->dst_object;
Vlast_coding_system_used = CODING_ID_NAME (coding->id);
/* A new coding system might be found. */
- if (!EQ (PVAR (p, decode_coding_system), Vlast_coding_system_used))
+ if (!EQ (p->decode_coding_system, Vlast_coding_system_used))
{
- PVAR (p, decode_coding_system) = Vlast_coding_system_used;
+ pset_decode_coding_system (p, Vlast_coding_system_used);
/* Don't call setup_coding_system for
proc_decode_coding_system[channel] here. It is done in
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 (PVAR (p, encode_coding_system))
+ if (NILP (p->encode_coding_system)
&& proc_encode_coding_system[p->outfd])
{
- PVAR (p, encode_coding_system)
- = coding_inherit_eol_type (Vlast_coding_system_used, Qnil);
- setup_coding_system (PVAR (p, encode_coding_system),
+ pset_encode_coding_system
+ (p, coding_inherit_eol_type (Vlast_coding_system_used, Qnil));
+ setup_coding_system (p->encode_coding_system,
proc_encode_coding_system[p->outfd]);
}
}
if (coding->carryover_bytes > 0)
{
- if (SCHARS (PVAR (p, decoding_buf)) < coding->carryover_bytes)
- PVAR (p, decoding_buf) = make_uninit_string (coding->carryover_bytes);
- memcpy (SDATA (PVAR (p, decoding_buf)), coding->carryover,
+ if (SCHARS (p->decoding_buf) < coding->carryover_bytes)
+ pset_decoding_buf (p, make_uninit_string (coding->carryover_bytes));
+ memcpy (SDATA (p->decoding_buf), coding->carryover,
coding->carryover_bytes);
p->decoding_carryover = coding->carryover_bytes;
}
}
/* If no filter, write into buffer if it isn't dead. */
- else if (!NILP (PVAR (p, buffer)) && !NILP (BVAR (XBUFFER (PVAR (p, buffer)), name)))
+ else if (!NILP (p->buffer) && !NILP (BVAR (XBUFFER (p->buffer), name)))
{
Lisp_Object old_read_only;
ptrdiff_t old_begv, old_zv;
Lisp_Object text;
struct buffer *b;
- Fset_buffer (PVAR (p, buffer));
+ Fset_buffer (p->buffer);
opoint = PT;
opoint_byte = PT_BYTE;
old_read_only = BVAR (current_buffer, read_only);
old_begv_byte = BEGV_BYTE;
old_zv_byte = ZV_BYTE;
- BVAR (current_buffer, read_only) = Qnil;
+ bset_read_only (current_buffer, Qnil);
/* Insert new output into buffer
at the current end-of-output marker,
thus preserving logical ordering of input and output. */
- if (XMARKER (PVAR (p, mark))->buffer)
+ if (XMARKER (p->mark)->buffer)
SET_PT_BOTH (clip_to_bounds (BEGV,
- marker_position (PVAR (p, mark)), ZV),
+ marker_position (p->mark), ZV),
clip_to_bounds (BEGV_BYTE,
- marker_byte_position (PVAR (p, mark)),
+ marker_byte_position (p->mark),
ZV_BYTE));
else
SET_PT_BOTH (ZV, ZV_BYTE);
Vlast_coding_system_used = CODING_ID_NAME (coding->id);
/* A new coding system might be found. See the comment in the
similar code in the previous `if' block. */
- if (!EQ (PVAR (p, decode_coding_system), Vlast_coding_system_used))
+ if (!EQ (p->decode_coding_system, Vlast_coding_system_used))
{
- PVAR (p, decode_coding_system) = Vlast_coding_system_used;
- if (NILP (PVAR (p, encode_coding_system))
+ pset_decode_coding_system (p, Vlast_coding_system_used);
+ if (NILP (p->encode_coding_system)
&& proc_encode_coding_system[p->outfd])
{
- PVAR (p, encode_coding_system)
- = coding_inherit_eol_type (Vlast_coding_system_used, Qnil);
- setup_coding_system (PVAR (p, encode_coding_system),
+ pset_encode_coding_system
+ (p, coding_inherit_eol_type (Vlast_coding_system_used, Qnil));
+ setup_coding_system (p->encode_coding_system,
proc_encode_coding_system[p->outfd]);
}
}
if (coding->carryover_bytes > 0)
{
- if (SCHARS (PVAR (p, decoding_buf)) < coding->carryover_bytes)
- PVAR (p, decoding_buf) = make_uninit_string (coding->carryover_bytes);
- memcpy (SDATA (PVAR (p, decoding_buf)), coding->carryover,
+ if (SCHARS (p->decoding_buf) < coding->carryover_bytes)
+ pset_decoding_buf (p, make_uninit_string (coding->carryover_bytes));
+ memcpy (SDATA (p->decoding_buf), coding->carryover,
coding->carryover_bytes);
p->decoding_carryover = coding->carryover_bytes;
}
/* Make sure the process marker's position is valid when the
process buffer is changed in the signal_after_change above.
W3 is known to do that. */
- if (BUFFERP (PVAR (p, buffer))
- && (b = XBUFFER (PVAR (p, buffer)), b != current_buffer))
- set_marker_both (PVAR (p, mark), PVAR (p, buffer), BUF_PT (b), BUF_PT_BYTE (b));
+ if (BUFFERP (p->buffer)
+ && (b = XBUFFER (p->buffer), b != current_buffer))
+ set_marker_both (p->mark, p->buffer, BUF_PT (b), BUF_PT_BYTE (b));
else
- set_marker_both (PVAR (p, mark), PVAR (p, buffer), PT, PT_BYTE);
+ set_marker_both (p->mark, p->buffer, PT, PT_BYTE);
update_mode_lines++;
Fnarrow_to_region (make_number (old_begv), make_number (old_zv));
- BVAR (current_buffer, read_only) = old_read_only;
+ bset_read_only (current_buffer, old_read_only);
SET_PT_BOTH (opoint, opoint_byte);
}
/* Handling the process output should not deactivate the mark. */
static jmp_buf send_process_frame;
static Lisp_Object process_sent_to;
-#ifndef FORWARD_SIGNAL_TO_MAIN_THREAD
-static _Noreturn void send_process_trap (int);
-#endif
+static _Noreturn void
+handle_pipe_signal (int sig)
+{
+ sigset_t unblocked;
+ sigemptyset (&unblocked);
+ sigaddset (&unblocked, SIGPIPE);
+ pthread_sigmask (SIG_UNBLOCK, &unblocked, 0);
+ _longjmp (send_process_frame, 1);
+}
static void
-send_process_trap (int ignore)
+deliver_pipe_signal (int sig)
{
- SIGNAL_THREAD_CHECK (SIGPIPE);
- sigunblock (sigmask (SIGPIPE));
- longjmp (send_process_frame, 1);
+ handle_on_main_thread (sig, handle_pipe_signal);
}
/* In send_process, when a write fails temporarily,
entry = Fcons (obj, Fcons (make_number (offset), make_number (len)));
if (front)
- PVAR (p, write_queue) = Fcons (entry, PVAR (p, write_queue));
+ pset_write_queue (p, Fcons (entry, p->write_queue));
else
- PVAR (p, write_queue) = nconc2 (PVAR (p, write_queue), Fcons (entry, Qnil));
+ pset_write_queue (p, nconc2 (p->write_queue, Fcons (entry, Qnil)));
}
/* Remove the first element in the write_queue of process P, put its
Lisp_Object entry, offset_length;
ptrdiff_t offset;
- if (NILP (PVAR (p, write_queue)))
+ if (NILP (p->write_queue))
return 0;
- entry = XCAR (PVAR (p, write_queue));
- PVAR (p, write_queue) = XCDR (PVAR (p, write_queue));
+ entry = XCAR (p->write_queue);
+ pset_write_queue (p, XCDR (p->write_queue));
*obj = XCAR (entry);
offset_length = XCDR (entry);
struct Lisp_Process *p = XPROCESS (proc);
ssize_t rv;
struct coding_system *coding;
- void (*volatile old_sigpipe) (int);
+ struct sigaction old_sigpipe_action;
if (p->raw_status_new)
update_status (p);
- if (! EQ (PVAR (p, status), Qrun))
- error ("Process %s not running", SDATA (PVAR (p, name)));
+ if (! EQ (p->status, Qrun))
+ error ("Process %s not running", SDATA (p->name));
if (p->outfd < 0)
- error ("Output file descriptor of %s is closed", SDATA (PVAR (p, name)));
+ error ("Output file descriptor of %s is closed", SDATA (p->name));
coding = proc_encode_coding_system[p->outfd];
Vlast_coding_system_used = CODING_ID_NAME (coding->id);
&& !NILP (BVAR (XBUFFER (object), enable_multibyte_characters)))
|| EQ (object, Qt))
{
- PVAR (p, encode_coding_system)
- = complement_process_encoding_system (PVAR (p, encode_coding_system));
- if (!EQ (Vlast_coding_system_used, PVAR (p, encode_coding_system)))
+ pset_encode_coding_system
+ (p, complement_process_encoding_system (p->encode_coding_system));
+ if (!EQ (Vlast_coding_system_used, p->encode_coding_system))
{
/* The coding system for encoding was changed to raw-text
because we sent a unibyte text previously. Now we are
Another reason we come here is that the coding system
was just complemented and a new one was returned by
complement_process_encoding_system. */
- setup_coding_system (PVAR (p, encode_coding_system), coding);
- Vlast_coding_system_used = PVAR (p, encode_coding_system);
+ setup_coding_system (p->encode_coding_system, coding);
+ Vlast_coding_system_used = p->encode_coding_system;
}
coding->src_multibyte = 1;
}
/* 2000-09-21: Emacs 20.7, sparc-sun-solaris-2.6, GCC 2.95.2,
CFLAGS="-g -O": The value of the parameter `proc' is clobbered
when returning with longjmp despite being declared volatile. */
- if (!setjmp (send_process_frame))
+ if (!_setjmp (send_process_frame))
{
p = XPROCESS (proc); /* Repair any setjmp clobbering. */
process_sent_to = proc;
/* If there is already data in the write_queue, put the new data
in the back of queue. Otherwise, ignore it. */
- if (!NILP (PVAR (p, write_queue)))
+ if (!NILP (p->write_queue))
write_queue_push (p, object, buf, len, 0);
do /* while !NILP (p->write_queue) */
/* Send this batch, using one or more write calls. */
ptrdiff_t written = 0;
int outfd = p->outfd;
- old_sigpipe = (void (*) (int)) signal (SIGPIPE, send_process_trap);
+ struct sigaction action;
+ emacs_sigaction_init (&action, deliver_pipe_signal);
+ sigaction (SIGPIPE, &action, &old_sigpipe_action);
#ifdef DATAGRAM_SOCKETS
if (DATAGRAM_CHAN_P (outfd))
{
written = rv;
else if (errno == EMSGSIZE)
{
- signal (SIGPIPE, old_sigpipe);
+ sigaction (SIGPIPE, &old_sigpipe_action, 0);
report_file_error ("sending datagram",
Fcons (proc, Qnil));
}
}
#endif
}
- signal (SIGPIPE, old_sigpipe);
+ sigaction (SIGPIPE, &old_sigpipe_action, 0);
if (rv < 0)
{
cur_len -= written;
}
}
- while (!NILP (PVAR (p, write_queue)));
+ while (!NILP (p->write_queue));
}
else
{
- signal (SIGPIPE, old_sigpipe);
+ sigaction (SIGPIPE, &old_sigpipe_action, 0);
proc = process_sent_to;
p = XPROCESS (proc);
p->raw_status_new = 0;
- PVAR (p, status) = Fcons (Qexit, Fcons (make_number (256), Qnil));
+ pset_status (p, Fcons (Qexit, Fcons (make_number (256), Qnil)));
p->tick = ++process_tick;
deactivate_process (proc);
- error ("SIGPIPE raised on process %s; closed it", SDATA (PVAR (p, name)));
+ error ("SIGPIPE raised on process %s; closed it", SDATA (p->name));
}
}
pid_t gid = -1;
#ifdef TIOCGPGRP
- if (ioctl (p->infd, TIOCGPGRP, &gid) == -1 && ! NILP (PVAR (p, tty_name)))
+ if (ioctl (p->infd, TIOCGPGRP, &gid) == -1 && ! NILP (p->tty_name))
{
int fd;
/* Some OS:es (Solaris 8/9) does not allow TIOCGPGRP from the
master side. Try the slave side. */
- fd = emacs_open (SSDATA (PVAR (p, tty_name)), O_RDONLY, 0);
+ fd = emacs_open (SSDATA (p->tty_name), O_RDONLY, 0);
if (fd != -1)
{
proc = get_process (process);
p = XPROCESS (proc);
- if (!EQ (PVAR (p, type), Qreal))
+ if (!EQ (p->type, Qreal))
error ("Process %s is not a subprocess",
- SDATA (PVAR (p, name)));
+ SDATA (p->name));
if (p->infd < 0)
error ("Process %s is not active",
- SDATA (PVAR (p, name)));
+ SDATA (p->name));
gid = emacs_get_tty_pgrp (p);
proc = get_process (process);
p = XPROCESS (proc);
- if (!EQ (PVAR (p, type), Qreal))
+ if (!EQ (p->type, Qreal))
error ("Process %s is not a subprocess",
- SDATA (PVAR (p, name)));
+ SDATA (p->name));
if (p->infd < 0)
error ("Process %s is not active",
- SDATA (PVAR (p, name)));
+ SDATA (p->name));
if (!p->pty_flag)
current_group = Qnil;
#ifdef SIGCONT
case SIGCONT:
p->raw_status_new = 0;
- PVAR (p, status) = Qrun;
+ pset_status (p, Qrun);
p->tick = ++process_tick;
if (!nomsg)
{
struct Lisp_Process *p;
p = XPROCESS (process);
- if (NILP (PVAR (p, command))
+ if (NILP (p->command)
&& p->infd >= 0)
{
FD_CLR (p->infd, &input_wait_mask);
FD_CLR (p->infd, &non_keyboard_wait_mask);
}
- PVAR (p, command) = Qt;
+ pset_command (p, Qt);
return process;
}
#ifndef SIGTSTP
struct Lisp_Process *p;
p = XPROCESS (process);
- if (EQ (PVAR (p, command), Qt)
+ if (EQ (p->command, Qt)
&& p->infd >= 0
- && (!EQ (PVAR (p, filter), Qt) || EQ (PVAR (p, status), Qlisten)))
+ && (!EQ (p->filter, Qt) || EQ (p->status, Qlisten)))
{
FD_SET (p->infd, &input_wait_mask);
FD_SET (p->infd, &non_keyboard_wait_mask);
tcflush (p->infd, TCIFLUSH);
#endif /* not WINDOWSNT */
}
- PVAR (p, command) = Qnil;
+ pset_command (p, Qnil);
return process;
}
#ifdef SIGCONT
CHECK_PROCESS (process);
pid = XPROCESS (process)->pid;
if (pid <= 0)
- error ("Cannot signal process %s",
- SDATA (PVAR (XPROCESS (process), name)));
+ error ("Cannot signal process %s", SDATA (XPROCESS (process)->name));
}
#define parse_signal(NAME, VALUE) \
/* Make sure the process is really alive. */
if (XPROCESS (proc)->raw_status_new)
update_status (XPROCESS (proc));
- if (! EQ (PVAR (XPROCESS (proc), status), Qrun))
- error ("Process %s not running", SDATA (PVAR (XPROCESS (proc), name)));
+ if (! EQ (XPROCESS (proc)->status, Qrun))
+ error ("Process %s not running", SDATA (XPROCESS (proc)->name));
if (CODING_REQUIRE_FLUSHING (coding))
{
if (XPROCESS (proc)->pty_flag)
send_process (proc, "\004", 1, Qnil);
- else if (EQ (PVAR (XPROCESS (proc), type), Qserial))
+ else if (EQ (XPROCESS (proc)->type, Qserial))
{
#ifndef WINDOWSNT
if (tcdrain (XPROCESS (proc)->outfd) != 0)
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 (EQ (PVAR (XPROCESS (proc), type), Qnetwork)
+ if (EQ (XPROCESS (proc)->type, Qnetwork)
|| XPROCESS (proc)->outfd == XPROCESS (proc)->infd)
shutdown (XPROCESS (proc)->outfd, 1);
/* In case of socketpair, outfd == infd, so don't close it. */
#endif /* not HAVE_SHUTDOWN */
new_outfd = emacs_open (NULL_DEVICE, O_WRONLY, 0);
if (new_outfd < 0)
- abort ();
+ emacs_abort ();
old_outfd = XPROCESS (proc)->outfd;
if (!proc_encode_coding_system[new_outfd])
indirectly; if it does, that is a bug */
#ifdef SIGCHLD
-static void
-sigchld_handler (int signo)
+
+/* Record one child's changed status. Return true if a child was found. */
+static bool
+record_child_status_change (void)
{
- int old_errno = errno;
Lisp_Object proc;
struct Lisp_Process *p;
+ pid_t pid;
+ int w;
+ Lisp_Object tail;
- SIGNAL_THREAD_CHECK (signo);
-
- while (1)
- {
- pid_t pid;
- int w;
- Lisp_Object tail;
-
-#ifdef WNOHANG
-#ifndef WUNTRACED
-#define WUNTRACED 0
-#endif /* no WUNTRACED */
- /* Keep trying to get a status until we get a definitive result. */
- do
- {
- errno = 0;
- pid = waitpid (-1, &w, WNOHANG | WUNTRACED);
- }
- while (pid < 0 && errno == EINTR);
-
- if (pid <= 0)
- {
- /* PID == 0 means no processes found, PID == -1 means a real
- failure. We have done all our job, so return. */
+ do
+ pid = waitpid (-1, &w, WNOHANG | WUNTRACED);
+ while (pid < 0 && errno == EINTR);
- errno = old_errno;
- return;
- }
-#else
- pid = wait (&w);
-#endif /* no WNOHANG */
+ /* PID == 0 means no processes found, PID == -1 means a real failure.
+ Either way, we have done all our job. */
+ if (pid <= 0)
+ return false;
- /* Find the process that signaled us, and record its status. */
+ /* Find the process that signaled us, and record its status. */
- /* The process can have been deleted by Fdelete_process. */
- for (tail = deleted_pid_list; CONSP (tail); tail = XCDR (tail))
+ /* The process can have been deleted by Fdelete_process. */
+ for (tail = deleted_pid_list; CONSP (tail); tail = XCDR (tail))
+ {
+ Lisp_Object xpid = XCAR (tail);
+ if ((INTEGERP (xpid) && pid == XINT (xpid))
+ || (FLOATP (xpid) && pid == XFLOAT_DATA (xpid)))
{
- Lisp_Object xpid = XCAR (tail);
- if ((INTEGERP (xpid) && pid == XINT (xpid))
- || (FLOATP (xpid) && pid == XFLOAT_DATA (xpid)))
- {
- XSETCAR (tail, Qnil);
- goto sigchld_end_of_loop;
- }
+ XSETCAR (tail, Qnil);
+ return true;
}
+ }
- /* Otherwise, if it is asynchronous, it is in Vprocess_alist. */
+ /* Otherwise, if it is asynchronous, it is in Vprocess_alist. */
+ p = 0;
+ for (tail = Vprocess_alist; CONSP (tail); tail = XCDR (tail))
+ {
+ proc = XCDR (XCAR (tail));
+ p = XPROCESS (proc);
+ if (EQ (p->type, Qreal) && p->pid == pid)
+ break;
p = 0;
- for (tail = Vprocess_alist; CONSP (tail); tail = XCDR (tail))
- {
- proc = XCDR (XCAR (tail));
- p = XPROCESS (proc);
- if (EQ (PVAR (p, type), Qreal) && p->pid == pid)
- break;
- p = 0;
- }
-
- /* Look for an asynchronous process whose pid hasn't been filled
- in yet. */
- if (p == 0)
- for (tail = Vprocess_alist; CONSP (tail); tail = XCDR (tail))
- {
- proc = XCDR (XCAR (tail));
- p = XPROCESS (proc);
- if (p->pid == -1)
- break;
- p = 0;
- }
-
- /* Change the status of the process that was found. */
- if (p != 0)
- {
- int clear_desc_flag = 0;
+ }
- p->tick = ++process_tick;
- p->raw_status = w;
- p->raw_status_new = 1;
+ /* Look for an asynchronous process whose pid hasn't been filled
+ in yet. */
+ if (! p)
+ for (tail = Vprocess_alist; CONSP (tail); tail = XCDR (tail))
+ {
+ proc = XCDR (XCAR (tail));
+ p = XPROCESS (proc);
+ if (p->pid == -1)
+ break;
+ p = 0;
+ }
- /* If process has terminated, stop waiting for its output. */
- if ((WIFSIGNALED (w) || WIFEXITED (w))
- && p->infd >= 0)
- clear_desc_flag = 1;
+ /* Change the status of the process that was found. */
+ if (p)
+ {
+ int clear_desc_flag = 0;
- /* We use clear_desc_flag to avoid a compiler bug in Microsoft C. */
- if (clear_desc_flag)
- {
- FD_CLR (p->infd, &input_wait_mask);
- FD_CLR (p->infd, &non_keyboard_wait_mask);
- }
+ p->tick = ++process_tick;
+ p->raw_status = w;
+ p->raw_status_new = 1;
- /* Tell wait_reading_process_output that it needs to wake up and
- look around. */
- if (input_available_clear_time)
- *input_available_clear_time = make_emacs_time (0, 0);
- }
+ /* If process has terminated, stop waiting for its output. */
+ if ((WIFSIGNALED (w) || WIFEXITED (w))
+ && p->infd >= 0)
+ clear_desc_flag = 1;
- /* There was no asynchronous process found for that pid: we have
- a synchronous process. */
- else
+ /* We use clear_desc_flag to avoid a compiler bug in Microsoft C. */
+ if (clear_desc_flag)
{
- synch_process_alive = 0;
-
- /* Report the status of the synchronous process. */
- if (WIFEXITED (w))
- synch_process_retcode = WEXITSTATUS (w);
- else if (WIFSIGNALED (w))
- synch_process_termsig = WTERMSIG (w);
-
- /* Tell wait_reading_process_output that it needs to wake up and
- look around. */
- if (input_available_clear_time)
- *input_available_clear_time = make_emacs_time (0, 0);
+ FD_CLR (p->infd, &input_wait_mask);
+ FD_CLR (p->infd, &non_keyboard_wait_mask);
}
- sigchld_end_of_loop:
- ;
+ /* Tell wait_reading_process_output that it needs to wake up and
+ look around. */
+ if (input_available_clear_time)
+ *input_available_clear_time = make_emacs_time (0, 0);
+ }
+ /* There was no asynchronous process found for that pid: we have
+ a synchronous process. */
+ else
+ {
+ synch_process_alive = 0;
+
+ /* Report the status of the synchronous process. */
+ if (WIFEXITED (w))
+ synch_process_retcode = WEXITSTATUS (w);
+ else if (WIFSIGNALED (w))
+ synch_process_termsig = WTERMSIG (w);
+
+ /* Tell wait_reading_process_output that it needs to wake up and
+ look around. */
+ if (input_available_clear_time)
+ *input_available_clear_time = make_emacs_time (0, 0);
+ }
- /* On some systems, we must return right away.
- If any more processes want to signal us, we will
- get another signal.
- Otherwise (on systems that have WNOHANG), loop around
- to use up all the processes that have something to tell us. */
+ return true;
+}
+
+/* On some systems, the SIGCHLD handler must return right away. If
+ any more processes want to signal us, we will get another signal.
+ Otherwise, loop around to use up all the processes that have
+ something to tell us. */
#if (defined WINDOWSNT \
|| (defined USG && !defined GNU_LINUX \
&& !(defined HPUX && defined WNOHANG)))
- errno = old_errno;
- return;
-#endif /* USG, but not HPUX with WNOHANG */
- }
+enum { CAN_HANDLE_MULTIPLE_CHILDREN = 0 };
+#else
+enum { CAN_HANDLE_MULTIPLE_CHILDREN = 1 };
+#endif
+
+static void
+handle_child_signal (int sig)
+{
+ while (record_child_status_change () && CAN_HANDLE_MULTIPLE_CHILDREN)
+ continue;
+}
+
+static void
+deliver_child_signal (int sig)
+{
+ handle_on_main_thread (sig, handle_child_signal);
}
+
#endif /* SIGCHLD */
\f
static Lisp_Object
exec_sentinel_unwind (Lisp_Object data)
{
- PVAR (XPROCESS (XCAR (data)), sentinel) = XCDR (data);
+ pset_sentinel (XPROCESS (XCAR (data)), XCDR (data));
return Qnil;
}
exec_sentinel (Lisp_Object proc, Lisp_Object reason)
{
Lisp_Object sentinel, odeactivate;
- register struct Lisp_Process *p = XPROCESS (proc);
+ struct Lisp_Process *p = XPROCESS (proc);
ptrdiff_t count = SPECPDL_INDEX ();
- int outer_running_asynch_code = running_asynch_code;
+ bool outer_running_asynch_code = running_asynch_code;
int waiting = waiting_for_user_input_p;
if (inhibit_sentinels)
/* There's no good reason to let sentinels change the current
buffer, and many callers of accept-process-output, sit-for, and
friends don't expect current-buffer to be changed from under them. */
- record_unwind_protect (set_buffer_if_live, Fcurrent_buffer ());
+ record_unwind_current_buffer ();
- sentinel = PVAR (p, sentinel);
+ sentinel = p->sentinel;
if (NILP (sentinel))
return;
/* Zilch the sentinel while it's running, to avoid recursive invocations;
assure that it gets restored no matter how the sentinel exits. */
- PVAR (p, sentinel) = Qnil;
+ pset_sentinel (p, Qnil);
record_unwind_protect (exec_sentinel_unwind, Fcons (proc, sentinel));
/* Inhibit quit so that random quits don't screw up a running filter. */
specbind (Qinhibit_quit, Qt);
p->update_tick = p->tick;
/* If process is still active, read any output that remains. */
- while (! EQ (PVAR (p, filter), Qt)
- && ! EQ (PVAR (p, status), Qconnect)
- && ! EQ (PVAR (p, status), Qlisten)
+ while (! EQ (p->filter, Qt)
+ && ! EQ (p->status, Qconnect)
+ && ! EQ (p->status, Qlisten)
/* Network or serial process not stopped: */
- && ! EQ (PVAR (p, command), Qt)
+ && ! EQ (p->command, Qt)
&& p->infd >= 0
&& p != deleting_process
&& read_process_output (proc, p->infd) > 0);
- buffer = PVAR (p, buffer);
+ buffer = p->buffer;
/* Get the text to use for the message. */
if (p->raw_status_new)
msg = status_message (p);
/* If process is terminated, deactivate it or delete it. */
- symbol = PVAR (p, status);
- if (CONSP (PVAR (p, status)))
- symbol = XCAR (PVAR (p, status));
+ symbol = p->status;
+ if (CONSP (p->status))
+ symbol = XCAR (p->status);
if (EQ (symbol, Qsignal) || EQ (symbol, Qexit)
|| EQ (symbol, Qclosed))
this code to be run again. */
p->update_tick = p->tick;
/* Now output the message suitably. */
- if (!NILP (PVAR (p, sentinel)))
+ if (!NILP (p->sentinel))
exec_sentinel (proc, msg);
/* Don't bother with a message in the buffer
when a process becomes runnable. */
/* Insert new output into buffer
at the current end-of-output marker,
thus preserving logical ordering of input and output. */
- if (XMARKER (PVAR (p, mark))->buffer)
- Fgoto_char (PVAR (p, mark));
+ if (XMARKER (p->mark)->buffer)
+ Fgoto_char (p->mark);
else
SET_PT_BOTH (ZV, ZV_BYTE);
before_byte = PT_BYTE;
tem = BVAR (current_buffer, read_only);
- BVAR (current_buffer, read_only) = Qnil;
+ bset_read_only (current_buffer, Qnil);
insert_string ("\nProcess ");
- Finsert (1, &PVAR (p, name));
+ { /* FIXME: temporary kludge */
+ Lisp_Object tem2 = p->name; Finsert (1, &tem2); }
insert_string (" ");
Finsert (1, &msg);
- BVAR (current_buffer, read_only) = tem;
- set_marker_both (PVAR (p, mark), PVAR (p, buffer), PT, PT_BYTE);
+ bset_read_only (current_buffer, tem);
+ set_marker_both (p->mark, p->buffer, PT, PT_BYTE);
if (opoint >= before)
SET_PT_BOTH (opoint + (PT - before),
CHECK_PROCESS (process);
p = XPROCESS (process);
if (p->infd < 0)
- error ("Input file descriptor of %s closed", SDATA (PVAR (p, name)));
+ error ("Input file descriptor of %s closed", SDATA (p->name));
if (p->outfd < 0)
- error ("Output file descriptor of %s closed", SDATA (PVAR (p, name)));
+ error ("Output file descriptor of %s closed", SDATA (p->name));
Fcheck_coding_system (decoding);
Fcheck_coding_system (encoding);
encoding = coding_inherit_eol_type (encoding, Qnil);
- PVAR (p, decode_coding_system) = decoding;
- PVAR (p, encode_coding_system) = encoding;
+ pset_decode_coding_system (p, decoding);
+ pset_encode_coding_system (p, encoding);
setup_process_coding_systems (process);
return Qnil;
(register Lisp_Object process)
{
CHECK_PROCESS (process);
- return Fcons (PVAR (XPROCESS (process), decode_coding_system),
- PVAR (XPROCESS (process), encode_coding_system));
+ return Fcons (XPROCESS (process)->decode_coding_system,
+ XPROCESS (process)->encode_coding_system);
}
DEFUN ("set-process-filter-multibyte", Fset_process_filter_multibyte,
CHECK_PROCESS (process);
p = XPROCESS (process);
if (NILP (flag))
- PVAR (p, decode_coding_system)
- = raw_text_coding_system (PVAR (p, decode_coding_system));
+ pset_decode_coding_system
+ (p, raw_text_coding_system (p->decode_coding_system));
setup_process_coding_systems (process);
return Qnil;
if (!proc_decode_coding_system[inch])
proc_decode_coding_system[inch] = xmalloc (sizeof (struct coding_system));
- coding_system = PVAR (p, decode_coding_system);
- if (! NILP (PVAR (p, filter)))
+ coding_system = p->decode_coding_system;
+ if (! NILP (p->filter))
;
- else if (BUFFERP (PVAR (p, buffer)))
+ else if (BUFFERP (p->buffer))
{
- if (NILP (BVAR (XBUFFER (PVAR (p, buffer)), enable_multibyte_characters)))
+ if (NILP (BVAR (XBUFFER (p->buffer), enable_multibyte_characters)))
coding_system = raw_text_coding_system (coding_system);
}
setup_coding_system (coding_system, proc_decode_coding_system[inch]);
if (!proc_encode_coding_system[outch])
proc_encode_coding_system[outch] = xmalloc (sizeof (struct coding_system));
- setup_coding_system (PVAR (p, encode_coding_system),
+ setup_coding_system (p->encode_coding_system,
proc_encode_coding_system[outch]);
#endif
}
for (tail = Vprocess_alist; CONSP (tail); tail = XCDR (tail))
{
proc = Fcdr (XCAR (tail));
- if (PROCESSP (proc) && EQ (PVAR (XPROCESS (proc), buffer), buf))
+ if (PROCESSP (proc) && EQ (XPROCESS (proc)->buffer, buf))
return proc;
}
#endif /* subprocesses */
{
proc = XCDR (XCAR (tail));
if (PROCESSP (proc)
- && (NILP (buffer) || EQ (PVAR (XPROCESS (proc), buffer), buffer)))
+ && (NILP (buffer) || EQ (XPROCESS (proc)->buffer, buffer)))
{
if (NETCONN_P (proc) || SERIALCONN_P (proc))
Fdelete_process (proc);
#ifndef CANNOT_DUMP
if (! noninteractive || initialized)
#endif
- signal (SIGCHLD, sigchld_handler);
+ {
+ struct sigaction action;
+ emacs_sigaction_init (&action, deliver_child_signal);
+ sigaction (SIGCHLD, &action, 0);
+ }
#endif
FD_ZERO (&input_wait_mask);
HCoop / bpt / emacs.git / blobdiff