xemacs-beta: src/process.c comparison

comparison src/process.c @ 412:697ef44129c6 r21-2-14

Import from CVS: tag r21-2-14

author	cvs
date	Mon, 13 Aug 2007 11:20:41 +0200
parents	de805c49cfc1
children	41dbb7a9d5f2

comparison

equal deleted inserted replaced

-:12e008d41344
+:697ef44129c6
 #include "systime.h"
 #include "syssignal.h" /* Always include before systty.h */
 #include "systty.h"
 #include "syswait.h"
-Lisp_Object Qprocessp, Qprocess_live_p;
+Lisp_Object Qprocessp;
 /* Process methods */
 struct process_methods the_process_methods;
 /* a process object is a network connection when its pid field a cons
 /* Valid values of process->status_symbol */
 Lisp_Object Qrun, Qstop;
 /* Qrun => Qopen, Qexit => Qclosed for "network connection" processes */
 Lisp_Object Qopen, Qclosed;
 /* Protocol families */
-Lisp_Object Qtcp, Qudp;
+Lisp_Object Qtcpip;
 #ifdef HAVE_MULTICAST
 Lisp_Object Qmulticast; /* Will be used for occasional warnings */
 #endif
 /* List of process objects. */
 Lisp_Object Vprocess_list;
 extern Lisp_Object Vlisp_EXEC_SUFFIXES;
-Lisp_Object Vnull_device;
 static Lisp_Object
-mark_process (Lisp_Object obj)
+mark_process (Lisp_Object obj, void (*markobj) (Lisp_Object))
 {
-Lisp_Process *proc = XPROCESS (obj);
+struct Lisp_Process *proc = XPROCESS (obj);
-MAYBE_PROCMETH (mark_process_data, (proc));
+MAYBE_PROCMETH (mark_process_data, (proc, markobj));
-mark_object (proc->name);
+markobj (proc->name);
-mark_object (proc->command);
+markobj (proc->command);
-mark_object (proc->filter);
+markobj (proc->filter);
-mark_object (proc->sentinel);
+markobj (proc->sentinel);
-mark_object (proc->buffer);
+markobj (proc->buffer);
-mark_object (proc->mark);
+markobj (proc->mark);
-mark_object (proc->pid);
+markobj (proc->pid);
-mark_object (proc->pipe_instream);
+markobj (proc->pipe_instream);
-mark_object (proc->pipe_outstream);
+markobj (proc->pipe_outstream);
 #ifdef FILE_CODING
-mark_object (proc->coding_instream);
+markobj (proc->coding_instream);
-mark_object (proc->coding_outstream);
+markobj (proc->coding_outstream);
 #endif
 return proc->status_symbol;
 }
 static void
 print_process (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 {
-Lisp_Process *proc = XPROCESS (obj);
+struct Lisp_Process *proc = XPROCESS (obj);
 if (print_readably)
 error ("printing unreadable object #<process %s>",
 XSTRING_DATA (proc->name));
 print_internal (proc->name, printcharfun, 0);
 }
 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);
 MAYBE_PROCMETH (print_process_data, (proc, printcharfun));
 write_c_string (">", printcharfun);
 }
 }
 #ifdef HAVE_WINDOW_SYSTEM
-extern void debug_process_finalization (Lisp_Process *p);
+extern void debug_process_finalization (struct 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 */
-Lisp_Process *p = (Lisp_Process *) header;
+struct Lisp_Process *p = (struct 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, Lisp_Process);
+0, 0, struct 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 (Lisp_Process *p, Lisp_Object *instr, Lisp_Object *outstr)
+get_process_streams (struct Lisp_Process *p,
+		     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;
 }
-Lisp_Process *
+struct 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);
 return XPROCESS (proc);
 }
 else
 return 0;
 }
 int
-get_process_selected_p (Lisp_Process *p)
+get_process_selected_p (struct Lisp_Process *p)
 {
 return p->selected;
 }
 void
-set_process_selected_p (Lisp_Process *p, int selected_p)
+set_process_selected_p (struct Lisp_Process *p, int selected_p)
 {
 p->selected = !!selected_p;
 }
 int
-connected_via_filedesc_p (Lisp_Process *p)
+connected_via_filedesc_p (struct Lisp_Process *p)
 {
 return MAYBE_INT_PROCMETH (tooltalk_connection_p, (p));
 }
 #ifdef HAVE_SOCKETS
 int
 network_connection_p (Lisp_Object process)
 {
-return CONSP (XPROCESS (process)->pid);
+return GC_CONSP (XPROCESS (process)->pid);
 }
 #endif
 DEFUN ("processp", Fprocessp, 1, 1, 0, /*
 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.
 */
 ())
 {
 */
 (name))
 {
 Lisp_Object tail;
-if (PROCESSP (name))
+if (GC_PROCESSP (name))
 return name;
 if (!gc_in_progress)
 /* this only gets called during GC when emacs is going away as a result
 of a signal or crash. */
 CHECK_STRING (name);
-for (tail = Vprocess_list; CONSP (tail); tail = XCDR (tail))
+for (tail = Vprocess_list; GC_CONSP (tail); tail = XCDR (tail))
 {
 Lisp_Object proc = XCAR (tail);
 QUIT;
 if (internal_equal (name, XPROCESS (proc)->name, 0))
 return XCAR (tail);
 */
 (name))
 {
 Lisp_Object buf, tail, proc;
-if (NILP (name)) return Qnil;
+if (GC_NILP (name)) return Qnil;
 buf = Fget_buffer (name);
-if (NILP (buf)) return Qnil;
+if (GC_NILP (buf)) return Qnil;
-for (tail = Vprocess_list; CONSP (tail); tail = XCDR (tail))
+for (tail = Vprocess_list; GC_CONSP (tail); tail = XCDR (tail))
 {
 /* jwz: do not quit here - it isn't necessary, as there is no way for
 	 Vprocess_list to get circular or overwhelmingly long, and this
 	 function is called from layout_mode_element under redisplay. */
 /* QUIT; */
 proc = XCAR (tail);
-if (PROCESSP (proc) && EQ (XPROCESS (proc)->buffer, buf))
+if (GC_PROCESSP (proc) && EQ (XPROCESS (proc)->buffer, buf))
 	return proc;
 }
 return Qnil;
 }
 /* #### Look more closely into translating process names. */
 #endif
 /* This may be called during a GC from process_send_signal() from
 kill_buffer_processes() if emacs decides to abort(). */
-if (PROCESSP (name))
+if (GC_PROCESSP (name))
 return name;
-if (STRINGP (name))
+if (GC_STRINGP (name))
 {
 obj = Fget_process (name);
-if (NILP (obj))
+if (GC_NILP (obj))
 obj = Fget_buffer (name);
-if (NILP (obj))
+if (GC_NILP (obj))
 error ("Process %s does not exist", XSTRING_DATA (name));
 }
-else if (NILP (name))
+else if (GC_NILP (name))
 obj = Fcurrent_buffer ();
 else
 obj = name;
 /* Now obj should be either a buffer object or a process object.
 */
-if (BUFFERP (obj))
+if (GC_BUFFERP (obj))
 {
 proc = Fget_buffer_process (obj);
-if (NILP (proc))
+if (GC_NILP (proc))
 	error ("Buffer %s has no process", XSTRING_DATA (XBUFFER(obj)->name));
 }
 else
 {
 /* #### This was commented out. Although, simple
 Lisp_Object
 make_process_internal (Lisp_Object name)
 {
 Lisp_Object val, name1;
 int i;
-Lisp_Process *p = alloc_lcrecord_type (Lisp_Process, &lrecord_process);
+struct Lisp_Process *p =
+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 (Lisp_Process *p, void* in, void* out, int flags)
+init_process_io_handles (struct 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);
 if (usid != USID_DONTHASH)
 {
 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));
 #ifdef FILE_CODING
 static void
 create_process (Lisp_Object process, Lisp_Object *argv, int nargv,
 		Lisp_Object program, Lisp_Object cur_dir)
 {
-Lisp_Process *p = XPROCESS (process);
+struct 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 (PROCESS_LIVE_P (p))
+if (!NILP(p->pipe_instream))
 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
 connection has no PID; you cannot signal it.  All you can do is
 deactivate and close it via delete-process */
 DEFUN ("open-network-stream-internal", Fopen_network_stream_internal, 4, 5, 0, /*
 Open a TCP connection for a service to a host.
-Return a subprocess-object to represent the connection.
+Returns a subprocess-object to represent the connection.
 Input and output work as for subprocesses; `delete-process' closes it.
 NAME is name for process.  It is modified if necessary to make it unique.
 BUFFER is the buffer (or buffer-name) to associate with the process.
 Process output goes at end of that buffer, unless you specify
 BUFFER may also be nil, meaning that this process is not associated
 with any buffer.
 Third arg is name of the host to connect to, or its IP address.
 Fourth arg SERVICE is name of the service desired, or an integer
 specifying a port number to connect to.
-Fifth argument PROTOCOL is a network protocol.  Currently 'tcp
+Fifth argument FAMILY is a protocol family. When omitted, 'tcp/ip
-(Transmission Control Protocol) and 'udp (User Datagram Protocol) are
+\(Internet protocol family TCP/IP) is assumed.
-supported.  When omitted, 'tcp is assumed.
+*/
+(name, buffer, host, service, family))
-Ouput via `process-send-string' and input via buffer or filter (see
-`set-process-filter') are stream-oriented.  That means UDP datagrams are
-not guaranteed to be sent and received in discrete packets. (But small
-datagrams around 500 bytes that are not truncated by `process-send-string'
-are usually fine.)  Note further that UDP protocol does not guard against
-lost packets.
-*/
-(name, buffer, host, service, protocol))
 {
 /* !!#### This function has not been Mule-ized */
 /* This function can GC */
 Lisp_Object proc = Qnil;
 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, ngcpro1;
 void *inch, *outch;
-GCPRO5 (name, buffer, host, service, protocol);
+GCPRO5 (name, buffer, host, service, family);
 CHECK_STRING (name);
-if (NILP(protocol))
+if (NILP(family))
-protocol = Qtcp;
+family = Qtcpip;
 else
-CHECK_SYMBOL (protocol);
+CHECK_SYMBOL (family);
 /* Since this code is inside HAVE_SOCKETS, existence of
 open_network_stream is mandatory */
-PROCMETH (open_network_stream, (name, host, service, protocol,
+PROCMETH (open_network_stream, (name, host, service, family,
 				  &inch, &outch));
 if (!NILP (buffer))
 buffer = Fget_buffer_create (buffer);
 proc = make_process_internal (name);
 #ifdef HAVE_MULTICAST
 DEFUN ("open-multicast-group-internal", Fopen_multicast_group_internal, 5, 5, 0, /*
 Open a multicast connection on the specified dest/port/ttl.
-Return a subprocess-object to represent the connection.
+Returns a subprocess-object to represent the connection.
 Input and output work as for subprocesses; `delete-process' closes it.
 NAME is name for process.  It is modified if necessary to make it unique.
 BUFFER is the buffer (or buffer-name) to associate with the process.
 Process output goes at end of that buffer, unless you specify
 {
 /* This function can GC */
 Bytecount nbytes, nchars;
 Bufbyte chars[1024];
 Lisp_Object outstream;
-Lisp_Process *p = XPROCESS (proc);
+struct 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 (!PROCESS_LIVE_P (p))
+if (NILP(p->pipe_instream))
 return -1; /* already closed */
 if (!NILP (p->filter) && (p->filter_does_read))
 {
 Lisp_Object filter_result;
 Note that START and LEN are in Bufpos's if RELOCATABLE is a buffer,
 and in Bytecounts otherwise. */
 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 */
 struct gcpro gcpro1, gcpro2;
 Lisp_Object lstream = Qnil;
 signal_simple_error ("Process not open for writing", proc);
 if (nonrelocatable)
 lstream =
 make_fixed_buffer_input_stream (nonrelocatable + start, len);
-else if (BUFFERP (relocatable))
+else if (GC_BUFFERP (relocatable))
 lstream = make_lisp_buffer_input_stream (XBUFFER (relocatable),
 					     start, start + len, 0);
 else
 lstream = make_lisp_string_input_stream (relocatable, start, len);
 void
 set_process_filter (Lisp_Object proc, Lisp_Object filter, int filter_does_read)
 {
 CHECK_PROCESS (proc);
-if (PROCESS_LIVE_P (XPROCESS (proc))) {
+if (PROCESS_LIVE_P (proc)) {
 if (EQ (filter, Qt))
 event_stream_unselect_process (XPROCESS (proc));
 else
 event_stream_select_process (XPROCESS (proc));
 }
 {
 CHECK_PROCESS (proc);
 return XPROCESS (proc)->filter;
 }
-DEFUN ("process-send-region", Fprocess_send_region, 3, 4, 0, /*
+DEFUN ("process-send-region", Fprocess_send_region, 3, 3, 0, /*
-Send current contents of the region between START and END as input to PROCESS.
+Send current contents of region as input to PROCESS.
 PROCESS may be a process name or an actual process.
-BUFFER specifies the buffer to look in; if nil, the current buffer is used.
+Called from program, takes three arguments, PROCESS, START and END.
 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, buffer))
+(process, start, end))
 {
 /* 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;
 }
 DEFUN ("process-send-string", Fprocess_send_string, 2, 4, 0, /*
 Send PROCESS the contents of STRING as input.
 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)
 {
-Lisp_Cons *d = XCONS (datum);
+struct 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 ();
-Lisp_Process *p = XPROCESS (proc);
+struct Lisp_Process *p = XPROCESS (proc);
 Lisp_Object sentinel = p->sentinel;
 if (NILP (sentinel))
 return;
 CHECK_PROCESS (proc);
 return XPROCESS (proc)->sentinel;
 }
-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
 update_process_status (Lisp_Object p,
 		       Lisp_Object status_symbol,
 }
 /* Return a string describing a process status list.  */
 static Lisp_Object
-status_message (Lisp_Process *p)
+status_message (struct 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);
-Lisp_Process *p = XPROCESS (proc);
+struct 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));
-CHECK_LIVE_PROCESS (proc);
+if (!PROCESS_LIVE_P (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, /*
 CHECK_SYMBOL (sigcode);
 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)
 	;
 handle_signal (SIGINT);  /* ANSI */
 /************************************************************************/
 void
 deactivate_process (Lisp_Object proc)
 {
-Lisp_Process *p = XPROCESS (proc);
+struct 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
 else
 usid = event_stream_delete_stream_pair (p->pipe_instream,
 					    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;
 #ifdef FILE_CODING
 p->coding_instream = Qnil;
 PROCESS may be a process or the name of one, or a buffer name.
 */
 (proc))
 {
 /* This function can GC */
-Lisp_Process *p;
+struct 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 (PROCESS_LIVE_P (p))
+else if (!NILP(p->pipe_instream))
 {
 Fkill_process (proc, Qnil);
 /* Do this now, since remove_process will make sigchld_handler do nothing.  */
 p->status_symbol = Qsignal;
 p->exit_code = SIGKILL;
 void
 kill_buffer_processes (Lisp_Object buffer)
 {
 Lisp_Object tail;
-for (tail = Vprocess_list; CONSP (tail);
+for (tail = Vprocess_list; GC_CONSP (tail);
 tail = XCDR (tail))
 {
 Lisp_Object proc = XCAR (tail);
-if (PROCESSP (proc)
+if (GC_PROCESSP (proc)
-	  && (NILP (buffer) || EQ (XPROCESS (proc)->buffer, buffer)))
+	  && (GC_NILP (buffer) || GC_EQ (XPROCESS (proc)->buffer, buffer)))
 	{
 	  if (network_connection_p (proc))
 	    Fdelete_process (proc);
-	  else if (PROCESS_LIVE_P (XPROCESS (proc)))
+	  else if (!NILP (XPROCESS (proc)->pipe_instream))
 	    process_send_signal (proc, SIGHUP, 0, 1);
 	}
 }
 }
 #endif /* 0 */
 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");
 defsymbol (&Qclosed, "closed");
-defsymbol (&Qtcp, "tcp");
+defsymbol (&Qtcpip, "tcp/ip");
-defsymbol (&Qudp, "udp");
 #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);
 nil means don't delete them until `list-processes' is run.
 */ );
 delete_exited_processes = 1;
-DEFVAR_CONST_LISP ("null-device", &Vnull_device /*
-Name of the null device, which differs from system to system.
-The null device is a filename that acts as a sink for arbitrary amounts of
-data, which is discarded, or as a source for a zero-length file.
-It is available on all the systems that we currently support, but with
-different names (typically either `/dev/null' or `nul').
-Note that there is also a /dev/zero on most modern Unix versions (including
-Cygwin), which acts like /dev/null when used as a sink, but as a source
-it sends a non-ending stream of zero bytes.  It's used most often along
-with memory-mapping.  We don't provide a Lisp variable for this because
-the operations needing this are lower level than what ELisp programs
-typically do, and in any case no equivalent exists under native MS Windows.
-*/ );
-Vnull_device = build_string (NULL_DEVICE);
 DEFVAR_LISP ("process-connection-type", &Vprocess_connection_type /*
 Control type of device used to communicate with subprocesses.
 Values are nil to use a pipe, or t or `pty' to use a pty.
 The value has no effect if the system has no ptys or if all ptys are busy:
 then a pipe is used in any case.

Mercurial > hg > xemacs-beta

comparison src/process.c @ 412:697ef44129c6 r21-2-14