xemacs-beta: src/process.c comparison

comparison src/process.c @ 440:8de8e3f6228a r21-2-28

Import from CVS: tag r21-2-28

author	cvs
date	Mon, 13 Aug 2007 11:33:38 +0200
parents	3ecd8885ac67
children	abe6d1db359e

comparison

equal deleted inserted replaced

-:357dd071b03c
+:8de8e3f6228a
 #include "systime.h"
 #include "syssignal.h" /* Always include before systty.h */
 #include "systty.h"
 #include "syswait.h"
-Lisp_Object Qprocessp;
+Lisp_Object Qprocessp, Qprocess_live_p;
 /* Process methods */
 struct process_methods the_process_methods;
 /* a process object is a network connection when its pid field a cons
 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);
 mark_object (proc->filter);
 mark_object (proc->sentinel);
 }
 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>",
 XSTRING_DATA (proc->name));
 write_c_string (">", printcharfun);
 }
 }
 #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
 finalize_process (void *header, int for_disksave)
 {
 /* #### 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)
 {
 debug_process_finalization (p);
 }
 }
 }
 DEFINE_LRECORD_IMPLEMENTATION ("process", process,
 mark_process, print_process, finalize_process,
-0, 0, 0, struct Lisp_Process);
+0, 0, 0, Lisp_Process);
 /************************************************************************/
 /*                       basic process accessors                        */
 /************************************************************************/
 /* Under FILE_CODING, this function returns low-level streams, connected
 directly to the child process, rather than en/decoding FILE_CODING
 streams */
 void
-get_process_streams (struct Lisp_Process *p,
+get_process_streams (Lisp_Process *p, Lisp_Object *instr, Lisp_Object *outstr)
-		     Lisp_Object *instr, Lisp_Object *outstr)
 {
 assert (p);
 assert (NILP (p->pipe_instream) || LSTREAMP(p->pipe_instream));
 assert (NILP (p->pipe_outstream) || LSTREAMP(p->pipe_outstream));
 *instr = p->pipe_instream;
 *outstr = p->pipe_outstream;
 }
-struct Lisp_Process *
+Lisp_Process *
 get_process_from_usid (USID usid)
 {
 CONST void *vval;
 assert (usid != USID_ERROR && usid != USID_DONTHASH);
 else
 return 0;
 }
 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));
 }
 #ifdef HAVE_SOCKETS
 Return t if OBJECT is a process.
 */
 (obj))
 {
 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
 make_process_internal (Lisp_Object name)
 {
 Lisp_Object val, name1;
 int i;
-struct Lisp_Process *p =
+Lisp_Process *p = alloc_lcrecord_type (Lisp_Process, &lrecord_process);
-alloc_lcrecord_type (struct Lisp_Process, &lrecord_process);
 /* If name is already in use, modify it until it is unused.  */
 name1 = name;
 for (i = 1; ; i++)
 {
 Vprocess_list = Fcons (val, Vprocess_list);
 return val;
 }
 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,
 					       flags);
 static void
 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
 is a kind of "fire-and-forget" (no I/O, unwaitable) */
 p->status_symbol = Qrun;
 p->exit_code = 0;
 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);
 }
 /* This function is the unwind_protect form for Fstart_process_internal.  If
 PROC doesn't have its pid set, then we know someone has signalled
 {
 /* This function can GC */
 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
 than once.  If the filter that was executed from one of these
 calls set the filter to t, we have to stop now.  Return -1 rather
 than 0 so execute_internal_event() doesn't close the process.
 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))
 {
 Lisp_Object filter_result;
 void
 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
 event_stream_select_process (XPROCESS (proc));
 }
 Return PROCESS's input coding system.
 */
 (process))
 {
 process = get_process (process);
+CHECK_LIVE_PROCESS (process);
 return decoding_stream_coding_system (XLSTREAM (XPROCESS (process)->coding_instream) );
 }
 DEFUN ("process-output-coding-system", Fprocess_output_coding_system, 1, 1, 0, /*
 Return PROCESS's output coding system.
 */
 (process))
 {
 process = get_process (process);
+CHECK_LIVE_PROCESS (process);
 return encoding_stream_coding_system (XLSTREAM (XPROCESS (process)->coding_outstream));
 }
 DEFUN ("process-coding-system", Fprocess_coding_system, 1, 1, 0, /*
 Return a pair of coding-system for decoding and encoding of PROCESS.
 */
 (process))
 {
 process = get_process (process);
+CHECK_LIVE_PROCESS (process);
 return Fcons (decoding_stream_coding_system
 		(XLSTREAM (XPROCESS (process)->coding_instream)),
 		encoding_stream_coding_system
 		(XLSTREAM (XPROCESS (process)->coding_outstream)));
 }
 */
 (process, codesys))
 {
 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;
 }
 */
 (process, codesys))
 {
 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))
 {
 if (!NILP (decoding))
 Fset_process_input_coding_system (process, decoding);
 /************************************************************************/
 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;
 }
 static void
 exec_sentinel (Lisp_Object proc, Lisp_Object reason)
 {
 /* 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))
 return;
 }
 /* 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;
 int coredump = p->core_dumped;
 Lisp_Object string, string2;
 GCPRO3 (tail, symbol, msg);
 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;
 /* #### extra check for terminated processes, in case a SIGCHLD
 	 got missed (this seems to happen sometimes, I'm not sure why).
 Lisp_Object proc = get_process (process);
 if (network_connection_p (proc))
 error ("Network connection %s is not a subprocess",
 	   XSTRING_DATA (XPROCESS(proc)->name));
-if (!PROCESS_LIVE_P (proc))
+CHECK_LIVE_PROCESS (proc);
-error ("Process %s is not active",
-	   XSTRING_DATA (XPROCESS(proc)->name));
 MAYBE_PROCMETH (kill_child_process, (proc, signo, current_group, nomsg));
 }
 DEFUN ("interrupt-process", Finterrupt_process, 0, 2, 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
 process as creating the descriptors but didn't get so
 far as selecting the process for input.  In this
 PROCESS may be a process or the name of one, or a buffer name.
 */
 (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->status_symbol = Qexit;
 p->exit_code = 0;
 p->core_dumped = 0;
 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.  */
 p->status_symbol = Qsignal;
 p->exit_code = SIGKILL;
 if (PROCESSP (proc)
 	  && (NILP (buffer) || EQ (XPROCESS (proc)->buffer, buffer)))
 	{
 	  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)
 {
 defsymbol (&Qprocessp, "processp");
+defsymbol (&Qprocess_live_p, "process-live-p");
 defsymbol (&Qrun, "run");
 defsymbol (&Qstop, "stop");
 defsymbol (&Qopen, "open");
 defsymbol (&Qclosed, "closed");
 #ifdef HAVE_MULTICAST
 defsymbol(&Qmulticast, "multicast"); /* Used for occasional warnings */
 #endif
 DEFSUBR (Fprocessp);
+DEFSUBR (Fprocess_live_p);
 DEFSUBR (Fget_process);
 DEFSUBR (Fget_buffer_process);
 DEFSUBR (Fdelete_process);
 DEFSUBR (Fprocess_status);
 DEFSUBR (Fprocess_exit_status);

Mercurial > hg > xemacs-beta

comparison src/process.c @ 440:8de8e3f6228a r21-2-28