#include "systty.h"
#include "window.h"
-#include "buffer.h"
#include "character.h"
+#include "buffer.h"
#include "coding.h"
#include "process.h"
#include "frame.h"
/* QCfilter is defined in keyboard.c. */
extern Lisp_Object QCfilter;
-#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))
+#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))
#ifndef HAVE_H_ERRNO
extern int h_errno;
#endif
#if !defined (ADAPTIVE_READ_BUFFERING) && !defined (NO_ADAPTIVE_READ_BUFFERING)
-#ifdef EMACS_HAS_USECS
#define ADAPTIVE_READ_BUFFERING
#endif
-#endif
#ifdef ADAPTIVE_READ_BUFFERING
-#define READ_OUTPUT_DELAY_INCREMENT 10000
+#define READ_OUTPUT_DELAY_INCREMENT (EMACS_TIME_RESOLUTION / 100)
#define READ_OUTPUT_DELAY_MAX (READ_OUTPUT_DELAY_INCREMENT * 5)
#define READ_OUTPUT_DELAY_MAX_MAX (READ_OUTPUT_DELAY_INCREMENT * 7)
#define process_output_delay_count 0
#endif
-static Lisp_Object Fget_process (Lisp_Object);
static void create_process (Lisp_Object, char **, Lisp_Object);
#ifdef SIGIO
static int keyboard_bit_set (SELECT_TYPE *);
void
add_read_fd (int fd, fd_callback func, void *data)
{
- xassert (fd < MAXDESC);
+ eassert (fd < MAXDESC);
add_keyboard_wait_descriptor (fd);
fd_callback_info[fd].func = func;
void
delete_read_fd (int fd)
{
- xassert (fd < MAXDESC);
+ eassert (fd < MAXDESC);
delete_keyboard_wait_descriptor (fd);
fd_callback_info[fd].condition &= ~FOR_READ;
void
add_write_fd (int fd, fd_callback func, void *data)
{
- xassert (fd < MAXDESC);
+ eassert (fd < MAXDESC);
FD_SET (fd, &write_mask);
if (fd > max_input_desc)
max_input_desc = fd;
{
int lim = max_input_desc;
- xassert (fd < MAXDESC);
+ eassert (fd < MAXDESC);
FD_CLR (fd, &write_mask);
fd_callback_info[fd].condition &= ~FOR_WRITE;
if (fd_callback_info[fd].condition == 0)
update_status (struct Lisp_Process *p)
{
eassert (p->raw_status_new);
- p->status = status_convert (p->raw_status);
+ PVAR (p, status) = status_convert (p->raw_status);
p->raw_status_new = 0;
}
static Lisp_Object
status_message (struct Lisp_Process *p)
{
- Lisp_Object status = p->status;
+ Lisp_Object status = PVAR (p, status);
Lisp_Object symbol;
int code, coredump;
Lisp_Object string, string2;
{
int c1, c2;
- string = make_unibyte_string (signame, strlen (signame));
+ string = build_unibyte_string (signame);
if (! NILP (Vlocale_coding_system))
string = (code_convert_string_norecord
(string, Vlocale_coding_system, 0));
printmax_t i;
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 ();
+ /* 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. */
p->infd = -1;
p->outfd = -1;
- p->tick = 0;
- p->update_tick = 0;
- p->pid = 0;
- p->pty_flag = 0;
- p->raw_status_new = 0;
- p->status = Qrun;
- p->mark = Fmake_marker ();
- p->kill_without_query = 0;
-
-#ifdef ADAPTIVE_READ_BUFFERING
- p->adaptive_read_buffering = 0;
- p->read_output_delay = 0;
- p->read_output_skip = 0;
-#endif
#ifdef HAVE_GNUTLS
p->gnutls_initstage = GNUTLS_STAGE_EMPTY;
- /* Default log level. */
- p->gnutls_log_level = 0;
- /* GnuTLS handshakes attempted for this connection. */
- p->gnutls_handshakes_tried = 0;
- p->gnutls_p = 0;
- p->gnutls_state = NULL;
- p->gnutls_x509_cred = NULL;
- p->gnutls_anon_cred = NULL;
#endif
/* If name is already in use, modify it until it is unused. */
{
tem = Fget_process (name1);
if (NILP (tem)) break;
- sprintf (suffix, "<%"pMd">", i);
- name1 = concat2 (name, build_string (suffix));
+ name1 = concat2 (name, make_formatted_string (suffix, "<%"pMd">", i));
}
name = name1;
- p->name = name;
+ PVAR (p, name) = name;
XSETPROCESS (val, p);
Vprocess_alist = Fcons (Fcons (name, val), Vprocess_alist);
return val;
p->raw_status_new = 0;
if (NETCONN1_P (p) || SERIALCONN1_P (p))
{
- p->status = Fcons (Qexit, Fcons (make_number (0), Qnil));
+ PVAR (p, status) = 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 = p->status;
- if (CONSP (p->status))
- symbol = XCAR (p->status);
+ symbol = PVAR (p, status);
+ if (CONSP (PVAR (p, status)))
+ symbol = XCAR (PVAR (p, status));
if (EQ (symbol, Qsignal) || EQ (symbol, Qexit))
deleted_pid_list
= Fdelete (make_fixnum_or_float (pid), deleted_pid_list);
{
Fkill_process (process, Qnil);
/* Do this now, since remove_process will make sigchld_handler do nothing. */
- p->status
+ PVAR (p, status)
= Fcons (Qsignal, Fcons (make_number (SIGKILL), Qnil));
p->tick = ++process_tick;
status_notify (p);
p = XPROCESS (process);
if (p->raw_status_new)
update_status (p);
- status = p->status;
+ status = PVAR (p, status);
if (CONSP (status))
status = XCAR (status);
if (NETCONN1_P (p) || SERIALCONN1_P (p))
{
if (EQ (status, Qexit))
status = Qclosed;
- else if (EQ (p->command, Qt))
+ else if (EQ (PVAR (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 (XPROCESS (process)->status))
- return XCAR (XCDR (XPROCESS (process)->status));
+ if (CONSP (PVAR (XPROCESS (process), status)))
+ return XCAR (XCDR (PVAR (XPROCESS (process), status)));
return make_number (0);
}
(register Lisp_Object process)
{
CHECK_PROCESS (process);
- return XPROCESS (process)->name;
+ return PVAR (XPROCESS (process), name);
}
DEFUN ("process-command", Fprocess_command, Sprocess_command, 1, 1, 0,
(register Lisp_Object process)
{
CHECK_PROCESS (process);
- return XPROCESS (process)->command;
+ return PVAR (XPROCESS (process), command);
}
DEFUN ("process-tty-name", Fprocess_tty_name, Sprocess_tty_name, 1, 1, 0,
(register Lisp_Object process)
{
CHECK_PROCESS (process);
- return XPROCESS (process)->tty_name;
+ return PVAR (XPROCESS (process), tty_name);
}
DEFUN ("set-process-buffer", Fset_process_buffer, Sset_process_buffer,
if (!NILP (buffer))
CHECK_BUFFER (buffer);
p = XPROCESS (process);
- p->buffer = buffer;
+ PVAR (p, buffer) = buffer;
if (NETCONN1_P (p) || SERIALCONN1_P (p))
- p->childp = Fplist_put (p->childp, QCbuffer, buffer);
+ PVAR (p, childp) = Fplist_put (PVAR (p, childp), QCbuffer, buffer);
setup_process_coding_systems (process);
return buffer;
}
(register Lisp_Object process)
{
CHECK_PROCESS (process);
- return XPROCESS (process)->buffer;
+ return PVAR (XPROCESS (process), buffer);
}
DEFUN ("process-mark", Fprocess_mark, Sprocess_mark,
(register Lisp_Object process)
{
CHECK_PROCESS (process);
- return XPROCESS (process)->mark;
+ return PVAR (XPROCESS (process), mark);
}
DEFUN ("set-process-filter", Fset_process_filter, Sset_process_filter,
if (p->infd >= 0)
{
- if (EQ (filter, Qt) && !EQ (p->status, Qlisten))
+ if (EQ (filter, Qt) && !EQ (PVAR (p, status), Qlisten))
{
FD_CLR (p->infd, &input_wait_mask);
FD_CLR (p->infd, &non_keyboard_wait_mask);
}
- else if (EQ (p->filter, Qt)
+ else if (EQ (PVAR (p, filter), Qt)
/* Network or serial process not stopped: */
- && !EQ (p->command, Qt))
+ && !EQ (PVAR (p, command), Qt))
{
FD_SET (p->infd, &input_wait_mask);
FD_SET (p->infd, &non_keyboard_wait_mask);
}
}
- p->filter = filter;
+ PVAR (p, filter) = filter;
if (NETCONN1_P (p) || SERIALCONN1_P (p))
- p->childp = Fplist_put (p->childp, QCfilter, filter);
+ PVAR (p, childp) = Fplist_put (PVAR (p, childp), QCfilter, filter);
setup_process_coding_systems (process);
return filter;
}
(register Lisp_Object process)
{
CHECK_PROCESS (process);
- return XPROCESS (process)->filter;
+ return PVAR (XPROCESS (process), filter);
}
DEFUN ("set-process-sentinel", Fset_process_sentinel, Sset_process_sentinel,
CHECK_PROCESS (process);
p = XPROCESS (process);
- p->sentinel = sentinel;
+ PVAR (p, sentinel) = sentinel;
if (NETCONN1_P (p) || SERIALCONN1_P (p))
- p->childp = Fplist_put (p->childp, QCsentinel, sentinel);
+ PVAR (p, childp) = Fplist_put (PVAR (p, childp), QCsentinel, sentinel);
return sentinel;
}
(register Lisp_Object process)
{
CHECK_PROCESS (process);
- return XPROCESS (process)->sentinel;
+ return PVAR (XPROCESS (process), sentinel);
}
DEFUN ("set-process-window-size", Fset_process_window_size,
(register Lisp_Object process, Lisp_Object height, Lisp_Object width)
{
CHECK_PROCESS (process);
- CHECK_RANGED_INTEGER (0, height, INT_MAX);
- CHECK_RANGED_INTEGER (0, width, INT_MAX);
+ CHECK_RANGED_INTEGER (height, 0, INT_MAX);
+ CHECK_RANGED_INTEGER (width, 0, INT_MAX);
if (XPROCESS (process)->infd < 0
|| set_window_size (XPROCESS (process)->infd,
return (XPROCESS (process)->kill_without_query ? Qnil : Qt);
}
-#ifdef DATAGRAM_SOCKETS
-static Lisp_Object Fprocess_datagram_address (Lisp_Object);
-#endif
-
DEFUN ("process-contact", Fprocess_contact, Sprocess_contact,
1, 2, 0,
doc: /* Return the contact info of PROCESS; t for a real child.
Lisp_Object contact;
CHECK_PROCESS (process);
- contact = XPROCESS (process)->childp;
+ contact = PVAR (XPROCESS (process), childp);
#ifdef DATAGRAM_SOCKETS
if (DATAGRAM_CONN_P (process)
(register Lisp_Object process)
{
CHECK_PROCESS (process);
- return XPROCESS (process)->plist;
+ return PVAR (XPROCESS (process), plist);
}
DEFUN ("set-process-plist", Fset_process_plist, Sset_process_plist,
CHECK_PROCESS (process);
CHECK_LIST (plist);
- XPROCESS (process)->plist = plist;
+ PVAR (XPROCESS (process), plist) = plist;
return plist;
}
a socket connection. */)
(Lisp_Object process)
{
- return XPROCESS (process)->type;
+ return PVAR (XPROCESS (process), type);
}
#endif
{
Lisp_Object proc;
proc = get_process (process);
- return XPROCESS (proc)->type;
+ return PVAR (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);
- XPROCESS (proc)->childp = Qt;
- XPROCESS (proc)->plist = Qnil;
- XPROCESS (proc)->type = Qreal;
- XPROCESS (proc)->buffer = buffer;
- XPROCESS (proc)->sentinel = Qnil;
- XPROCESS (proc)->filter = Qnil;
- XPROCESS (proc)->command = Flist (nargs - 2, args + 2);
+ 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);
#ifdef HAVE_GNUTLS
/* AKA GNUTLS_INITSTAGE(proc). */
/* Make the process marker point into the process buffer (if any). */
if (BUFFERP (buffer))
- set_marker_both (XPROCESS (proc)->mark, buffer,
+ set_marker_both (PVAR (XPROCESS (proc), mark), buffer,
BUF_ZV (XBUFFER (buffer)),
BUF_ZV_BYTE (XBUFFER (buffer)));
val = Vcoding_system_for_read;
if (NILP (val))
{
- args2 = (Lisp_Object *) alloca ((nargs + 1) * sizeof *args2);
+ args2 = alloca ((nargs + 1) * sizeof *args2);
args2[0] = Qstart_process;
for (i = 0; i < nargs; i++) args2[i + 1] = args[i];
GCPRO2 (proc, current_dir);
else if (CONSP (Vdefault_process_coding_system))
val = XCAR (Vdefault_process_coding_system);
}
- XPROCESS (proc)->decode_coding_system = val;
+ PVAR (XPROCESS (proc), decode_coding_system) = val;
val = Vcoding_system_for_write;
if (NILP (val))
{
if (EQ (coding_systems, Qt))
{
- args2 = (Lisp_Object *) alloca ((nargs + 1) * sizeof *args2);
+ args2 = alloca ((nargs + 1) * sizeof *args2);
args2[0] = Qstart_process;
for (i = 0; i < nargs; i++) args2[i + 1] = args[i];
GCPRO2 (proc, current_dir);
else if (CONSP (Vdefault_process_coding_system))
val = XCDR (Vdefault_process_coding_system);
}
- XPROCESS (proc)->encode_coding_system = val;
+ PVAR (XPROCESS (proc), encode_coding_system) = 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
}
- XPROCESS (proc)->decoding_buf = empty_unibyte_string;
+ PVAR (XPROCESS (proc), decoding_buf) = empty_unibyte_string;
XPROCESS (proc)->decoding_carryover = 0;
- XPROCESS (proc)->encoding_buf = empty_unibyte_string;
+ PVAR (XPROCESS (proc), encoding_buf) = 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
- (XPROCESS (proc)->encode_coding_system));
+ (PVAR (XPROCESS (proc), encode_coding_system)));
XSETCAR (tem,
code_convert_string_norecord
(XCAR (tem), arg_encoding, 1));
/* Now that everything is encoded we can collect the strings into
NEW_ARGV. */
- new_argv = (unsigned char **) alloca ((nargs - 1) * sizeof (char *));
+ new_argv = alloca ((nargs - 1) * sizeof *new_argv);
new_argv[nargs - 2] = 0;
for (i = nargs - 2; i-- != 0; )
more portable (see USG_SUBTTY_WORKS above). */
XPROCESS (process)->pty_flag = pty_flag;
- XPROCESS (process)->status = Qrun;
+ PVAR (XPROCESS (process), status) = Qrun;
/* Delay interrupts until we have a chance to store
the new fork's pid in its process structure */
So have an interrupt jar it loose. */
{
struct atimer *timer;
- EMACS_TIME offset;
+ EMACS_TIME offset = make_emacs_time (1, 0);
stop_polling ();
- EMACS_SET_SECS_USECS (offset, 1, 0);
timer = start_atimer (ATIMER_RELATIVE, offset, create_process_1, 0);
if (forkin >= 0)
#ifdef HAVE_PTYS
if (pty_flag)
- XPROCESS (process)->tty_name = build_string (pty_name);
+ PVAR (XPROCESS (process), tty_name) = build_string (pty_name);
else
#endif
- XPROCESS (process)->tty_name = Qnil;
+ PVAR (XPROCESS (process), tty_name) = 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;
- XPROCESS (process)->status = Qrun;
+ PVAR (XPROCESS (process), status) = Qrun;
setup_process_coding_systems (process);
FD_SET (inchannel, &input_wait_mask);
XPROCESS (process)->pid = -2;
#ifdef HAVE_PTYS
if (pty_flag)
- XPROCESS (process)->tty_name = build_string (pty_name);
+ PVAR (XPROCESS (process), tty_name) = build_string (pty_name);
else
#endif
- XPROCESS (process)->tty_name = Qnil;
+ PVAR (XPROCESS (process), tty_name) = Qnil;
}
\f
if (set_socket_option (s, option, value))
{
- p->childp = Fplist_put (p->childp, option, value);
+ PVAR (p, childp) = Fplist_put (PVAR (p, childp), option, value);
return Qt;
}
proc = Fplist_get (contact, QCport);
proc = get_process (proc);
p = XPROCESS (proc);
- if (!EQ (p->type, Qserial))
+ if (!EQ (PVAR (p, type), Qserial))
error ("Not a serial process");
- if (NILP (Fplist_get (p->childp, QCspeed)))
+ if (NILP (Fplist_get (PVAR (p, childp), QCspeed)))
{
UNGCPRO;
return Qnil;
if (NILP (buffer))
buffer = name;
buffer = Fget_buffer_create (buffer);
- p->buffer = buffer;
-
- p->childp = contact;
- p->plist = Fcopy_sequence (Fplist_get (contact, QCplist));
- p->type = Qserial;
- p->sentinel = Fplist_get (contact, QCsentinel);
- p->filter = Fplist_get (contact, QCfilter);
- p->log = Qnil;
+ 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;
if (tem = Fplist_get (contact, QCnoquery), !NILP (tem))
p->kill_without_query = 1;
if (tem = Fplist_get (contact, QCstop), !NILP (tem))
- p->command = Qt;
+ PVAR (p, command) = Qt;
p->pty_flag = 0;
- if (!EQ (p->command, Qt))
+ if (!EQ (PVAR (p, command), Qt))
{
FD_SET (fd, &input_wait_mask);
FD_SET (fd, &non_keyboard_wait_mask);
if (BUFFERP (buffer))
{
- set_marker_both (p->mark, buffer,
+ set_marker_both (PVAR (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;
- p->decode_coding_system = val;
+ PVAR (p, decode_coding_system) = 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;
- p->encode_coding_system = val;
+ PVAR (p, encode_coding_system) = val;
setup_process_coding_systems (proc);
- p->decoding_buf = empty_unibyte_string;
+ PVAR (p, decoding_buf) = empty_unibyte_string;
p->decoding_carryover = 0;
- p->encoding_buf = empty_unibyte_string;
+ PVAR (p, encoding_buf) = empty_unibyte_string;
p->inherit_coding_system_flag
= !(!NILP (tem) || NILP (buffer) || !inherit_process_coding_system);
CHECK_STRING (service);
memset (&address_un, 0, sizeof address_un);
address_un.sun_family = AF_LOCAL;
- strncpy (address_un.sun_path, SSDATA (service), sizeof address_un.sun_path);
+ if (sizeof address_un.sun_path <= SBYTES (service))
+ error ("Service name too long");
+ strcpy (address_un.sun_path, SSDATA (service));
ai.ai_addr = (struct sockaddr *) &address_un;
ai.ai_addrlen = sizeof address_un;
goto open_socket;
{
/* Unlike most other syscalls connect() cannot be called
again. (That would return EALREADY.) The proper way to
- wait for completion is select(). */
+ wait for completion is pselect(). */
int sc;
socklen_t len;
SELECT_TYPE fdset;
FD_ZERO (&fdset);
FD_SET (s, &fdset);
QUIT;
- sc = select (s + 1, (SELECT_TYPE *)0, &fdset, (SELECT_TYPE *)0,
- (EMACS_TIME *)0);
+ sc = pselect (s + 1, NULL, &fdset, NULL, NULL, NULL);
if (sc == -1)
{
if (errno == EINTR)
{
if (datagram_address[s].sa)
abort ();
- datagram_address[s].sa = (struct sockaddr *) xmalloc (lres->ai_addrlen);
+ datagram_address[s].sa = xmalloc (lres->ai_addrlen);
datagram_address[s].len = lres->ai_addrlen;
if (is_server)
{
p = XPROCESS (proc);
- p->childp = contact;
- p->plist = Fcopy_sequence (Fplist_get (contact, QCplist));
- p->type = Qnetwork;
+ PVAR (p, childp) = contact;
+ PVAR (p, plist) = Fcopy_sequence (Fplist_get (contact, QCplist));
+ PVAR (p, type) = Qnetwork;
- p->buffer = buffer;
- p->sentinel = sentinel;
- p->filter = filter;
- p->log = Fplist_get (contact, QClog);
+ PVAR (p, buffer) = buffer;
+ PVAR (p, sentinel) = sentinel;
+ PVAR (p, filter) = filter;
+ PVAR (p, log) = 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)))
- p->command = Qt;
+ PVAR (p, command) = Qt;
p->pid = 0;
p->infd = inch;
p->outfd = outch;
if (is_server && socktype != SOCK_DGRAM)
- p->status = Qlisten;
+ PVAR (p, status) = Qlisten;
/* Make the process marker point into the process buffer (if any). */
if (BUFFERP (buffer))
- set_marker_both (p->mark, buffer,
+ set_marker_both (PVAR (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. */
- p->status = Qconnect;
+ PVAR (p, status) = 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 (p->filter, Qt) && !EQ (p->command, Qt))
- || (EQ (p->status, Qlisten) && NILP (p->command)))
+ if ((!EQ (PVAR (p, filter), Qt) && !EQ (PVAR (p, command), Qt))
+ || (EQ (PVAR (p, status), Qlisten) && NILP (PVAR (p, command))))
{
FD_SET (inch, &input_wait_mask);
FD_SET (inch, &non_keyboard_wait_mask);
else
val = Qnil;
}
- p->decode_coding_system = val;
+ PVAR (p, decode_coding_system) = val;
if (!NILP (tem))
{
else
val = Qnil;
}
- p->encode_coding_system = val;
+ PVAR (p, encode_coding_system) = val;
}
setup_process_coding_systems (proc);
- p->decoding_buf = empty_unibyte_string;
+ PVAR (p, decoding_buf) = empty_unibyte_string;
p->decoding_carryover = 0;
- p->encoding_buf = empty_unibyte_string;
+ PVAR (p, encoding_buf) = empty_unibyte_string;
p->inherit_coding_system_flag
= !(!NILP (tem) || NILP (buffer) || !inherit_process_coding_system);
CHECK_STRING (ifname);
- memset (rq.ifr_name, 0, sizeof rq.ifr_name);
- strncpy (rq.ifr_name, SSDATA (ifname), sizeof (rq.ifr_name));
+ if (sizeof rq.ifr_name <= SBYTES (ifname))
+ error ("interface name too long");
+ strcpy (rq.ifr_name, SSDATA (ifname));
s = socket (AF_INET, SOCK_STREAM, 0);
if (s < 0)
Return non-nil if we received any output before the timeout expired. */)
(register Lisp_Object process, Lisp_Object seconds, Lisp_Object millisec, Lisp_Object just_this_one)
{
- int secs = -1, usecs = 0;
+ intmax_t secs;
+ int nsecs;
if (! NILP (process))
CHECK_PROCESS (process);
}
}
+ secs = 0;
+ nsecs = -1;
+
if (!NILP (seconds))
{
- double duration = extract_float (seconds);
- if (0 < duration)
- duration_to_sec_usec (duration, &secs, &usecs);
+ if (INTEGERP (seconds))
+ {
+ if (0 < XINT (seconds))
+ {
+ secs = XINT (seconds);
+ nsecs = 0;
+ }
+ }
+ else if (FLOATP (seconds))
+ {
+ if (0 < XFLOAT_DATA (seconds))
+ {
+ EMACS_TIME t = EMACS_TIME_FROM_DOUBLE (XFLOAT_DATA (seconds));
+ secs = min (EMACS_SECS (t), WAIT_READING_MAX);
+ nsecs = EMACS_NSECS (t);
+ }
+ }
+ else
+ wrong_type_argument (Qnumberp, seconds);
}
- else if (!NILP (process))
- secs = 0;
+ else if (! NILP (process))
+ nsecs = 0;
return
- (wait_reading_process_output (secs, usecs, 0, 0,
+ (wait_reading_process_output (secs, nsecs, 0, 0,
Qnil,
!NILP (process) ? XPROCESS (process) : NULL,
NILP (just_this_one) ? 0 :
return;
#endif
- if (!NILP (ps->log))
- call3 (ps->log, server, Qnil,
+ if (!NILP (PVAR (ps, log)))
+ call3 (PVAR (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 (ps->filter) && !EQ (ps->filter, Qt))
+ if (!NILP (PVAR (ps, filter)) && !EQ (PVAR (ps, filter), Qt))
buffer = Qnil;
else
{
- buffer = ps->buffer;
+ buffer = PVAR (ps, buffer);
if (!NILP (buffer))
buffer = Fbuffer_name (buffer);
else
- buffer = ps->name;
+ buffer = PVAR (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 (ps->name, caller);
+ name = concat2 (PVAR (ps, name), caller);
proc = make_process (name);
chan_process[s] = proc;
p = XPROCESS (proc);
/* Build new contact information for this setup. */
- contact = Fcopy_sequence (ps->childp);
+ contact = Fcopy_sequence (PVAR (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
- p->childp = contact;
- p->plist = Fcopy_sequence (ps->plist);
- p->type = Qnetwork;
+ PVAR (p, childp) = contact;
+ PVAR (p, plist) = Fcopy_sequence (PVAR (ps, plist));
+ PVAR (p, type) = Qnetwork;
- p->buffer = buffer;
- p->sentinel = ps->sentinel;
- p->filter = ps->filter;
- p->command = Qnil;
+ PVAR (p, buffer) = buffer;
+ PVAR (p, sentinel) = PVAR (ps, sentinel);
+ PVAR (p, filter) = PVAR (ps, filter);
+ PVAR (p, command) = Qnil;
p->pid = 0;
p->infd = s;
p->outfd = s;
- p->status = Qrun;
+ PVAR (p, status) = Qrun;
/* Client processes for accepted connections are not stopped initially. */
- if (!EQ (p->filter, Qt))
+ if (!EQ (PVAR (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. */
- p->decode_coding_system = ps->decode_coding_system;
- p->encode_coding_system = ps->encode_coding_system;
+ PVAR (p, decode_coding_system) = PVAR (ps, decode_coding_system);
+ PVAR (p, encode_coding_system) = PVAR (ps, encode_coding_system);
setup_process_coding_systems (proc);
- p->decoding_buf = empty_unibyte_string;
+ PVAR (p, decoding_buf) = empty_unibyte_string;
p->decoding_carryover = 0;
- p->encoding_buf = empty_unibyte_string;
+ PVAR (p, encoding_buf) = empty_unibyte_string;
p->inherit_coding_system_flag
= (NILP (buffer) ? 0 : ps->inherit_coding_system_flag);
- if (!NILP (ps->log))
- call3 (ps->log, server, proc,
+ if (!NILP (PVAR (ps, log)))
+ call3 (PVAR (ps, log), server, proc,
concat3 (build_string ("accept from "),
(STRINGP (host) ? host : build_string ("-")),
build_string ("\n")));
- if (!NILP (p->sentinel))
+ if (!NILP (PVAR (p, sentinel)))
exec_sentinel (proc,
concat3 (build_string ("open from "),
(STRINGP (host) ? host : build_string ("-")),
{
}
-/* Use a wrapper around select to work around a bug in gdb 5.3.
- Normally, the wrapper is optimized away by inlining.
-
- If emacs is stopped inside select, the gdb backtrace doesn't
- show the function which called select, so it is practically
- impossible to step through wait_reading_process_output. */
-
-#ifndef select
-static inline int
-select_wrapper (int n, fd_set *rfd, fd_set *wfd, fd_set *xfd, struct timeval *tmo)
-{
- return select (n, rfd, wfd, xfd, tmo);
-}
-#define select select_wrapper
-#endif
-
/* Read and dispose of subprocess output while waiting for timeout to
elapse and/or keyboard input to be available.
TIME_LIMIT is:
- timeout in seconds, or
- zero for no limit, or
- -1 means gobble data immediately available but don't wait for any.
+ timeout in seconds
+ If negative, gobble data immediately available but don't wait for any.
- MICROSECS is:
- an additional duration to wait, measured in microseconds.
- If this is nonzero and time_limit is 0, then the timeout
- consists of MICROSECS only.
+ NSECS is:
+ an additional duration to wait, measured in nanoseconds
+ If TIME_LIMIT is zero, then:
+ If NSECS == 0, there is no limit.
+ If NSECS > 0, the timeout consists of NSECS only.
+ If NSECS < 0, gobble data immediately, as if TIME_LIMIT were negative.
- READ_KBD is a lisp value:
+ READ_KBD is:
0 to ignore keyboard input, or
1 to return when input is available, or
-1 meaning caller will actually read the input, so don't throw to
Otherwise, return true if we received input from any process. */
int
-wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
+wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
int do_display,
Lisp_Object wait_for_cell,
struct Lisp_Process *wait_proc, int just_wait_proc)
FD_ZERO (&Available);
FD_ZERO (&Writeok);
- if (time_limit == 0 && microsecs == 0 && wait_proc && !NILP (Vinhibit_quit)
- && !(CONSP (wait_proc->status) && EQ (XCAR (wait_proc->status), Qexit)))
+ if (time_limit == 0 && nsecs == 0 && wait_proc && !NILP (Vinhibit_quit)
+ && !(CONSP (PVAR (wait_proc, status))
+ && EQ (XCAR (PVAR (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. */
make_number (waiting_for_user_input_p));
waiting_for_user_input_p = read_kbd;
+ if (time_limit < 0)
+ {
+ time_limit = 0;
+ nsecs = -1;
+ }
+ else if (TYPE_MAXIMUM (time_t) < time_limit)
+ time_limit = TYPE_MAXIMUM (time_t);
+
/* Since we may need to wait several times,
compute the absolute time to return at. */
- if (time_limit || microsecs)
+ if (time_limit || 0 < nsecs)
{
- EMACS_GET_TIME (end_time);
- EMACS_SET_SECS_USECS (timeout, time_limit, microsecs);
- EMACS_ADD_TIME (end_time, end_time, timeout);
+ timeout = make_emacs_time (time_limit, nsecs);
+ end_time = add_emacs_time (current_emacs_time (), timeout);
}
while (1)
/* Compute time from now till when time limit is up */
/* Exit if already run out */
- if (time_limit == -1)
+ if (nsecs < 0)
{
- /* -1 specified for timeout means
+ /* A negative timeout means
gobble output available now
but don't wait at all. */
- EMACS_SET_SECS_USECS (timeout, 0, 0);
+ timeout = make_emacs_time (0, 0);
}
- else if (time_limit || microsecs)
+ else if (time_limit || 0 < nsecs)
{
- EMACS_GET_TIME (timeout);
- EMACS_SUB_TIME (timeout, end_time, timeout);
- if (EMACS_TIME_NEG_P (timeout))
+ EMACS_TIME now = current_emacs_time ();
+ if (EMACS_TIME_LE (end_time, now))
break;
+ timeout = sub_emacs_time (end_time, now);
}
else
{
- EMACS_SET_SECS_USECS (timeout, 100000, 0);
+ timeout = make_emacs_time (100000, 0);
}
/* Normally we run timers here.
&& requeued_events_pending_p ())
break;
- if (! EMACS_TIME_NEG_P (timer_delay) && time_limit != -1)
+ /* A negative timeout means do not wait at all. */
+ if (0 <= nsecs)
{
- EMACS_TIME difference;
- EMACS_SUB_TIME (difference, timer_delay, timeout);
- if (EMACS_TIME_NEG_P (difference))
+ if (EMACS_TIME_VALID_P (timer_delay))
{
- timeout = timer_delay;
- timeout_reduced_for_timers = 1;
+ if (EMACS_TIME_LT (timer_delay, timeout))
+ {
+ timeout = timer_delay;
+ timeout_reduced_for_timers = 1;
+ }
+ }
+ else
+ {
+ /* This is so a breakpoint can be put here. */
+ wait_reading_process_output_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_output_1 ();
}
}
Atemp = input_wait_mask;
Ctemp = write_mask;
- EMACS_SET_SECS_USECS (timeout, 0, 0);
- if ((select (max (max_process_desc, max_input_desc) + 1,
- &Atemp,
+ timeout = make_emacs_time (0, 0);
+ if ((pselect (max (max_process_desc, max_input_desc) + 1,
+ &Atemp,
#ifdef NON_BLOCKING_CONNECT
- (num_pending_connects > 0 ? &Ctemp : (SELECT_TYPE *)0),
+ (num_pending_connects > 0 ? &Ctemp : NULL),
#else
- (SELECT_TYPE *)0,
+ NULL,
#endif
- (SELECT_TYPE *)0, &timeout)
+ NULL, &timeout, NULL)
<= 0))
{
/* It's okay for us to do this and then continue with
if (wait_proc && wait_proc->raw_status_new)
update_status (wait_proc);
if (wait_proc
- && ! EQ (wait_proc->status, Qrun)
- && ! EQ (wait_proc->status, Qconnect))
+ && ! EQ (PVAR (wait_proc, status), Qrun)
+ && ! EQ (PVAR (wait_proc, status), Qconnect))
{
int nread, total_nread = 0;
Vprocess_adaptive_read_buffering is nil. */
if (process_output_skip && check_delay > 0)
{
- int usecs = EMACS_USECS (timeout);
- if (EMACS_SECS (timeout) > 0 || usecs > READ_OUTPUT_DELAY_MAX)
- usecs = READ_OUTPUT_DELAY_MAX;
+ int nsecs = EMACS_NSECS (timeout);
+ if (EMACS_SECS (timeout) > 0 || nsecs > READ_OUTPUT_DELAY_MAX)
+ nsecs = READ_OUTPUT_DELAY_MAX;
for (channel = 0; check_delay > 0 && channel <= max_process_desc; channel++)
{
proc = chan_process[channel];
continue;
FD_CLR (channel, &Available);
XPROCESS (proc)->read_output_skip = 0;
- if (XPROCESS (proc)->read_output_delay < usecs)
- usecs = XPROCESS (proc)->read_output_delay;
+ if (XPROCESS (proc)->read_output_delay < nsecs)
+ nsecs = XPROCESS (proc)->read_output_delay;
}
}
- EMACS_SET_SECS_USECS (timeout, 0, usecs);
+ timeout = make_emacs_time (0, nsecs);
process_output_skip = 0;
}
#endif
#elif defined (HAVE_NS)
nfds = ns_select
#else
- nfds = select
+ nfds = pselect
#endif
(max (max_process_desc, max_input_desc) + 1,
&Available,
(check_write ? &Writeok : (SELECT_TYPE *)0),
- (SELECT_TYPE *)0, &timeout);
+ NULL, &timeout, NULL);
#ifdef HAVE_GNUTLS
/* GnuTLS buffers data internally. In lowat mode it leaves
/* If we woke up due to SIGWINCH, actually change size now. */
do_pending_window_change (0);
- if (time_limit && nfds == 0 && ! timeout_reduced_for_timers)
- /* We wanted the full specified time, so return now. */
+ if ((time_limit || nsecs) && nfds == 0 && ! timeout_reduced_for_timers)
+ /* We waited the full specified time, so return now. */
break;
if (nfds < 0)
{
if (wait_channel == channel)
{
wait_channel = -1;
- time_limit = -1;
+ nsecs = -1;
got_some_input = 1;
}
proc = chan_process[channel];
continue;
/* If this is a server stream socket, accept connection. */
- if (EQ (XPROCESS (proc)->status, Qlisten))
+ if (EQ (PVAR (XPROCESS (proc), status), Qlisten))
{
server_accept_connection (proc, channel);
continue;
wait3() will not find the process object to
delete. Do it here. */
p->tick = ++process_tick;
- p->status = Qfailed;
+ PVAR (p, status) = Qfailed;
}
else
kill (getpid (), SIGCHLD);
deactivate_process (proc);
if (XPROCESS (proc)->raw_status_new)
update_status (XPROCESS (proc));
- if (EQ (XPROCESS (proc)->status, Qrun))
- XPROCESS (proc)->status
+ if (EQ (PVAR (XPROCESS (proc), status), Qrun))
+ PVAR (XPROCESS (proc), status)
= Fcons (Qexit, Fcons (make_number (256), Qnil));
}
}
if (xerrno)
{
p->tick = ++process_tick;
- p->status = Fcons (Qfailed, Fcons (make_number (xerrno), Qnil));
+ PVAR (p, status)
+ = Fcons (Qfailed, Fcons (make_number (xerrno), Qnil));
deactivate_process (proc);
}
else
{
- p->status = Qrun;
+ PVAR (p, status) = 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 (p->filter, Qt) && !EQ (p->command, Qt))
+ if (!EQ (PVAR (p, filter), Qt) && !EQ (PVAR (p, command), Qt))
{
FD_SET (p->infd, &input_wait_mask);
FD_SET (p->infd, &non_keyboard_wait_mask);
ptrdiff_t count = SPECPDL_INDEX ();
Lisp_Object odeactivate;
- chars = (char *) alloca (carryover + readmax);
+ chars = alloca (carryover + readmax);
if (carryover)
/* See the comment above. */
- memcpy (chars, SDATA (p->decoding_buf), carryover);
+ memcpy (chars, SDATA (PVAR (p, decoding_buf)), carryover);
#ifdef DATAGRAM_SOCKETS
/* We have a working select, so proc_buffered_char is always -1. */
record_unwind_protect (set_buffer_if_live, Fcurrent_buffer ());
/* Read and dispose of the process output. */
- outstream = p->filter;
+ outstream = PVAR (p, filter);
if (!NILP (outstream))
{
Lisp_Object text;
text = coding->dst_object;
Vlast_coding_system_used = CODING_ID_NAME (coding->id);
/* A new coding system might be found. */
- if (!EQ (p->decode_coding_system, Vlast_coding_system_used))
+ if (!EQ (PVAR (p, decode_coding_system), Vlast_coding_system_used))
{
- p->decode_coding_system = Vlast_coding_system_used;
+ PVAR (p, decode_coding_system) = 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 (p->encode_coding_system)
+ if (NILP (PVAR (p, encode_coding_system))
&& proc_encode_coding_system[p->outfd])
{
- p->encode_coding_system
+ PVAR (p, encode_coding_system)
= coding_inherit_eol_type (Vlast_coding_system_used, Qnil);
- setup_coding_system (p->encode_coding_system,
+ setup_coding_system (PVAR (p, encode_coding_system),
proc_encode_coding_system[p->outfd]);
}
}
if (coding->carryover_bytes > 0)
{
- if (SCHARS (p->decoding_buf) < coding->carryover_bytes)
- p->decoding_buf = make_uninit_string (coding->carryover_bytes);
- memcpy (SDATA (p->decoding_buf), coding->carryover,
+ 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,
coding->carryover_bytes);
p->decoding_carryover = coding->carryover_bytes;
}
}
/* If no filter, write into buffer if it isn't dead. */
- else if (!NILP (p->buffer) && !NILP (BVAR (XBUFFER (p->buffer), name)))
+ else if (!NILP (PVAR (p, buffer)) && !NILP (BVAR (XBUFFER (PVAR (p, buffer)), name)))
{
Lisp_Object old_read_only;
ptrdiff_t old_begv, old_zv;
Lisp_Object text;
struct buffer *b;
- Fset_buffer (p->buffer);
+ Fset_buffer (PVAR (p, buffer));
opoint = PT;
opoint_byte = PT_BYTE;
old_read_only = BVAR (current_buffer, read_only);
/* 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_BOTH (clip_to_bounds (BEGV, marker_position (p->mark), ZV),
- clip_to_bounds (BEGV_BYTE, marker_byte_position (p->mark),
+ if (XMARKER (PVAR (p, mark))->buffer)
+ SET_PT_BOTH (clip_to_bounds (BEGV,
+ marker_position (PVAR (p, mark)), ZV),
+ clip_to_bounds (BEGV_BYTE,
+ marker_byte_position (PVAR (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 (p->decode_coding_system, Vlast_coding_system_used))
+ if (!EQ (PVAR (p, decode_coding_system), Vlast_coding_system_used))
{
- p->decode_coding_system = Vlast_coding_system_used;
- if (NILP (p->encode_coding_system)
+ PVAR (p, decode_coding_system) = Vlast_coding_system_used;
+ if (NILP (PVAR (p, encode_coding_system))
&& proc_encode_coding_system[p->outfd])
{
- p->encode_coding_system
+ PVAR (p, encode_coding_system)
= coding_inherit_eol_type (Vlast_coding_system_used, Qnil);
- setup_coding_system (p->encode_coding_system,
+ setup_coding_system (PVAR (p, encode_coding_system),
proc_encode_coding_system[p->outfd]);
}
}
if (coding->carryover_bytes > 0)
{
- if (SCHARS (p->decoding_buf) < coding->carryover_bytes)
- p->decoding_buf = make_uninit_string (coding->carryover_bytes);
- memcpy (SDATA (p->decoding_buf), coding->carryover,
+ 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,
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 (p->buffer)
- && (b = XBUFFER (p->buffer), b != current_buffer))
- set_marker_both (p->mark, p->buffer, BUF_PT (b), BUF_PT_BYTE (b));
+ 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));
else
- set_marker_both (p->mark, p->buffer, PT, PT_BYTE);
+ set_marker_both (PVAR (p, mark), PVAR (p, buffer), PT, PT_BYTE);
update_mode_lines++;
static Lisp_Object process_sent_to;
#ifndef FORWARD_SIGNAL_TO_MAIN_THREAD
-static void send_process_trap (int) NO_RETURN;
+static _Noreturn void send_process_trap (int);
#endif
static void
longjmp (send_process_frame, 1);
}
+/* In send_process, when a write fails temporarily,
+ wait_reading_process_output is called. It may execute user code,
+ e.g. timers, that attempts to write new data to the same process.
+ We must ensure that data is sent in the right order, and not
+ interspersed half-completed with other writes (Bug#10815). This is
+ handled by the write_queue element of struct process. It is a list
+ with each entry having the form
+
+ (string . (offset . length))
+
+ where STRING is a lisp string, OFFSET is the offset into the
+ string's byte sequence from which we should begin to send, and
+ LENGTH is the number of bytes left to send. */
+
+/* Create a new entry in write_queue.
+ INPUT_OBJ should be a buffer, string Qt, or Qnil.
+ BUF is a pointer to the string sequence of the input_obj or a C
+ string in case of Qt or Qnil. */
+
+static void
+write_queue_push (struct Lisp_Process *p, Lisp_Object input_obj,
+ const char *buf, ptrdiff_t len, int front)
+{
+ ptrdiff_t offset;
+ Lisp_Object entry, obj;
+
+ if (STRINGP (input_obj))
+ {
+ offset = buf - SSDATA (input_obj);
+ obj = input_obj;
+ }
+ else
+ {
+ offset = 0;
+ obj = make_unibyte_string (buf, len);
+ }
+
+ entry = Fcons (obj, Fcons (make_number (offset), make_number (len)));
+
+ if (front)
+ PVAR (p, write_queue) = Fcons (entry, PVAR (p, write_queue));
+ else
+ PVAR (p, write_queue) = nconc2 (PVAR (p, write_queue), Fcons (entry, Qnil));
+}
+
+/* Remove the first element in the write_queue of process P, put its
+ contents in OBJ, BUF and LEN, and return non-zero. If the
+ write_queue is empty, return zero. */
+
+static int
+write_queue_pop (struct Lisp_Process *p, Lisp_Object *obj,
+ const char **buf, ptrdiff_t *len)
+{
+ Lisp_Object entry, offset_length;
+ ptrdiff_t offset;
+
+ if (NILP (PVAR (p, write_queue)))
+ return 0;
+
+ entry = XCAR (PVAR (p, write_queue));
+ PVAR (p, write_queue) = XCDR (PVAR (p, write_queue));
+
+ *obj = XCAR (entry);
+ offset_length = XCDR (entry);
+
+ *len = XINT (XCDR (offset_length));
+ offset = XINT (XCAR (offset_length));
+ *buf = SSDATA (*obj) + offset;
+
+ return 1;
+}
+
/* 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. If OBJECT is
struct Lisp_Process *p = XPROCESS (proc);
ssize_t rv;
struct coding_system *coding;
- struct gcpro gcpro1;
void (*volatile old_sigpipe) (int);
- GCPRO1 (object);
-
if (p->raw_status_new)
update_status (p);
- if (! EQ (p->status, Qrun))
- error ("Process %s not running", SDATA (p->name));
+ if (! EQ (PVAR (p, status), Qrun))
+ error ("Process %s not running", SDATA (PVAR (p, name)));
if (p->outfd < 0)
- error ("Output file descriptor of %s is closed", SDATA (p->name));
+ error ("Output file descriptor of %s is closed", SDATA (PVAR (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))
{
- p->encode_coding_system
- = complement_process_encoding_system (p->encode_coding_system);
- if (!EQ (Vlast_coding_system_used, p->encode_coding_system))
+ 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)))
{
/* 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 (p->encode_coding_system, coding);
- Vlast_coding_system_used = p->encode_coding_system;
+ setup_coding_system (PVAR (p, encode_coding_system), coding);
+ Vlast_coding_system_used = PVAR (p, encode_coding_system);
}
coding->src_multibyte = 1;
}
if (!setjmp (send_process_frame))
{
p = XPROCESS (proc); /* Repair any setjmp clobbering. */
-
process_sent_to = proc;
- while (len > 0)
+
+ /* 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)))
+ write_queue_push (p, object, buf, len, 0);
+
+ do /* while !NILP (p->write_queue) */
{
- ptrdiff_t this = len;
+ ptrdiff_t cur_len = -1;
+ const char *cur_buf;
+ Lisp_Object cur_object;
- /* Send this batch, using one or more write calls. */
- while (this > 0)
+ /* If write_queue is empty, ignore it. */
+ if (!write_queue_pop (p, &cur_object, &cur_buf, &cur_len))
{
+ cur_len = len;
+ cur_buf = buf;
+ cur_object = object;
+ }
+
+ while (cur_len > 0)
+ {
+ /* 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);
#ifdef DATAGRAM_SOCKETS
if (DATAGRAM_CHAN_P (outfd))
{
- rv = sendto (outfd, buf, this,
+ rv = sendto (outfd, cur_buf, cur_len,
0, datagram_address[outfd].sa,
datagram_address[outfd].len);
if (0 <= rv)
{
#ifdef HAVE_GNUTLS
if (p->gnutls_p)
- written = emacs_gnutls_write (p, buf, this);
+ written = emacs_gnutls_write (p, cur_buf, cur_len);
else
#endif
- written = emacs_write (outfd, buf, this);
+ written = emacs_write (outfd, cur_buf, cur_len);
rv = (written ? 0 : -1);
#ifdef ADAPTIVE_READ_BUFFERING
if (p->read_output_delay > 0
that may allow the program
to finish doing output and read more. */
{
- ptrdiff_t offset = 0;
-
#ifdef BROKEN_PTY_READ_AFTER_EAGAIN
/* A gross hack to work around a bug in FreeBSD.
In the following sequence, read(2) returns
}
#endif /* BROKEN_PTY_READ_AFTER_EAGAIN */
- /* Running filters might relocate buffers or strings.
- Arrange to relocate BUF. */
- if (BUFFERP (object))
- offset = BUF_PTR_BYTE_POS (XBUFFER (object),
- (unsigned char *) buf);
- else if (STRINGP (object))
- offset = buf - SSDATA (object);
-
-#ifdef EMACS_HAS_USECS
- wait_reading_process_output (0, 20000, 0, 0, Qnil, NULL, 0);
-#else
- wait_reading_process_output (1, 0, 0, 0, Qnil, NULL, 0);
-#endif
-
- if (BUFFERP (object))
- buf = (char *) BUF_BYTE_ADDRESS (XBUFFER (object),
- offset);
- else if (STRINGP (object))
- buf = offset + SSDATA (object);
+ /* Put what we should have written in wait_queue. */
+ write_queue_push (p, cur_object, cur_buf, cur_len, 1);
+ wait_reading_process_output (0, 20 * 1000 * 1000,
+ 0, 0, Qnil, NULL, 0);
+ /* Reread queue, to see what is left. */
+ break;
}
else
/* This is a real error. */
report_file_error ("writing to process", Fcons (proc, Qnil));
}
- buf += written;
- len -= written;
- this -= written;
+ cur_buf += written;
+ cur_len -= written;
}
}
+ while (!NILP (PVAR (p, write_queue)));
}
else
{
proc = process_sent_to;
p = XPROCESS (proc);
p->raw_status_new = 0;
- p->status = Fcons (Qexit, Fcons (make_number (256), Qnil));
+ PVAR (p, status) = Fcons (Qexit, Fcons (make_number (256), Qnil));
p->tick = ++process_tick;
deactivate_process (proc);
- error ("SIGPIPE raised on process %s; closed it", SDATA (p->name));
+ error ("SIGPIPE raised on process %s; closed it", SDATA (PVAR (p, name)));
}
-
- UNGCPRO;
}
DEFUN ("process-send-region", Fprocess_send_region, Sprocess_send_region,
pid_t gid = -1;
#ifdef TIOCGPGRP
- if (ioctl (p->infd, TIOCGPGRP, &gid) == -1 && ! NILP (p->tty_name))
+ if (ioctl (p->infd, TIOCGPGRP, &gid) == -1 && ! NILP (PVAR (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 (p->tty_name), O_RDONLY, 0);
+ fd = emacs_open (SSDATA (PVAR (p, tty_name)), O_RDONLY, 0);
if (fd != -1)
{
proc = get_process (process);
p = XPROCESS (proc);
- if (!EQ (p->type, Qreal))
+ if (!EQ (PVAR (p, type), Qreal))
error ("Process %s is not a subprocess",
- SDATA (p->name));
+ SDATA (PVAR (p, name)));
if (p->infd < 0)
error ("Process %s is not active",
- SDATA (p->name));
+ SDATA (PVAR (p, name)));
gid = emacs_get_tty_pgrp (p);
proc = get_process (process);
p = XPROCESS (proc);
- if (!EQ (p->type, Qreal))
+ if (!EQ (PVAR (p, type), Qreal))
error ("Process %s is not a subprocess",
- SDATA (p->name));
+ SDATA (PVAR (p, name)));
if (p->infd < 0)
error ("Process %s is not active",
- SDATA (p->name));
+ SDATA (PVAR (p, name)));
if (!p->pty_flag)
current_group = Qnil;
#ifdef SIGCONT
case SIGCONT:
p->raw_status_new = 0;
- p->status = Qrun;
+ PVAR (p, status) = Qrun;
p->tick = ++process_tick;
if (!nomsg)
{
struct Lisp_Process *p;
p = XPROCESS (process);
- if (NILP (p->command)
+ if (NILP (PVAR (p, command))
&& p->infd >= 0)
{
FD_CLR (p->infd, &input_wait_mask);
FD_CLR (p->infd, &non_keyboard_wait_mask);
}
- p->command = Qt;
+ PVAR (p, command) = Qt;
return process;
}
#ifndef SIGTSTP
struct Lisp_Process *p;
p = XPROCESS (process);
- if (EQ (p->command, Qt)
+ if (EQ (PVAR (p, command), Qt)
&& p->infd >= 0
- && (!EQ (p->filter, Qt) || EQ (p->status, Qlisten)))
+ && (!EQ (PVAR (p, filter), Qt) || EQ (PVAR (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 */
}
- p->command = Qnil;
+ PVAR (p, command) = Qnil;
return process;
}
#ifdef SIGCONT
CHECK_PROCESS (process);
pid = XPROCESS (process)->pid;
if (pid <= 0)
- error ("Cannot signal process %s", SDATA (XPROCESS (process)->name));
+ error ("Cannot signal process %s",
+ SDATA (PVAR (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 (XPROCESS (proc)->status, Qrun))
- error ("Process %s not running", SDATA (XPROCESS (proc)->name));
+ if (! EQ (PVAR (XPROCESS (proc), status), Qrun))
+ error ("Process %s not running", SDATA (PVAR (XPROCESS (proc), name)));
if (CODING_REQUIRE_FLUSHING (coding))
{
if (XPROCESS (proc)->pty_flag)
send_process (proc, "\004", 1, Qnil);
- else if (EQ (XPROCESS (proc)->type, Qserial))
+ else if (EQ (PVAR (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 (XPROCESS (proc)->type, Qnetwork)
+ if (EQ (PVAR (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. */
if (!proc_encode_coding_system[new_outfd])
proc_encode_coding_system[new_outfd]
- = (struct coding_system *) xmalloc (sizeof (struct coding_system));
+ = xmalloc (sizeof (struct coding_system));
memcpy (proc_encode_coding_system[new_outfd],
proc_encode_coding_system[old_outfd],
sizeof (struct coding_system));
{
proc = XCDR (XCAR (tail));
p = XPROCESS (proc);
- if (EQ (p->type, Qreal) && p->pid == pid)
+ if (EQ (PVAR (p, type), Qreal) && p->pid == pid)
break;
p = 0;
}
/* Tell wait_reading_process_output that it needs to wake up and
look around. */
if (input_available_clear_time)
- EMACS_SET_SECS_USECS (*input_available_clear_time, 0, 0);
+ *input_available_clear_time = make_emacs_time (0, 0);
}
/* There was no asynchronous process found for that pid: we have
/* Tell wait_reading_process_output that it needs to wake up and
look around. */
if (input_available_clear_time)
- EMACS_SET_SECS_USECS (*input_available_clear_time, 0, 0);
+ *input_available_clear_time = make_emacs_time (0, 0);
}
sigchld_end_of_loop:
static Lisp_Object
exec_sentinel_unwind (Lisp_Object data)
{
- XPROCESS (XCAR (data))->sentinel = XCDR (data);
+ PVAR (XPROCESS (XCAR (data)), sentinel) = XCDR (data);
return Qnil;
}
friends don't expect current-buffer to be changed from under them. */
record_unwind_protect (set_buffer_if_live, Fcurrent_buffer ());
- sentinel = p->sentinel;
+ sentinel = PVAR (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. */
- p->sentinel = Qnil;
+ PVAR (p, sentinel) = 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 (p->filter, Qt)
- && ! EQ (p->status, Qconnect)
- && ! EQ (p->status, Qlisten)
+ while (! EQ (PVAR (p, filter), Qt)
+ && ! EQ (PVAR (p, status), Qconnect)
+ && ! EQ (PVAR (p, status), Qlisten)
/* Network or serial process not stopped: */
- && ! EQ (p->command, Qt)
+ && ! EQ (PVAR (p, command), Qt)
&& p->infd >= 0
&& p != deleting_process
&& read_process_output (proc, p->infd) > 0);
- buffer = p->buffer;
+ buffer = PVAR (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 = p->status;
- if (CONSP (p->status))
- symbol = XCAR (p->status);
+ symbol = PVAR (p, status);
+ if (CONSP (PVAR (p, status)))
+ symbol = XCAR (PVAR (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 (p->sentinel))
+ if (!NILP (PVAR (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 (p->mark)->buffer)
- Fgoto_char (p->mark);
+ if (XMARKER (PVAR (p, mark))->buffer)
+ Fgoto_char (PVAR (p, mark));
else
SET_PT_BOTH (ZV, ZV_BYTE);
tem = BVAR (current_buffer, read_only);
BVAR (current_buffer, read_only) = Qnil;
insert_string ("\nProcess ");
- Finsert (1, &p->name);
+ Finsert (1, &PVAR (p, name));
insert_string (" ");
Finsert (1, &msg);
BVAR (current_buffer, read_only) = tem;
- set_marker_both (p->mark, p->buffer, PT, PT_BYTE);
+ set_marker_both (PVAR (p, mark), PVAR (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 (p->name));
+ error ("Input file descriptor of %s closed", SDATA (PVAR (p, name)));
if (p->outfd < 0)
- error ("Output file descriptor of %s closed", SDATA (p->name));
+ error ("Output file descriptor of %s closed", SDATA (PVAR (p, name)));
Fcheck_coding_system (decoding);
Fcheck_coding_system (encoding);
encoding = coding_inherit_eol_type (encoding, Qnil);
- p->decode_coding_system = decoding;
- p->encode_coding_system = encoding;
+ PVAR (p, decode_coding_system) = decoding;
+ PVAR (p, encode_coding_system) = encoding;
setup_process_coding_systems (process);
return Qnil;
(register Lisp_Object process)
{
CHECK_PROCESS (process);
- return Fcons (XPROCESS (process)->decode_coding_system,
- XPROCESS (process)->encode_coding_system);
+ return Fcons (PVAR (XPROCESS (process), decode_coding_system),
+ PVAR (XPROCESS (process), encode_coding_system));
}
DEFUN ("set-process-filter-multibyte", Fset_process_filter_multibyte,
CHECK_PROCESS (process);
p = XPROCESS (process);
if (NILP (flag))
- p->decode_coding_system = raw_text_coding_system (p->decode_coding_system);
+ PVAR (p, decode_coding_system)
+ = raw_text_coding_system (PVAR (p, decode_coding_system));
setup_process_coding_systems (process);
return Qnil;
/* Defined on msdos.c. */
extern int sys_select (int, SELECT_TYPE *, SELECT_TYPE *, SELECT_TYPE *,
- EMACS_TIME *);
+ EMACS_TIME *, void *);
/* Implementation of wait_reading_process_output, assuming that there
are no subprocesses. Used only by the MS-DOS build.
Wait for timeout to elapse and/or keyboard input to be available.
- time_limit is:
- timeout in seconds, or
- zero for no limit, or
- -1 means gobble data immediately available but don't wait for any.
+ TIME_LIMIT is:
+ timeout in seconds
+ If negative, gobble data immediately available but don't wait for any.
+
+ NSECS is:
+ an additional duration to wait, measured in nanoseconds
+ If TIME_LIMIT is zero, then:
+ If NSECS == 0, there is no limit.
+ If NSECS > 0, the timeout consists of NSECS only.
+ If NSECS < 0, gobble data immediately, as if TIME_LIMIT were negative.
- read_kbd is a Lisp_Object:
+ READ_KBD is:
0 to ignore keyboard input, or
1 to return when input is available, or
-1 means caller will actually read the input, so don't throw to
see full version for other parameters. We know that wait_proc will
always be NULL, since `subprocesses' isn't defined.
- do_display != 0 means redisplay should be done to show subprocess
+ DO_DISPLAY != 0 means redisplay should be done to show subprocess
output that arrives.
Return true if we received input from any process. */
int
-wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
+wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
int do_display,
Lisp_Object wait_for_cell,
struct Lisp_Process *wait_proc, int just_wait_proc)
{
register int nfds;
EMACS_TIME end_time, timeout;
- SELECT_TYPE waitchannels;
- int xerrno;
+
+ if (time_limit < 0)
+ {
+ time_limit = 0;
+ nsecs = -1;
+ }
+ else if (TYPE_MAXIMUM (time_t) < time_limit)
+ time_limit = TYPE_MAXIMUM (time_t);
/* What does time_limit really mean? */
- if (time_limit || microsecs)
+ if (time_limit || 0 < nsecs)
{
- EMACS_GET_TIME (end_time);
- EMACS_SET_SECS_USECS (timeout, time_limit, microsecs);
- EMACS_ADD_TIME (end_time, end_time, timeout);
+ timeout = make_emacs_time (time_limit, nsecs);
+ end_time = add_emacs_time (current_emacs_time (), timeout);
}
/* Turn off periodic alarms (in case they are in use)
while (1)
{
int timeout_reduced_for_timers = 0;
+ SELECT_TYPE waitchannels;
+ int xerrno;
/* If calling from keyboard input, do not quit
since we want to return C-g as an input character.
/* Compute time from now till when time limit is up */
/* Exit if already run out */
- if (time_limit == -1)
+ if (nsecs < 0)
{
- /* -1 specified for timeout means
+ /* A negative timeout means
gobble output available now
but don't wait at all. */
- EMACS_SET_SECS_USECS (timeout, 0, 0);
+ timeout = make_emacs_time (0, 0);
}
- else if (time_limit || microsecs)
+ else if (time_limit || 0 < nsecs)
{
- EMACS_GET_TIME (timeout);
- EMACS_SUB_TIME (timeout, end_time, timeout);
- if (EMACS_TIME_NEG_P (timeout))
+ EMACS_TIME now = current_emacs_time ();
+ if (EMACS_TIME_LE (end_time, now))
break;
+ timeout = sub_emacs_time (end_time, now);
}
else
{
- EMACS_SET_SECS_USECS (timeout, 100000, 0);
+ timeout = make_emacs_time (100000, 0);
}
/* If our caller will not immediately handle keyboard events,
&& requeued_events_pending_p ())
break;
- if (! EMACS_TIME_NEG_P (timer_delay) && time_limit != -1)
+ if (EMACS_TIME_VALID_P (timer_delay) && 0 <= nsecs)
{
- EMACS_TIME difference;
- EMACS_SUB_TIME (difference, timer_delay, timeout);
- if (EMACS_TIME_NEG_P (difference))
+ if (EMACS_TIME_LT (timer_delay, timeout))
{
timeout = timer_delay;
timeout_reduced_for_timers = 1;
if (read_kbd < 0)
set_waiting_for_input (&timeout);
- /* Wait till there is something to do. */
-
- if (! read_kbd && NILP (wait_for_cell))
- 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)
set_waiting_for_input (&timeout);
}
+ /* Wait till there is something to do. */
+ FD_ZERO (&waitchannels);
if (read_kbd && detect_input_pending ())
+ nfds = 0;
+ else
{
- nfds = 0;
- FD_ZERO (&waitchannels);
+ if (read_kbd || !NILP (wait_for_cell))
+ FD_SET (0, &waitchannels);
+ nfds = pselect (1, &waitchannels, NULL, NULL, &timeout, NULL);
}
- else
- nfds = select (1, &waitchannels, (SELECT_TYPE *)0, (SELECT_TYPE *)0,
- &timeout);
xerrno = errno;
/* If we woke up due to SIGWINCH, actually change size now. */
do_pending_window_change (0);
- if (time_limit && nfds == 0 && ! timeout_reduced_for_timers)
+ if ((time_limit || nsecs) && nfds == 0 && ! timeout_reduced_for_timers)
/* We waited the full specified time, so return now. */
break;
return;
if (!proc_decode_coding_system[inch])
- proc_decode_coding_system[inch]
- = (struct coding_system *) xmalloc (sizeof (struct coding_system));
- coding_system = p->decode_coding_system;
- if (! NILP (p->filter))
+ proc_decode_coding_system[inch] = xmalloc (sizeof (struct coding_system));
+ coding_system = PVAR (p, decode_coding_system);
+ if (! NILP (PVAR (p, filter)))
;
- else if (BUFFERP (p->buffer))
+ else if (BUFFERP (PVAR (p, buffer)))
{
- if (NILP (BVAR (XBUFFER (p->buffer), enable_multibyte_characters)))
+ if (NILP (BVAR (XBUFFER (PVAR (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]
- = (struct coding_system *) xmalloc (sizeof (struct coding_system));
- setup_coding_system (p->encode_coding_system,
+ proc_encode_coding_system[outch] = xmalloc (sizeof (struct coding_system));
+ setup_coding_system (PVAR (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 (XPROCESS (proc)->buffer, buf))
+ if (PROCESSP (proc) && EQ (PVAR (XPROCESS (proc), buffer), buf))
return proc;
}
#endif /* subprocesses */
{
proc = XCDR (XCAR (tail));
if (PROCESSP (proc)
- && (NILP (buffer) || EQ (XPROCESS (proc)->buffer, buffer)))
+ && (NILP (buffer) || EQ (PVAR (XPROCESS (proc), buffer), buffer)))
{
if (NETCONN_P (proc) || SERIALCONN_P (proc))
Fdelete_process (proc);
majflt -- number of major page faults (number)
cminflt -- cumulative number of minor page faults (number)
cmajflt -- cumulative number of major page faults (number)
- utime -- user time used by the process, in the (HIGH LOW USEC) format
- stime -- system time used by the process, in the (HIGH LOW USEC) format
- time -- sum of utime and stime, in the (HIGH LOW USEC) format
- cutime -- user time used by the process and its children, (HIGH LOW USEC)
- cstime -- system time used by the process and its children, (HIGH LOW USEC)
- ctime -- sum of cutime and cstime, in the (HIGH LOW USEC) format
+ utime -- user time used by the process, in (current-time) format,
+ which is a list of integers (HIGH LOW USEC PSEC)
+ stime -- system time used by the process (current-time)
+ time -- sum of utime and stime (current-time)
+ cutime -- user time used by the process and its children (current-time)
+ cstime -- system time used by the process and its children (current-time)
+ ctime -- sum of cutime and cstime (current-time)
pri -- priority of the process (number)
nice -- nice value of the process (number)
thcount -- process thread count (number)
- start -- time the process started, in the (HIGH LOW USEC) format
+ start -- time the process started (current-time)
vsize -- virtual memory size of the process in KB's (number)
rss -- resident set size of the process in KB's (number)
- etime -- elapsed time the process is running, in (HIGH LOW USEC) format
+ etime -- elapsed time the process is running, in (HIGH LOW USEC PSEC) format
pcpu -- percents of CPU time used by the process (floating-point number)
pmem -- percents of total physical memory used by process's resident set
(floating-point number)
}
\f
+/* This is not called "init_process" because that is the name of a
+ Mach system call, so it would cause problems on Darwin systems. */
void
-init_process (void)
+init_process_emacs (void)
{
#ifdef subprocesses
register int i;
char const *release = (STRINGP (Voperating_system_release)
? SSDATA (Voperating_system_release)
: 0);
- if (!release || !release[0] || (release[0] < MIN_PTY_KERNEL_VERSION
- && release[1] == '.')) {
+ if (!release || !release[0] || (release[0] < '7' && release[1] == '.')) {
Vprocess_connection_type = Qnil;
}
}
HCoop / bpt / emacs.git / blobdiff