#include "systty.h"
#include "syswait.h"
-Lisp_Object Qprocessp;
+Lisp_Object Qprocessp, Qprocess_live_p;
/* Process methods */
struct process_methods the_process_methods;
static Lisp_Object
mark_process (Lisp_Object obj)
{
- struct Lisp_Process *proc = XPROCESS (obj);
+ Lisp_Process *proc = XPROCESS (obj);
MAYBE_PROCMETH (mark_process_data, (proc));
mark_object (proc->name);
mark_object (proc->command);
static void
print_process (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
{
- struct Lisp_Process *proc = XPROCESS (obj);
+ Lisp_Process *proc = XPROCESS (obj);
if (print_readably)
error ("printing unreadable object #<process %s>",
}
#ifdef HAVE_WINDOW_SYSTEM
-extern void debug_process_finalization (struct Lisp_Process *p);
+extern void debug_process_finalization (Lisp_Process *p);
#endif /* HAVE_WINDOW_SYSTEM */
static void
{
/* #### this probably needs to be tied into the tty event loop */
/* #### when there is one */
- struct Lisp_Process *p = (struct Lisp_Process *) header;
+ Lisp_Process *p = (Lisp_Process *) header;
#ifdef HAVE_WINDOW_SYSTEM
if (!for_disksave)
{
DEFINE_LRECORD_IMPLEMENTATION ("process", process,
mark_process, print_process, finalize_process,
- 0, 0, 0, struct Lisp_Process);
+ 0, 0, 0, Lisp_Process);
\f
/************************************************************************/
/* basic process accessors */
directly to the child process, rather than en/decoding FILE_CODING
streams */
void
-get_process_streams (struct Lisp_Process *p,
- Lisp_Object *instr, Lisp_Object *outstr)
+get_process_streams (Lisp_Process *p, Lisp_Object *instr, Lisp_Object *outstr)
{
assert (p);
assert (NILP (p->pipe_instream) || LSTREAMP(p->pipe_instream));
*outstr = p->pipe_outstream;
}
-struct Lisp_Process *
+Lisp_Process *
get_process_from_usid (USID usid)
{
- CONST void *vval;
+ const void *vval;
assert (usid != USID_ERROR && usid != USID_DONTHASH);
- if (gethash ((CONST void*)usid, usid_to_process, &vval))
+ if (gethash ((const void*)usid, usid_to_process, &vval))
{
Lisp_Object proc;
CVOID_TO_LISP (proc, vval);
}
int
-get_process_selected_p (struct Lisp_Process *p)
+get_process_selected_p (Lisp_Process *p)
{
return p->selected;
}
void
-set_process_selected_p (struct Lisp_Process *p, int selected_p)
+set_process_selected_p (Lisp_Process *p, int selected_p)
{
p->selected = !!selected_p;
}
int
-connected_via_filedesc_p (struct Lisp_Process *p)
+connected_via_filedesc_p (Lisp_Process *p)
{
return MAYBE_INT_PROCMETH (tooltalk_connection_p, (p));
}
return PROCESSP (obj) ? Qt : Qnil;
}
+DEFUN ("process-live-p", Fprocess_live_p, 1, 1, 0, /*
+Return t if OBJECT is a process that is alive.
+*/
+ (obj))
+{
+ return PROCESSP (obj) && PROCESS_LIVE_P (XPROCESS (obj)) ? Qt : Qnil;
+}
+
DEFUN ("process-list", Fprocess_list, 0, 0, 0, /*
Return a list of all processes.
*/
{
Lisp_Object val, name1;
int i;
- struct Lisp_Process *p =
- alloc_lcrecord_type (struct Lisp_Process, &lrecord_process);
+ Lisp_Process *p = alloc_lcrecord_type (Lisp_Process, &lrecord_process);
/* If name is already in use, modify it until it is unused. */
name1 = name;
}
void
-init_process_io_handles (struct Lisp_Process *p, void* in, void* out, int flags)
+init_process_io_handles (Lisp_Process *p, void* in, void* out, int flags)
{
USID usid = event_stream_create_stream_pair (in, out,
&p->pipe_instream, &p->pipe_outstream,
{
Lisp_Object proc = Qnil;
XSETPROCESS (proc, p);
- puthash ((CONST void*)usid, LISP_TO_VOID (proc), usid_to_process);
+ puthash ((const void*)usid, LISP_TO_VOID (proc), usid_to_process);
}
MAYBE_PROCMETH (init_process_io_handles, (p, in, out, flags));
create_process (Lisp_Object process, Lisp_Object *argv, int nargv,
Lisp_Object program, Lisp_Object cur_dir)
{
- struct Lisp_Process *p = XPROCESS (process);
+ Lisp_Process *p = XPROCESS (process);
int pid;
/* *_create_process may change status_symbol, if the process
pid = PROCMETH (create_process, (p, argv, nargv, program, cur_dir));
p->pid = make_int (pid);
- if (!NILP(p->pipe_instream))
+ if (PROCESS_LIVE_P (p))
event_stream_select_process (p);
}
Bytecount nbytes, nchars;
Bufbyte chars[1024];
Lisp_Object outstream;
- struct Lisp_Process *p = XPROCESS (proc);
+ Lisp_Process *p = XPROCESS (proc);
/* If there is a lot of output from the subprocess, the loop in
execute_internal_event() might call read_process_output() more
Really, the loop in execute_internal_event() should check itself
for a process-filter change, like in status_notify(); but the
struct Lisp_Process is not exported outside of this file. */
- if (NILP(p->pipe_instream))
+ if (!PROCESS_LIVE_P (p))
return -1; /* already closed */
if (!NILP (p->filter) && (p->filter_does_read))
void
send_process (Lisp_Object proc,
- Lisp_Object relocatable, CONST Bufbyte *nonrelocatable,
+ Lisp_Object relocatable, const Bufbyte *nonrelocatable,
int start, int len)
{
/* This function can GC */
set_process_filter (Lisp_Object proc, Lisp_Object filter, int filter_does_read)
{
CHECK_PROCESS (proc);
- if (PROCESS_LIVE_P (proc)) {
+ if (PROCESS_LIVE_P (XPROCESS (proc))) {
if (EQ (filter, Qt))
event_stream_unselect_process (XPROCESS (proc));
else
(process))
{
process = get_process (process);
+ CHECK_LIVE_PROCESS (process);
return decoding_stream_coding_system (XLSTREAM (XPROCESS (process)->coding_instream) );
}
(process))
{
process = get_process (process);
+ CHECK_LIVE_PROCESS (process);
return encoding_stream_coding_system (XLSTREAM (XPROCESS (process)->coding_outstream));
}
(process))
{
process = get_process (process);
+ CHECK_LIVE_PROCESS (process);
return Fcons (decoding_stream_coding_system
(XLSTREAM (XPROCESS (process)->coding_instream)),
encoding_stream_coding_system
{
codesys = Fget_coding_system (codesys);
process = get_process (process);
+ CHECK_LIVE_PROCESS (process);
+
set_decoding_stream_coding_system
(XLSTREAM (XPROCESS (process)->coding_instream), codesys);
return Qnil;
{
codesys = Fget_coding_system (codesys);
process = get_process (process);
+ CHECK_LIVE_PROCESS (process);
+
set_encoding_stream_coding_system
(XLSTREAM (XPROCESS (process)->coding_outstream), codesys);
return Qnil;
DEFUN ("set-process-coding-system", Fset_process_coding_system,
1, 3, 0, /*
Set coding-systems of PROCESS to DECODING and ENCODING.
+DECODING will be used to decode subprocess output and ENCODING to
+encode subprocess input.
*/
(process, decoding, encoding))
{
static Lisp_Object
exec_sentinel_unwind (Lisp_Object datum)
{
- struct Lisp_Cons *d = XCONS (datum);
+ Lisp_Cons *d = XCONS (datum);
XPROCESS (d->car)->sentinel = d->cdr;
free_cons (d);
return Qnil;
{
/* This function can GC */
int speccount = specpdl_depth ();
- struct Lisp_Process *p = XPROCESS (proc);
+ Lisp_Process *p = XPROCESS (proc);
Lisp_Object sentinel = p->sentinel;
if (NILP (sentinel))
}
\f
-CONST char *
+const char *
signal_name (int signum)
{
if (signum >= 0 && signum < NSIG)
- return (CONST char *) sys_siglist[signum];
+ return (const char *) sys_siglist[signum];
- return (CONST char *) GETTEXT ("unknown signal");
+ return (const char *) GETTEXT ("unknown signal");
}
void
/* Return a string describing a process status list. */
static Lisp_Object
-status_message (struct Lisp_Process *p)
+status_message (Lisp_Process *p)
{
Lisp_Object symbol = p->status_symbol;
int code = p->exit_code;
for (tail = Vprocess_list; CONSP (tail); tail = XCDR (tail))
{
Lisp_Object proc = XCAR (tail);
- struct Lisp_Process *p = XPROCESS (proc);
+ Lisp_Process *p = XPROCESS (proc);
/* p->tick is also volatile. Same thing as above applies. */
int this_process_tick;
if (network_connection_p (proc))
error ("Network connection %s is not a subprocess",
XSTRING_DATA (XPROCESS(proc)->name));
- if (!PROCESS_LIVE_P (proc))
- error ("Process %s is not active",
- XSTRING_DATA (XPROCESS(proc)->name));
+ CHECK_LIVE_PROCESS (proc);
MAYBE_PROCMETH (kill_child_process, (proc, signo, current_group, nomsg));
}
name = string_data (XSYMBOL (sigcode)->name);
#define handle_signal(signal) \
- else if (!strcmp ((CONST char *) name, #signal)) \
+ else if (!strcmp ((const char *) name, #signal)) \
XSETINT (sigcode, signal)
if (0)
void
deactivate_process (Lisp_Object proc)
{
- struct Lisp_Process *p = XPROCESS (proc);
+ Lisp_Process *p = XPROCESS (proc);
USID usid;
/* It's possible that we got as far in the process-creation
p->pipe_outstream);
if (usid != USID_DONTHASH)
- remhash ((CONST void*)usid, usid_to_process);
+ remhash ((const void*)usid, usid_to_process);
p->pipe_instream = Qnil;
p->pipe_outstream = Qnil;
(proc))
{
/* This function can GC */
- struct Lisp_Process *p;
+ Lisp_Process *p;
proc = get_process (proc);
p = XPROCESS (proc);
if (network_connection_p (proc))
p->tick++;
process_tick++;
}
- else if (!NILP(p->pipe_instream))
+ else if (PROCESS_LIVE_P (p))
{
Fkill_process (proc, Qnil);
/* Do this now, since remove_process will make sigchld_handler do nothing. */
{
if (network_connection_p (proc))
Fdelete_process (proc);
- else if (!NILP (XPROCESS (proc)->pipe_instream))
+ else if (PROCESS_LIVE_P (XPROCESS (proc)))
process_send_signal (proc, SIGHUP, 0, 1);
}
}
void
syms_of_process (void)
{
+ INIT_LRECORD_IMPLEMENTATION (process);
+
defsymbol (&Qprocessp, "processp");
+ defsymbol (&Qprocess_live_p, "process-live-p");
defsymbol (&Qrun, "run");
defsymbol (&Qstop, "stop");
defsymbol (&Qopen, "open");
#endif
DEFSUBR (Fprocessp);
+ DEFSUBR (Fprocess_live_p);
DEFSUBR (Fget_process);
DEFSUBR (Fget_buffer_process);
DEFSUBR (Fdelete_process);