#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>",
else
{
int netp = network_connection_p (obj);
- write_c_string (((netp) ? GETTEXT ("#<network connection ") :
+ write_c_string ((netp ? GETTEXT ("#<network connection ") :
GETTEXT ("#<process ")), printcharfun);
print_internal (proc->name, printcharfun, 1);
- write_c_string (((netp) ? " " : " pid "), printcharfun);
+ write_c_string ((netp ? " " : " pid "), printcharfun);
print_internal (proc->pid, printcharfun, 1);
write_c_string (" state:", printcharfun);
print_internal (proc->status_symbol, printcharfun, 1);
}
#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
return XPROCESS (proc)->filter;
}
-DEFUN ("process-send-region", Fprocess_send_region, 3, 3, 0, /*
-Send current contents of region as input to PROCESS.
+DEFUN ("process-send-region", Fprocess_send_region, 3, 4, 0, /*
+Send current contents of the region between START and END as input to PROCESS.
PROCESS may be a process name or an actual process.
-Called from program, takes three arguments, PROCESS, START and END.
+BUFFER specifies the buffer to look in; if nil, the current buffer is used.
If the region is more than 500 or so characters long,
it is sent in several bunches. This may happen even for shorter regions.
Output from processes can arrive in between bunches.
*/
- (process, start, end))
+ (process, start, end, buffer))
{
/* This function can GC */
Lisp_Object proc = get_process (process);
Bufpos st, en;
+ struct buffer *buf = decode_buffer (buffer, 0);
- get_buffer_range_char (current_buffer, start, end, &st, &en, 0);
+ XSETBUFFER (buffer, buf);
+ get_buffer_range_char (buf, start, end, &st, &en, 0);
- send_process (proc, Fcurrent_buffer (), 0,
- st, en - st);
+ send_process (proc, buffer, 0, st, en - st);
return Qnil;
}
(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);
projects / chise / xemacs-chise.git- / blobdiff