1 /* Asynchronous subprocess control for XEmacs.
2 Copyright (C) 1985, 1986, 1987, 1988, 1992, 1993, 1994, 1995
3 Free Software Foundation, Inc.
4 Copyright (C) 1995 Sun Microsystems, Inc.
5 Copyright (C) 1995, 1996 Ben Wing.
7 This file is part of XEmacs.
9 XEmacs is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 2, or (at your option) any
14 XEmacs is distributed in the hope that it will be useful, but WITHOUT
15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with XEmacs; see the file COPYING. If not, write to
21 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
24 /* This file has been Mule-ized except for `start-process-internal',
25 `open-network-stream-internal' and `open-multicast-group-internal'. */
27 /* This file has been split into process.c and process-unix.c by
28 Kirill M. Katsnelson <kkm@kis.ru>, so please bash him and not
29 the original author(s) */
33 #if !defined (NO_SUBPROCESSES)
35 /* The entire file is within this conditional */
52 #include "file-coding.h"
58 #include "syssignal.h" /* Always include before systty.h */
62 Lisp_Object Qprocessp;
65 struct process_methods the_process_methods;
67 /* a process object is a network connection when its pid field a cons
68 (name of name of port we are connected to . foreign host name) */
70 /* Valid values of process->status_symbol */
71 Lisp_Object Qrun, Qstop;
72 /* Qrun => Qopen, Qexit => Qclosed for "network connection" processes */
73 Lisp_Object Qopen, Qclosed;
74 /* Protocol families */
78 Lisp_Object Qmulticast; /* Will be used for occasional warnings */
81 /* t means use pty, nil means use a pipe,
82 maybe other values to come. */
83 Lisp_Object Vprocess_connection_type;
85 /* Read comments to DEFVAR of this */
86 int windowed_process_io;
88 #ifdef PROCESS_IO_BLOCKING
89 /* List of port numbers or port names to set a blocking I/O mode.
90 Nil means set a non-blocking I/O mode [default]. */
91 Lisp_Object network_stream_blocking_port_list;
92 #endif /* PROCESS_IO_BLOCKING */
94 /* Number of events of change of status of a process. */
95 volatile int process_tick;
97 /* Number of events for which the user or sentinel has been notified. */
98 static int update_tick;
100 /* Nonzero means delete a process right away if it exits. */
101 int delete_exited_processes;
103 /* Hashtable which maps USIDs as returned by create_stream_pair_cb to
104 process objects. Processes are not GC-protected through this! */
105 c_hashtable usid_to_process;
107 /* List of process objects. */
108 Lisp_Object Vprocess_list;
113 mark_process (Lisp_Object obj, void (*markobj) (Lisp_Object))
115 struct Lisp_Process *proc = XPROCESS (obj);
116 MAYBE_PROCMETH (mark_process_data, (proc, markobj));
117 ((markobj) (proc->name));
118 ((markobj) (proc->command));
119 ((markobj) (proc->filter));
120 ((markobj) (proc->sentinel));
121 ((markobj) (proc->buffer));
122 ((markobj) (proc->mark));
123 ((markobj) (proc->pid));
124 ((markobj) (proc->pipe_instream));
125 ((markobj) (proc->pipe_outstream));
127 ((markobj) (proc->coding_instream));
128 ((markobj) (proc->coding_outstream));
130 return proc->status_symbol;
134 print_process (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
136 struct Lisp_Process *proc = XPROCESS (obj);
139 error ("printing unreadable object #<process %s>",
140 XSTRING_DATA (proc->name));
144 print_internal (proc->name, printcharfun, 0);
148 int netp = network_connection_p (obj);
149 write_c_string (((netp) ? GETTEXT ("#<network connection ") :
150 GETTEXT ("#<process ")), printcharfun);
151 print_internal (proc->name, printcharfun, 1);
152 write_c_string (((netp) ? " " : " pid "), printcharfun);
153 print_internal (proc->pid, printcharfun, 1);
154 write_c_string (" state:", printcharfun);
155 print_internal (proc->status_symbol, printcharfun, 1);
156 MAYBE_PROCMETH (print_process_data, (proc, printcharfun));
157 write_c_string (">", printcharfun);
161 #ifdef HAVE_WINDOW_SYSTEM
162 extern void debug_process_finalization (struct Lisp_Process *p);
163 #endif /* HAVE_WINDOW_SYSTEM */
166 finalize_process (void *header, int for_disksave)
168 /* #### this probably needs to be tied into the tty event loop */
169 /* #### when there is one */
170 struct Lisp_Process *p = (struct Lisp_Process *) header;
171 #ifdef HAVE_WINDOW_SYSTEM
174 debug_process_finalization (p);
176 #endif /* HAVE_WINDOW_SYSTEM */
180 MAYBE_PROCMETH (finalize_process_data, (p, for_disksave));
182 xfree (p->process_data);
186 DEFINE_LRECORD_IMPLEMENTATION ("process", process,
187 mark_process, print_process, finalize_process,
188 0, 0, struct Lisp_Process);
190 /************************************************************************/
191 /* basic process accessors */
192 /************************************************************************/
194 /* Under FILE_CODING, this function returns low-level streams, connected
195 directrly to the child process, rather than en/decoding FILE_CODING
198 get_process_streams (struct Lisp_Process *p,
199 Lisp_Object *instr, Lisp_Object *outstr)
202 assert (NILP (p->pipe_instream) || LSTREAMP(p->pipe_instream));
203 assert (NILP (p->pipe_outstream) || LSTREAMP(p->pipe_outstream));
204 *instr = p->pipe_instream;
205 *outstr = p->pipe_outstream;
208 struct Lisp_Process *
209 get_process_from_usid (USID usid)
213 assert (usid != USID_ERROR && usid != USID_DONTHASH);
215 if (gethash ((CONST void*)usid, usid_to_process, &vval))
218 CVOID_TO_LISP (proc, vval);
219 return XPROCESS (proc);
226 get_process_selected_p (struct Lisp_Process *p)
232 set_process_selected_p (struct Lisp_Process *p, int selected_p)
234 p->selected = !!selected_p;
238 connected_via_filedesc_p (struct Lisp_Process *p)
240 return MAYBE_INT_PROCMETH (tooltalk_connection_p, (p));
245 network_connection_p (Lisp_Object process)
247 return GC_CONSP (XPROCESS (process)->pid);
251 DEFUN ("processp", Fprocessp, 1, 1, 0, /*
252 Return t if OBJECT is a process.
256 return PROCESSP (obj) ? Qt : Qnil;
259 DEFUN ("process-list", Fprocess_list, 0, 0, 0, /*
260 Return a list of all processes.
264 return Fcopy_sequence (Vprocess_list);
267 DEFUN ("get-process", Fget_process, 1, 1, 0, /*
268 Return the process named NAME, or nil if there is none.
274 if (GC_PROCESSP (name))
278 /* this only gets called during GC when emacs is going away as a result
279 of a signal or crash. */
282 for (tail = Vprocess_list; GC_CONSP (tail); tail = XCDR (tail))
284 Lisp_Object proc = XCAR (tail);
286 if (internal_equal (name, XPROCESS (proc)->name, 0))
292 DEFUN ("get-buffer-process", Fget_buffer_process, 1, 1, 0, /*
293 Return the (or, a) process associated with BUFFER.
294 BUFFER may be a buffer or the name of one.
298 Lisp_Object buf, tail, proc;
300 if (GC_NILP (name)) return Qnil;
301 buf = Fget_buffer (name);
302 if (GC_NILP (buf)) return Qnil;
304 for (tail = Vprocess_list; GC_CONSP (tail); tail = XCDR (tail))
306 /* jwz: do not quit here - it isn't necessary, as there is no way for
307 Vprocess_list to get circular or overwhelmingly long, and this
308 function is called from layout_mode_element under redisplay. */
311 if (GC_PROCESSP (proc) && EQ (XPROCESS (proc)->buffer, buf))
317 /* This is how commands for the user decode process arguments. It
318 accepts a process, a process name, a buffer, a buffer name, or nil.
319 Buffers denote the first process in the buffer, and nil denotes the
323 get_process (Lisp_Object name)
325 Lisp_Object proc, obj;
328 /* #### Look more closely into translating process names. */
331 /* This may be called during a GC from process_send_signal() from
332 kill_buffer_processes() if emacs decides to abort(). */
333 if (GC_PROCESSP (name))
336 if (GC_STRINGP (name))
338 obj = Fget_process (name);
340 obj = Fget_buffer (name);
342 error ("Process %s does not exist", XSTRING_DATA (name));
344 else if (GC_NILP (name))
345 obj = Fcurrent_buffer ();
349 /* Now obj should be either a buffer object or a process object.
351 if (GC_BUFFERP (obj))
353 proc = Fget_buffer_process (obj);
355 error ("Buffer %s has no process", XSTRING_DATA (XBUFFER(obj)->name));
359 /* #### This was commented out. Although, simple
360 (kill-process 7 "qqq") resulted in a falat error. - kkm */
367 DEFUN ("process-id", Fprocess_id, 1, 1, 0, /*
368 Return the process id of PROCESS.
369 This is the pid of the Unix process which PROCESS uses or talks to.
370 For a network connection, this value is a cons of
371 (foreign-network-port . foreign-host-name).
376 CHECK_PROCESS (proc);
378 pid = XPROCESS (proc)->pid;
379 if (network_connection_p (proc))
381 return Fcons (Fcar (pid), Fcdr (pid));
386 DEFUN ("process-name", Fprocess_name, 1, 1, 0, /*
387 Return the name of PROCESS, as a string.
388 This is the name of the program invoked in PROCESS,
389 possibly modified to make it unique among process names.
393 CHECK_PROCESS (proc);
394 return XPROCESS (proc)->name;
397 DEFUN ("process-command", Fprocess_command, 1, 1, 0, /*
398 Return the command that was executed to start PROCESS.
399 This is a list of strings, the first string being the program executed
400 and the rest of the strings being the arguments given to it.
404 CHECK_PROCESS (proc);
405 return XPROCESS (proc)->command;
409 /************************************************************************/
410 /* creating a process */
411 /************************************************************************/
414 make_process_internal (Lisp_Object name)
416 Lisp_Object val, name1;
418 struct Lisp_Process *p =
419 alloc_lcrecord_type (struct Lisp_Process, lrecord_process);
421 /* If name is already in use, modify it until it is unused. */
426 Lisp_Object tem = Fget_process (name1);
429 sprintf (suffix, "<%d>", i);
430 name1 = concat2 (name, build_string (suffix));
439 p->mark = Fmake_marker ();
441 p->status_symbol = Qrun;
444 p->filter_does_read = 0;
445 p->kill_without_query = 0;
449 p->pipe_instream = Qnil;
450 p->pipe_outstream = Qnil;
452 p->coding_instream = Qnil;
453 p->coding_outstream = Qnil;
457 MAYBE_PROCMETH (alloc_process_data, (p));
459 XSETPROCESS (val, p);
461 Vprocess_list = Fcons (val, Vprocess_list);
466 init_process_io_handles (struct Lisp_Process *p, void* in, void* out, int flags)
468 USID usid = event_stream_create_stream_pair (in, out,
469 &p->pipe_instream, &p->pipe_outstream,
472 if (usid == USID_ERROR)
473 report_file_error ("Setting up communication with subprocess", Qnil);
475 if (usid != USID_DONTHASH)
477 Lisp_Object proc = Qnil;
478 XSETPROCESS (proc, p);
479 puthash ((CONST void*)usid, LISP_TO_VOID (proc), usid_to_process);
482 MAYBE_PROCMETH (init_process_io_handles, (p, in, out, flags));
485 p->coding_instream = make_decoding_input_stream
486 (XLSTREAM (p->pipe_instream),
487 Fget_coding_system (Vcoding_system_for_read));
488 Lstream_set_character_mode (XLSTREAM (p->coding_instream));
489 p->coding_outstream = make_encoding_output_stream
490 (XLSTREAM (p->pipe_outstream),
491 Fget_coding_system (Vcoding_system_for_write));
492 /* CODE_CNTL (&out_state[outchannel]) |= CC_END; !!####
493 What's going on here? */
494 #endif /* FILE_CODING */
498 create_process (Lisp_Object process, Lisp_Object *argv, int nargv,
499 Lisp_Object program, Lisp_Object cur_dir)
501 struct Lisp_Process *p = XPROCESS (process);
504 /* *_create_process may change status_symbol, if the process
505 is a kind of "fire-and-forget" (no I/O, unwaitable) */
506 p->status_symbol = Qrun;
509 pid = PROCMETH (create_process, (p, argv, nargv, program, cur_dir));
511 p->pid = make_int (pid);
512 if (!NILP(p->pipe_instream))
513 event_stream_select_process (p);
516 /* This function is the unwind_protect form for Fstart_process_internal. If
517 PROC doesn't have its pid set, then we know someone has signalled
518 an error and the process wasn't started successfully, so we should
519 remove it from the process list. */
520 static void remove_process (Lisp_Object proc);
522 start_process_unwind (Lisp_Object proc)
524 /* Was PROC started successfully? */
525 if (EQ (XPROCESS (proc)->pid, Qnil))
526 remove_process (proc);
530 DEFUN ("start-process-internal", Fstart_process_internal, 3, MANY, 0, /*
531 Start a program in a subprocess. Return the process object for it.
532 Args are NAME BUFFER PROGRAM &rest PROGRAM-ARGS
533 NAME is name for process. It is modified if necessary to make it unique.
534 BUFFER is the buffer or (buffer-name) to associate with the process.
535 Process output goes at end of that buffer, unless you specify
536 an output stream or filter function to handle the output.
537 BUFFER may be also nil, meaning that this process is not associated
539 Third arg is program file name. It is searched for as in the shell.
540 Remaining arguments are strings to give program as arguments.
541 INCODE and OUTCODE specify the coding-system objects used in input/output
544 (int nargs, Lisp_Object *args))
546 /* This function can call lisp */
547 /* !!#### This function has not been Mule-ized */
548 Lisp_Object buffer, name, program, proc, current_dir;
550 int speccount = specpdl_depth ();
551 struct gcpro gcpro1, gcpro2, gcpro3;
558 /* Protect against various file handlers doing GCs below. */
559 GCPRO3 (buffer, program, current_dir);
562 buffer = Fget_buffer_create (buffer);
565 CHECK_STRING (program);
567 /* Make sure that the child will be able to chdir to the current
568 buffer's current directory, or its unhandled equivalent. We
569 can't just have the child check for an error when it does the
570 chdir, since it's in a vfork.
572 Note: these assignments and calls are like this in order to insure
573 "caller protects args" GC semantics. */
574 current_dir = current_buffer->directory;
575 current_dir = Funhandled_file_name_directory (current_dir);
576 current_dir = expand_and_dir_to_file (current_dir, Qnil);
578 #if 0 /* This loser breaks ange-ftp */
579 /* dmoore - if you re-enable this code, you have to gcprotect
580 current_buffer through the above calls. */
581 if (NILP (Ffile_accessible_directory_p (current_dir)))
582 report_file_error ("Setting current directory",
583 list1 (current_buffer->directory));
586 /* If program file name is not absolute, search our path for it */
587 if (!IS_DIRECTORY_SEP (XSTRING_BYTE (program, 0))
588 && !(XSTRING_LENGTH (program) > 1
589 && IS_DEVICE_SEP (XSTRING_BYTE (program, 1))))
591 struct gcpro ngcpro1;
595 locate_file (Vexec_path, program, EXEC_SUFFIXES, &tem,
598 report_file_error ("Searching for program", list1 (program));
599 program = Fexpand_file_name (tem, Qnil);
604 if (!NILP (Ffile_directory_p (program)))
605 error ("Specified program for new process is a directory");
608 proc = make_process_internal (name);
610 XPROCESS (proc)->buffer = buffer;
611 XPROCESS (proc)->command = Flist (nargs - 2,
614 /* Make the process marker point into the process buffer (if any). */
616 Fset_marker (XPROCESS (proc)->mark,
617 make_int (BUF_ZV (XBUFFER (buffer))), buffer);
619 /* If an error occurs and we can't start the process, we want to
620 remove it from the process list. This means that each error
621 check in create_process doesn't need to call remove_process
622 itself; it's all taken care of here. */
623 record_unwind_protect (start_process_unwind, proc);
625 create_process (proc, args + 3, nargs - 3, program, current_dir);
628 return unbind_to (speccount, proc);
635 /* #### The network support is fairly synthetical. What we actually
636 need is a single function, which supports all datagram, stream and
637 packet stream connections, arbitrary protocol families should they
638 be supported by the target system, multicast groups, in both data
639 and control rooted/nonrooted flavors, service quality etc whatever
640 is supported by the underlying network.
642 It must accept a property list describing the connection. The current
643 functions must then go to lisp and provide a suitable list for the
644 generalized connection function.
646 Both UNIX ans Win32 support BSD sockets, and there are many extensions
647 availalble (Sockets 2 spec).
649 A todo is define a consistent set of properties abstracting a
650 network connection. -kkm
654 /* open a TCP network connection to a given HOST/SERVICE. Treated
655 exactly like a normal process when reading and writing. Only
656 differences are in status display and process deletion. A network
657 connection has no PID; you cannot signal it. All you can do is
658 deactivate and close it via delete-process */
660 DEFUN ("open-network-stream-internal", Fopen_network_stream_internal, 4, 5, 0, /*
661 Open a TCP connection for a service to a host.
662 Returns a subprocess-object to represent the connection.
663 Input and output work as for subprocesses; `delete-process' closes it.
665 NAME is name for process. It is modified if necessary to make it unique.
666 BUFFER is the buffer (or buffer-name) to associate with the process.
667 Process output goes at end of that buffer, unless you specify
668 an output stream or filter function to handle the output.
669 BUFFER may also be nil, meaning that this process is not associated
671 Third arg is name of the host to connect to, or its IP address.
672 Fourth arg SERVICE is name of the service desired, or an integer
673 specifying a port number to connect to.
674 Fifth argument FAMILY is a protocol family. When omitted, 'tcp/ip
675 \(Internet protocol family TCP/IP) is assumed.
677 (name, buffer, host, service, family))
679 /* !!#### This function has not been Mule-ized */
680 /* This function can GC */
681 Lisp_Object proc = Qnil;
682 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, ngcpro1;
685 GCPRO5 (name, buffer, host, service, family);
691 CHECK_SYMBOL (family);
693 /* Since this code is inside HAVE_SOCKETS, existence of
694 open_network_stream is mandatory */
695 PROCMETH (open_network_stream, (name, host, service, family,
699 buffer = Fget_buffer_create (buffer);
700 proc = make_process_internal (name);
703 XPROCESS (proc)->pid = Fcons (service, host);
704 XPROCESS (proc)->buffer = buffer;
705 init_process_io_handles (XPROCESS (proc), (void*)inch, (void*)outch,
706 STREAM_NETWORK_CONNECTION);
708 event_stream_select_process (XPROCESS (proc));
715 #ifdef HAVE_MULTICAST
717 DEFUN ("open-multicast-group-internal", Fopen_multicast_group_internal, 5, 5, 0, /*
718 Open a multicast connection on the specified dest/port/ttl.
719 Returns a subprocess-object to represent the connection.
720 Input and output work as for subprocesses; `delete-process' closes it.
722 NAME is name for process. It is modified if necessary to make it unique.
723 BUFFER is the buffer (or buffer-name) to associate with the process.
724 Process output goes at end of that buffer, unless you specify
725 an output stream or filter function to handle the output.
726 BUFFER may also be nil, meaning that this process is not associated
728 Third, fourth and fifth args are the multicast destination group, port and ttl.
729 dest must be an internet address between 224.0.0.0 and 239.255.255.255
730 port is a communication port like in traditional unicast
731 ttl is the time-to-live (15 for site, 63 for region and 127 for world)
733 (name, buffer, dest, port, ttl))
735 /* !!#### This function has not been Mule-ized */
736 /* This function can GC */
737 Lisp_Object proc = Qnil;
743 /* Since this code is inside HAVE_MULTICAST, existence of
744 open_network_stream is mandatory */
745 PROCMETH (open_multicast_group, (name, dest, port, ttl,
749 buffer = Fget_buffer_create (buffer);
751 proc = make_process_internal (name);
754 XPROCESS (proc)->pid = Fcons (port, dest);
755 XPROCESS (proc)->buffer = buffer;
756 init_process_io_handles (XPROCESS (proc), (void*)inch, (void*)outch,
757 STREAM_NETWORK_CONNECTION);
759 event_stream_select_process (XPROCESS (proc));
764 #endif /* HAVE_MULTICAST */
766 #endif /* HAVE_SOCKETS */
769 canonicalize_host_name (Lisp_Object host)
771 return PROCMETH_OR_GIVEN (canonicalize_host_name, (host), host);
775 DEFUN ("set-process-window-size", Fset_process_window_size, 3, 3, 0, /*
776 Tell PROCESS that it has logical window size HEIGHT and WIDTH.
778 (proc, height, width))
780 CHECK_PROCESS (proc);
781 CHECK_NATNUM (height);
782 CHECK_NATNUM (width);
784 MAYBE_INT_PROCMETH (set_window_size, (XPROCESS (proc), XINT (height), XINT (width))) <= 0
789 /************************************************************************/
791 /************************************************************************/
793 /* Read pending output from the process channel,
794 starting with our buffered-ahead character if we have one.
795 Yield number of characters read.
797 This function reads at most 1024 bytes.
798 If you want to read all available subprocess output,
799 you must call it repeatedly until it returns zero. */
802 read_process_output (Lisp_Object proc)
804 /* This function can GC */
805 Bytecount nbytes, nchars;
807 Lisp_Object outstream;
808 struct Lisp_Process *p = XPROCESS (proc);
810 /* If there is a lot of output from the subprocess, the loop in
811 execute_internal_event() might call read_process_output() more
812 than once. If the filter that was executed from one of these
813 calls set the filter to t, we have to stop now. Return -1 rather
814 than 0 so execute_internal_event() doesn't close the process.
815 Really, the loop in execute_internal_event() should check itself
816 for a process-filter change, like in status_notify(); but the
817 struct Lisp_Process is not exported outside of this file. */
818 if (NILP(p->pipe_instream))
819 return -1; /* already closed */
821 if (!NILP (p->filter) && (p->filter_does_read))
823 Lisp_Object filter_result;
825 /* Some weird FSFmacs crap here with
826 Vdeactivate_mark and current_buffer->keymap */
827 running_asynch_code = 1;
828 filter_result = call2_trapping_errors ("Error in process filter",
829 p->filter, proc, Qnil);
830 running_asynch_code = 0;
831 restore_match_data ();
832 CHECK_INT (filter_result);
833 return XINT (filter_result);
836 nbytes = Lstream_read (XLSTREAM (DATA_INSTREAM(p)), chars, sizeof (chars));
837 if (nbytes <= 0) return nbytes;
839 nchars = bytecount_to_charcount (chars, nbytes);
840 outstream = p->filter;
841 if (!NILP (outstream))
843 /* We used to bind inhibit-quit to t here, but
844 call2_trapping_errors() does that for us. */
845 running_asynch_code = 1;
846 call2_trapping_errors ("Error in process filter",
847 outstream, proc, make_string (chars, nbytes));
848 running_asynch_code = 0;
849 restore_match_data ();
853 /* If no filter, write into buffer if it isn't dead. */
854 if (!NILP (p->buffer) && BUFFER_LIVE_P (XBUFFER (p->buffer)))
856 Lisp_Object old_read_only = Qnil;
860 int old_zmacs_region_stays = zmacs_region_stays;
861 struct gcpro gcpro1, gcpro2;
862 struct buffer *buf = XBUFFER (p->buffer);
864 GCPRO2 (proc, old_read_only);
866 old_point = BUF_PT (buf);
867 old_begv = BUF_BEGV (buf);
868 old_zv = BUF_ZV (buf);
869 old_read_only = buf->read_only;
870 buf->read_only = Qnil;
872 /* Insert new output into buffer
873 at the current end-of-output marker,
874 thus preserving logical ordering of input and output. */
875 if (XMARKER (p->mark)->buffer)
877 bufpos_clip_to_bounds (old_begv, marker_position (p->mark),
880 BUF_SET_PT (buf, old_zv);
882 /* If the output marker is outside of the visible region, save
883 the restriction and widen. */
884 if (! (BUF_BEGV (buf) <= BUF_PT (buf) &&
885 BUF_PT (buf) <= BUF_ZV (buf)))
888 /* Make sure opoint floats ahead of any new text, just as point
890 if (BUF_PT (buf) <= old_point)
893 /* Insert after old_begv, but before old_zv. */
894 if (BUF_PT (buf) < old_begv)
896 if (BUF_PT (buf) <= old_zv)
900 /* This screws up intial display of the window. jla */
902 /* Insert before markers in case we are inserting where
903 the buffer's mark is, and the user's next command is Meta-y. */
904 buffer_insert_raw_string_1 (buf, -1, chars,
905 nbytes, INSDEL_BEFORE_MARKERS);
907 buffer_insert_raw_string (buf, chars, nbytes);
910 Fset_marker (p->mark, make_int (BUF_PT (buf)), p->buffer);
912 MARK_MODELINE_CHANGED;
914 /* If the restriction isn't what it should be, set it. */
915 if (old_begv != BUF_BEGV (buf) || old_zv != BUF_ZV (buf))
918 old_begv = bufpos_clip_to_bounds (BUF_BEG (buf),
921 old_zv = bufpos_clip_to_bounds (BUF_BEG (buf),
924 Fnarrow_to_region (make_int (old_begv), make_int (old_zv),
928 /* Handling the process output should not deactivate the mark. */
929 zmacs_region_stays = old_zmacs_region_stays;
930 buf->read_only = old_read_only;
931 old_point = bufpos_clip_to_bounds (BUF_BEGV (buf),
934 BUF_SET_PT (buf, old_point);
941 /* Sending data to subprocess */
943 /* send some data to process PROC. If NONRELOCATABLE is non-NULL, it
944 specifies the address of the data. Otherwise, the data comes from the
945 object RELOCATABLE (either a string or a buffer). START and LEN
946 specify the offset and length of the data to send.
948 Note that START and LEN are in Bufpos's if RELOCATABLE is a buffer,
949 and in Bytecounts otherwise. */
952 send_process (Lisp_Object proc,
953 Lisp_Object relocatable, CONST Bufbyte *nonrelocatable,
956 /* This function can GC */
957 struct gcpro gcpro1, gcpro2;
958 Lisp_Object lstream = Qnil;
960 GCPRO2 (proc, lstream);
962 if (NILP (DATA_OUTSTREAM (XPROCESS (proc))))
963 signal_simple_error ("Process not open for writing", proc);
967 make_fixed_buffer_input_stream (nonrelocatable + start, len);
968 else if (GC_BUFFERP (relocatable))
969 lstream = make_lisp_buffer_input_stream (XBUFFER (relocatable),
970 start, start + len, 0);
972 lstream = make_lisp_string_input_stream (relocatable, start, len);
974 PROCMETH (send_process, (proc, XLSTREAM (lstream)));
977 Lstream_delete (XLSTREAM (lstream));
980 DEFUN ("process-tty-name", Fprocess_tty_name, 1, 1, 0, /*
981 Return the name of the terminal PROCESS uses, or nil if none.
982 This is the terminal that the process itself reads and writes on,
983 not the name of the pty that Emacs uses to talk with that terminal.
987 CHECK_PROCESS (proc);
988 return MAYBE_LISP_PROCMETH (get_tty_name, (XPROCESS (proc)));
991 DEFUN ("set-process-buffer", Fset_process_buffer, 2, 2, 0, /*
992 Set buffer associated with PROCESS to BUFFER (a buffer, or nil).
996 CHECK_PROCESS (proc);
998 CHECK_BUFFER (buffer);
999 XPROCESS (proc)->buffer = buffer;
1003 DEFUN ("process-buffer", Fprocess_buffer, 1, 1, 0, /*
1004 Return the buffer PROCESS is associated with.
1005 Output from PROCESS is inserted in this buffer
1006 unless PROCESS has a filter.
1010 CHECK_PROCESS (proc);
1011 return XPROCESS (proc)->buffer;
1014 DEFUN ("process-mark", Fprocess_mark, 1, 1, 0, /*
1015 Return the marker for the end of the last output from PROCESS.
1019 CHECK_PROCESS (proc);
1020 return XPROCESS (proc)->mark;
1024 set_process_filter (Lisp_Object proc, Lisp_Object filter, int filter_does_read)
1026 CHECK_PROCESS (proc);
1027 if (PROCESS_LIVE_P (proc)) {
1028 if (EQ (filter, Qt))
1029 event_stream_unselect_process (XPROCESS (proc));
1031 event_stream_select_process (XPROCESS (proc));
1034 XPROCESS (proc)->filter = filter;
1035 XPROCESS (proc)->filter_does_read = filter_does_read;
1038 DEFUN ("set-process-filter", Fset_process_filter, 2, 2, 0, /*
1039 Give PROCESS the filter function FILTER; nil means no filter.
1040 t means stop accepting output from the process.
1041 When a process has a filter, each time it does output
1042 the entire string of output is passed to the filter.
1043 The filter gets two arguments: the process and the string of output.
1044 If the process has a filter, its buffer is not used for output.
1048 set_process_filter (proc, filter, 0);
1052 DEFUN ("process-filter", Fprocess_filter, 1, 1, 0, /*
1053 Return the filter function of PROCESS; nil if none.
1054 See `set-process-filter' for more info on filter functions.
1058 CHECK_PROCESS (proc);
1059 return XPROCESS (proc)->filter;
1062 DEFUN ("process-send-region", Fprocess_send_region, 3, 3, 0, /*
1063 Send current contents of region as input to PROCESS.
1064 PROCESS may be a process name or an actual process.
1065 Called from program, takes three arguments, PROCESS, START and END.
1066 If the region is more than 500 or so characters long,
1067 it is sent in several bunches. This may happen even for shorter regions.
1068 Output from processes can arrive in between bunches.
1070 (process, start, end))
1072 /* This function can GC */
1073 Lisp_Object proc = get_process (process);
1076 get_buffer_range_char (current_buffer, start, end, &st, &en, 0);
1078 send_process (proc, Fcurrent_buffer (), 0,
1083 DEFUN ("process-send-string", Fprocess_send_string, 2, 4, 0, /*
1084 Send PROCESS the contents of STRING as input.
1085 PROCESS may be a process name or an actual process.
1086 Optional arguments FROM and TO specify part of STRING, see `substring'.
1087 If STRING is more than 500 or so characters long,
1088 it is sent in several bunches. This may happen even for shorter strings.
1089 Output from processes can arrive in between bunches.
1091 (process, string, from, to))
1093 /* This function can GC */
1098 proc = get_process (process);
1099 CHECK_STRING (string);
1100 get_string_range_byte (string, from, to, &bfr, &bto,
1101 GB_HISTORICAL_STRING_BEHAVIOR);
1104 send_process (proc, string, 0, bfr, len);
1110 DEFUN ("process-input-coding-system", Fprocess_input_coding_system, 1, 1, 0, /*
1111 Return PROCESS's input coding system.
1115 process = get_process (process);
1116 return decoding_stream_coding_system (XLSTREAM (XPROCESS (process)->coding_instream) );
1119 DEFUN ("process-output-coding-system", Fprocess_output_coding_system, 1, 1, 0, /*
1120 Return PROCESS's output coding system.
1124 process = get_process (process);
1125 return encoding_stream_coding_system (XLSTREAM (XPROCESS (process)->coding_outstream));
1128 DEFUN ("process-coding-system", Fprocess_coding_system, 1, 1, 0, /*
1129 Return a pair of coding-system for decoding and encoding of PROCESS.
1133 process = get_process (process);
1134 return Fcons (decoding_stream_coding_system
1135 (XLSTREAM (XPROCESS (process)->coding_instream)),
1136 encoding_stream_coding_system
1137 (XLSTREAM (XPROCESS (process)->coding_outstream)));
1140 DEFUN ("set-process-input-coding-system", Fset_process_input_coding_system,
1142 Set PROCESS's input coding system to CODESYS.
1146 codesys = Fget_coding_system (codesys);
1147 process = get_process (process);
1148 set_decoding_stream_coding_system
1149 (XLSTREAM (XPROCESS (process)->coding_instream), codesys);
1153 DEFUN ("set-process-output-coding-system", Fset_process_output_coding_system,
1155 Set PROCESS's output coding system to CODESYS.
1159 codesys = Fget_coding_system (codesys);
1160 process = get_process (process);
1161 set_encoding_stream_coding_system
1162 (XLSTREAM (XPROCESS (process)->coding_outstream), codesys);
1166 DEFUN ("set-process-coding-system", Fset_process_coding_system,
1168 Set coding-systems of PROCESS to DECODING and ENCODING.
1170 (process, decoding, encoding))
1172 if (!NILP (decoding))
1173 Fset_process_input_coding_system (process, decoding);
1175 if (!NILP (encoding))
1176 Fset_process_output_coding_system (process, encoding);
1181 #endif /* FILE_CODING */
1183 /************************************************************************/
1184 /* process status */
1185 /************************************************************************/
1188 exec_sentinel_unwind (Lisp_Object datum)
1190 struct Lisp_Cons *d = XCONS (datum);
1191 XPROCESS (d->car)->sentinel = d->cdr;
1197 exec_sentinel (Lisp_Object proc, Lisp_Object reason)
1199 /* This function can GC */
1200 int speccount = specpdl_depth ();
1201 struct Lisp_Process *p = XPROCESS (proc);
1202 Lisp_Object sentinel = p->sentinel;
1204 if (NILP (sentinel))
1207 /* Some weird FSFmacs crap here with
1208 Vdeactivate_mark and current_buffer->keymap */
1210 /* Zilch the sentinel while it's running, to avoid recursive invocations;
1211 assure that it gets restored no matter how the sentinel exits. */
1213 record_unwind_protect (exec_sentinel_unwind, noseeum_cons (proc, sentinel));
1214 /* We used to bind inhibit-quit to t here, but call2_trapping_errors()
1215 does that for us. */
1216 running_asynch_code = 1;
1217 call2_trapping_errors ("Error in process sentinel", sentinel, proc, reason);
1218 running_asynch_code = 0;
1219 restore_match_data ();
1220 unbind_to (speccount, Qnil);
1223 DEFUN ("set-process-sentinel", Fset_process_sentinel, 2, 2, 0, /*
1224 Give PROCESS the sentinel SENTINEL; nil for none.
1225 The sentinel is called as a function when the process changes state.
1226 It gets two arguments: the process, and a string describing the change.
1230 CHECK_PROCESS (proc);
1231 XPROCESS (proc)->sentinel = sentinel;
1235 DEFUN ("process-sentinel", Fprocess_sentinel, 1, 1, 0, /*
1236 Return the sentinel of PROCESS; nil if none.
1237 See `set-process-sentinel' for more info on sentinels.
1241 CHECK_PROCESS (proc);
1242 return XPROCESS (proc)->sentinel;
1247 signal_name (int signum)
1249 if (signum >= 0 && signum < NSIG)
1250 return (CONST char *) sys_siglist[signum];
1252 return (CONST char *) GETTEXT ("unknown signal");
1256 update_process_status (Lisp_Object p,
1257 Lisp_Object status_symbol,
1261 XPROCESS (p)->tick++;
1263 XPROCESS (p)->status_symbol = status_symbol;
1264 XPROCESS (p)->exit_code = exit_code;
1265 XPROCESS (p)->core_dumped = core_dumped;
1268 /* Return a string describing a process status list. */
1271 status_message (struct Lisp_Process *p)
1273 Lisp_Object symbol = p->status_symbol;
1274 int code = p->exit_code;
1275 int coredump = p->core_dumped;
1276 Lisp_Object string, string2;
1278 if (EQ (symbol, Qsignal) || EQ (symbol, Qstop))
1280 string = build_string (signal_name (code));
1282 string2 = build_translated_string (" (core dumped)\n");
1284 string2 = build_string ("\n");
1285 set_string_char (XSTRING (string), 0,
1286 DOWNCASE (current_buffer,
1287 string_char (XSTRING (string), 0)));
1288 return concat2 (string, string2);
1290 else if (EQ (symbol, Qexit))
1293 return build_translated_string ("finished\n");
1294 string = Fnumber_to_string (make_int (code));
1296 string2 = build_translated_string (" (core dumped)\n");
1298 string2 = build_string ("\n");
1299 return concat2 (build_translated_string ("exited abnormally with code "),
1300 concat2 (string, string2));
1303 return Fcopy_sequence (Fsymbol_name (symbol));
1306 /* Tell status_notify() to check for terminated processes. We do this
1307 because on some systems we sometimes miss SIGCHLD calls. (Not sure
1311 kick_status_notify (void)
1317 /* Report all recent events of a change in process status
1318 (either run the sentinel or output a message).
1319 This is done while Emacs is waiting for keyboard input. */
1322 status_notify (void)
1324 /* This function can GC */
1325 Lisp_Object tail = Qnil;
1326 Lisp_Object symbol = Qnil;
1327 Lisp_Object msg = Qnil;
1328 struct gcpro gcpro1, gcpro2, gcpro3;
1329 /* process_tick is volatile, so we have to remember it now.
1330 Otherwise, we get a race condition is SIGCHLD happens during
1333 (Actually, this is not the case anymore. The code to
1334 update the process structures has been moved out of the
1335 SIGCHLD handler. But for the moment I'm leaving this
1336 stuff in -- it can't hurt.) */
1337 int temp_process_tick;
1339 MAYBE_PROCMETH (reap_exited_processes, ());
1341 temp_process_tick = process_tick;
1343 if (update_tick == temp_process_tick)
1346 /* We need to gcpro tail; if read_process_output calls a filter
1347 which deletes a process and removes the cons to which tail points
1348 from Vprocess_alist, and then causes a GC, tail is an unprotected
1350 GCPRO3 (tail, symbol, msg);
1352 for (tail = Vprocess_list; CONSP (tail); tail = XCDR (tail))
1354 Lisp_Object proc = XCAR (tail);
1355 struct Lisp_Process *p = XPROCESS (proc);
1356 /* p->tick is also volatile. Same thing as above applies. */
1357 int this_process_tick;
1359 /* #### extra check for terminated processes, in case a SIGCHLD
1360 got missed (this seems to happen sometimes, I'm not sure why).
1363 MAYBE_PROCMETH (update_status_if_terminated, (p));
1365 this_process_tick = p->tick;
1366 if (this_process_tick != p->update_tick)
1368 p->update_tick = this_process_tick;
1370 /* If process is still active, read any output that remains. */
1371 while (!EQ (p->filter, Qt)
1372 && read_process_output (proc) > 0)
1375 /* Get the text to use for the message. */
1376 msg = status_message (p);
1378 /* If process is terminated, deactivate it or delete it. */
1379 symbol = p->status_symbol;
1381 if (EQ (symbol, Qsignal)
1382 || EQ (symbol, Qexit))
1384 if (delete_exited_processes)
1385 remove_process (proc);
1387 deactivate_process (proc);
1390 /* Now output the message suitably. */
1391 if (!NILP (p->sentinel))
1392 exec_sentinel (proc, msg);
1393 /* Don't bother with a message in the buffer
1394 when a process becomes runnable. */
1395 else if (!EQ (symbol, Qrun) && !NILP (p->buffer))
1397 Lisp_Object old_read_only = Qnil;
1398 Lisp_Object old = Fcurrent_buffer ();
1400 struct gcpro ngcpro1, ngcpro2;
1402 /* Avoid error if buffer is deleted
1403 (probably that's why the process is dead, too) */
1404 if (!BUFFER_LIVE_P (XBUFFER (p->buffer)))
1407 NGCPRO2 (old, old_read_only);
1408 Fset_buffer (p->buffer);
1409 opoint = BUF_PT (current_buffer);
1410 /* Insert new output into buffer
1411 at the current end-of-output marker,
1412 thus preserving logical ordering of input and output. */
1413 if (XMARKER (p->mark)->buffer)
1414 BUF_SET_PT (current_buffer, marker_position (p->mark));
1416 BUF_SET_PT (current_buffer, BUF_ZV (current_buffer));
1417 if (BUF_PT (current_buffer) <= opoint)
1418 opoint += (string_char_length (XSTRING (msg))
1419 + string_char_length (XSTRING (p->name))
1422 old_read_only = current_buffer->read_only;
1423 current_buffer->read_only = Qnil;
1424 buffer_insert_c_string (current_buffer, "\nProcess ");
1425 Finsert (1, &p->name);
1426 buffer_insert_c_string (current_buffer, " ");
1428 current_buffer->read_only = old_read_only;
1429 Fset_marker (p->mark, make_int (BUF_PT (current_buffer)),
1432 opoint = bufpos_clip_to_bounds(BUF_BEGV (XBUFFER (p->buffer)),
1434 BUF_ZV (XBUFFER (p->buffer)));
1435 BUF_SET_PT (current_buffer, opoint);
1442 /* in case buffers use %s in modeline-format */
1443 MARK_MODELINE_CHANGED;
1446 update_tick = temp_process_tick;
1451 DEFUN ("process-status", Fprocess_status, 1, 1, 0, /*
1452 Return the status of PROCESS.
1453 This is a symbol, one of these:
1455 run -- for a process that is running.
1456 stop -- for a process stopped but continuable.
1457 exit -- for a process that has exited.
1458 signal -- for a process that has got a fatal signal.
1459 open -- for a network stream connection that is open.
1460 closed -- for a network stream connection that is closed.
1461 nil -- if arg is a process name and no such process exists.
1463 PROCESS may be a process, a buffer, the name of a process or buffer, or
1464 nil, indicating the current buffer's process.
1468 Lisp_Object status_symbol;
1471 proc = Fget_process (proc);
1473 proc = get_process (proc);
1478 status_symbol = XPROCESS (proc)->status_symbol;
1479 if (network_connection_p (proc))
1481 if (EQ (status_symbol, Qrun))
1482 status_symbol = Qopen;
1483 else if (EQ (status_symbol, Qexit))
1484 status_symbol = Qclosed;
1486 return status_symbol;
1489 DEFUN ("process-exit-status", Fprocess_exit_status, 1, 1, 0, /*
1490 Return the exit status of PROCESS or the signal number that killed it.
1491 If PROCESS has not yet exited or died, return 0.
1495 CHECK_PROCESS (proc);
1496 return make_int (XPROCESS (proc)->exit_code);
1501 /* send a signal number SIGNO to PROCESS.
1502 CURRENT_GROUP means send to the process group that currently owns
1503 the terminal being used to communicate with PROCESS.
1504 This is used for various commands in shell mode.
1505 If NOMSG is zero, insert signal-announcements into process's buffers
1508 If we can, we try to signal PROCESS by sending control characters
1509 down the pty. This allows us to signal inferiors who have changed
1510 their uid, for which killpg would return an EPERM error. */
1513 process_send_signal (Lisp_Object process, int signo,
1514 int current_group, int nomsg)
1516 /* This function can GC */
1517 Lisp_Object proc = get_process (process);
1519 if (network_connection_p (proc))
1520 error ("Network connection %s is not a subprocess",
1521 XSTRING_DATA (XPROCESS(proc)->name));
1522 if (!PROCESS_LIVE_P (proc))
1523 error ("Process %s is not active",
1524 XSTRING_DATA (XPROCESS(proc)->name));
1526 MAYBE_PROCMETH (kill_child_process, (proc, signo, current_group, nomsg));
1529 DEFUN ("interrupt-process", Finterrupt_process, 0, 2, 0, /*
1530 Interrupt process PROCESS. May be process or name of one.
1531 Nil or no arg means current buffer's process.
1532 Second arg CURRENT-GROUP non-nil means send signal to
1533 the current process-group of the process's controlling terminal
1534 rather than to the process's own process group.
1535 If the process is a shell, this means interrupt current subjob
1536 rather than the shell.
1538 (process, current_group))
1540 /* This function can GC */
1541 process_send_signal (process, SIGINT, !NILP (current_group), 0);
1545 DEFUN ("kill-process", Fkill_process, 0, 2, 0, /*
1546 Kill process PROCESS. May be process or name of one.
1547 See function `interrupt-process' for more details on usage.
1549 (process, current_group))
1551 /* This function can GC */
1553 process_send_signal (process, SIGKILL, !NILP (current_group), 0);
1555 error ("kill-process: Not supported on this system");
1560 DEFUN ("quit-process", Fquit_process, 0, 2, 0, /*
1561 Send QUIT signal to process PROCESS. May be process or name of one.
1562 See function `interrupt-process' for more details on usage.
1564 (process, current_group))
1566 /* This function can GC */
1568 process_send_signal (process, SIGQUIT, !NILP (current_group), 0);
1570 error ("quit-process: Not supported on this system");
1575 DEFUN ("stop-process", Fstop_process, 0, 2, 0, /*
1576 Stop process PROCESS. May be process or name of one.
1577 See function `interrupt-process' for more details on usage.
1579 (process, current_group))
1581 /* This function can GC */
1583 process_send_signal (process, SIGTSTP, !NILP (current_group), 0);
1585 error ("stop-process: Not supported on this system");
1590 DEFUN ("continue-process", Fcontinue_process, 0, 2, 0, /*
1591 Continue process PROCESS. May be process or name of one.
1592 See function `interrupt-process' for more details on usage.
1594 (process, current_group))
1596 /* This function can GC */
1598 process_send_signal (process, SIGCONT, !NILP (current_group), 0);
1600 error ("continue-process: Not supported on this system");
1605 DEFUN ("signal-process", Fsignal_process, 2, 2,
1606 "nProcess number: \nnSignal code: ", /*
1607 Send the process with process id PID the signal with code SIGCODE.
1608 PID must be an integer. The process need not be a child of this Emacs.
1609 SIGCODE may be an integer, or a symbol whose name is a signal name.
1621 CHECK_SYMBOL (sigcode);
1622 name = string_data (XSYMBOL (sigcode)->name);
1624 #define handle_signal(signal) \
1625 else if (!strcmp ((CONST char *) name, #signal)) \
1626 XSETINT (sigcode, signal)
1630 handle_signal (SIGINT); /* ANSI */
1631 handle_signal (SIGILL); /* ANSI */
1632 handle_signal (SIGABRT); /* ANSI */
1633 handle_signal (SIGFPE); /* ANSI */
1634 handle_signal (SIGSEGV); /* ANSI */
1635 handle_signal (SIGTERM); /* ANSI */
1638 handle_signal (SIGHUP); /* POSIX */
1641 handle_signal (SIGQUIT); /* POSIX */
1644 handle_signal (SIGTRAP); /* POSIX */
1647 handle_signal (SIGKILL); /* POSIX */
1650 handle_signal (SIGUSR1); /* POSIX */
1653 handle_signal (SIGUSR2); /* POSIX */
1656 handle_signal (SIGPIPE); /* POSIX */
1659 handle_signal (SIGALRM); /* POSIX */
1662 handle_signal (SIGCHLD); /* POSIX */
1665 handle_signal (SIGCONT); /* POSIX */
1668 handle_signal (SIGSTOP); /* POSIX */
1671 handle_signal (SIGTSTP); /* POSIX */
1674 handle_signal (SIGTTIN); /* POSIX */
1677 handle_signal (SIGTTOU); /* POSIX */
1681 handle_signal (SIGBUS); /* XPG5 */
1684 handle_signal (SIGPOLL); /* XPG5 */
1687 handle_signal (SIGPROF); /* XPG5 */
1690 handle_signal (SIGSYS); /* XPG5 */
1693 handle_signal (SIGURG); /* XPG5 */
1696 handle_signal (SIGXCPU); /* XPG5 */
1699 handle_signal (SIGXFSZ); /* XPG5 */
1702 handle_signal (SIGVTALRM); /* XPG5 */
1706 handle_signal (SIGIO); /* BSD 4.2 */
1709 handle_signal (SIGWINCH); /* BSD 4.3 */
1713 handle_signal (SIGEMT);
1716 handle_signal (SIGINFO);
1719 handle_signal (SIGHWE);
1722 handle_signal (SIGPRE);
1725 handle_signal (SIGUME);
1728 handle_signal (SIGDLK);
1731 handle_signal (SIGCPULIM);
1734 handle_signal (SIGIOT);
1737 handle_signal (SIGLOST);
1740 handle_signal (SIGSTKFLT);
1743 handle_signal (SIGUNUSED);
1746 handle_signal (SIGDANGER);
1749 handle_signal (SIGMSG);
1752 handle_signal (SIGSOUND);
1755 handle_signal (SIGRETRACT);
1758 handle_signal (SIGGRANT);
1761 handle_signal (SIGPWR);
1764 error ("Undefined signal name %s", name);
1767 #undef handle_signal
1769 return make_int (PROCMETH_OR_GIVEN (kill_process_by_pid,
1770 (XINT (pid), XINT (sigcode)), -1));
1773 DEFUN ("process-send-eof", Fprocess_send_eof, 0, 1, 0, /*
1774 Make PROCESS see end-of-file in its input.
1775 PROCESS may be a process, a buffer, the name of a process or buffer, or
1776 nil, indicating the current buffer's process.
1777 If PROCESS is a network connection, or is a process communicating
1778 through a pipe (as opposed to a pty), then you cannot send any more
1779 text to PROCESS after you call this function.
1783 /* This function can GC */
1784 Lisp_Object proc = get_process (process);
1786 /* Make sure the process is really alive. */
1787 if (! EQ (XPROCESS (proc)->status_symbol, Qrun))
1788 error ("Process %s not running", XSTRING_DATA (XPROCESS (proc)->name));
1790 if (!MAYBE_INT_PROCMETH (process_send_eof, (proc)))
1792 if (!NILP (DATA_OUTSTREAM (XPROCESS (proc))))
1794 Lstream_close (XLSTREAM (DATA_OUTSTREAM (XPROCESS (proc))));
1795 event_stream_delete_stream_pair (Qnil, XPROCESS (proc)->pipe_outstream);
1796 XPROCESS (proc)->pipe_outstream = Qnil;
1798 XPROCESS (proc)->coding_outstream = Qnil;
1807 /************************************************************************/
1808 /* deleting a process */
1809 /************************************************************************/
1812 deactivate_process (Lisp_Object proc)
1814 struct Lisp_Process *p = XPROCESS (proc);
1817 /* It's possible that we got as far in the process-creation
1818 process as creating the descriptors but didn't get so
1819 far as selecting the process for input. In this
1820 case, p->pid is nil: p->pid is set at the same time that
1821 the process is selected for input. */
1822 /* #### The comment does not look correct. event_stream_unselect_process
1823 is guarded by process->selected, so this is not a problem. - kkm*/
1824 /* Must call this before setting the streams to nil */
1825 event_stream_unselect_process (p);
1827 if (!NILP (DATA_OUTSTREAM (p)))
1828 Lstream_close (XLSTREAM (DATA_OUTSTREAM (p)));
1829 if (!NILP (DATA_INSTREAM (p)))
1830 Lstream_close (XLSTREAM (DATA_INSTREAM (p)));
1832 /* Provide minimal implementation for deactivate_process
1833 if there's no process-specific one */
1834 if (HAS_PROCMETH_P (deactivate_process))
1835 usid = PROCMETH (deactivate_process, (p));
1837 usid = event_stream_delete_stream_pair (p->pipe_instream,
1840 if (usid != USID_DONTHASH)
1841 remhash ((CONST void*)usid, usid_to_process);
1843 p->pipe_instream = Qnil;
1844 p->pipe_outstream = Qnil;
1846 p->coding_instream = Qnil;
1847 p->coding_outstream = Qnil;
1852 remove_process (Lisp_Object proc)
1854 Vprocess_list = delq_no_quit (proc, Vprocess_list);
1855 Fset_marker (XPROCESS (proc)->mark, Qnil, Qnil);
1857 deactivate_process (proc);
1860 DEFUN ("delete-process", Fdelete_process, 1, 1, 0, /*
1861 Delete PROCESS: kill it and forget about it immediately.
1862 PROCESS may be a process or the name of one, or a buffer name.
1866 /* This function can GC */
1867 struct Lisp_Process *p;
1868 proc = get_process (proc);
1869 p = XPROCESS (proc);
1870 if (network_connection_p (proc))
1872 p->status_symbol = Qexit;
1878 else if (!NILP(p->pipe_instream))
1880 Fkill_process (proc, Qnil);
1881 /* Do this now, since remove_process will make sigchld_handler do nothing. */
1882 p->status_symbol = Qsignal;
1883 p->exit_code = SIGKILL;
1889 remove_process (proc);
1893 /* Kill all processes associated with `buffer'.
1894 If `buffer' is nil, kill all processes */
1897 kill_buffer_processes (Lisp_Object buffer)
1901 for (tail = Vprocess_list; GC_CONSP (tail);
1904 Lisp_Object proc = XCAR (tail);
1905 if (GC_PROCESSP (proc)
1906 && (GC_NILP (buffer) || GC_EQ (XPROCESS (proc)->buffer, buffer)))
1908 if (network_connection_p (proc))
1909 Fdelete_process (proc);
1910 else if (!NILP (XPROCESS (proc)->pipe_instream))
1911 process_send_signal (proc, SIGHUP, 0, 1);
1916 DEFUN ("process-kill-without-query", Fprocess_kill_without_query, 1, 2, 0, /*
1917 Say no query needed if PROCESS is running when Emacs is exited.
1918 Optional second argument if non-nil says to require a query.
1919 Value is t if a query was formerly required.
1921 (proc, require_query_p))
1925 CHECK_PROCESS (proc);
1926 tem = XPROCESS (proc)->kill_without_query;
1927 XPROCESS (proc)->kill_without_query = NILP (require_query_p);
1929 return tem ? Qnil : Qt;
1932 DEFUN ("process-kill-without-query-p", Fprocess_kill_without_query_p, 1, 1, 0, /*
1933 Whether PROC will be killed without query if running when emacs is exited.
1937 CHECK_PROCESS (proc);
1938 return XPROCESS (proc)->kill_without_query ? Qt : Qnil;
1942 /* This is not named init_process in order to avoid a conflict with NS 3.3 */
1944 init_xemacs_process (void)
1946 MAYBE_PROCMETH (init_process, ());
1948 Vprocess_list = Qnil;
1949 usid_to_process = make_hashtable (32);
1954 xxDEFUN ("process-connection", Fprocess_connection, 0, 1, 0, /*
1955 Return the connection type of `PROCESS'. This can be nil (pipe),
1956 t or pty (pty) or stream (socket connection).
1960 return XPROCESS (process)->type;
1966 syms_of_process (void)
1968 defsymbol (&Qprocessp, "processp");
1969 defsymbol (&Qrun, "run");
1970 defsymbol (&Qstop, "stop");
1971 defsymbol (&Qopen, "open");
1972 defsymbol (&Qclosed, "closed");
1974 defsymbol (&Qtcpip, "tcp/ip");
1976 #ifdef HAVE_MULTICAST
1977 defsymbol(&Qmulticast, "multicast"); /* Used for occasional warnings */
1980 DEFSUBR (Fprocessp);
1981 DEFSUBR (Fget_process);
1982 DEFSUBR (Fget_buffer_process);
1983 DEFSUBR (Fdelete_process);
1984 DEFSUBR (Fprocess_status);
1985 DEFSUBR (Fprocess_exit_status);
1986 DEFSUBR (Fprocess_id);
1987 DEFSUBR (Fprocess_name);
1988 DEFSUBR (Fprocess_tty_name);
1989 DEFSUBR (Fprocess_command);
1990 DEFSUBR (Fset_process_buffer);
1991 DEFSUBR (Fprocess_buffer);
1992 DEFSUBR (Fprocess_mark);
1993 DEFSUBR (Fset_process_filter);
1994 DEFSUBR (Fprocess_filter);
1995 DEFSUBR (Fset_process_window_size);
1996 DEFSUBR (Fset_process_sentinel);
1997 DEFSUBR (Fprocess_sentinel);
1998 DEFSUBR (Fprocess_kill_without_query);
1999 DEFSUBR (Fprocess_kill_without_query_p);
2000 DEFSUBR (Fprocess_list);
2001 DEFSUBR (Fstart_process_internal);
2003 DEFSUBR (Fopen_network_stream_internal);
2004 #ifdef HAVE_MULTICAST
2005 DEFSUBR (Fopen_multicast_group_internal);
2006 #endif /* HAVE_MULTICAST */
2007 #endif /* HAVE_SOCKETS */
2008 DEFSUBR (Fprocess_send_region);
2009 DEFSUBR (Fprocess_send_string);
2010 DEFSUBR (Finterrupt_process);
2011 DEFSUBR (Fkill_process);
2012 DEFSUBR (Fquit_process);
2013 DEFSUBR (Fstop_process);
2014 DEFSUBR (Fcontinue_process);
2015 DEFSUBR (Fprocess_send_eof);
2016 DEFSUBR (Fsignal_process);
2017 /* DEFSUBR (Fprocess_connection); */
2019 DEFSUBR (Fprocess_input_coding_system);
2020 DEFSUBR (Fprocess_output_coding_system);
2021 DEFSUBR (Fset_process_input_coding_system);
2022 DEFSUBR (Fset_process_output_coding_system);
2023 DEFSUBR (Fprocess_coding_system);
2024 DEFSUBR (Fset_process_coding_system);
2025 #endif /* FILE_CODING */
2029 vars_of_process (void)
2031 Fprovide (intern ("subprocesses"));
2033 Fprovide (intern ("network-streams"));
2034 #ifdef HAVE_MULTICAST
2035 Fprovide (intern ("multicast"));
2036 #endif /* HAVE_MULTICAST */
2037 #endif /* HAVE_SOCKETS */
2038 staticpro (&Vprocess_list);
2040 DEFVAR_BOOL ("delete-exited-processes", &delete_exited_processes /*
2041 *Non-nil means delete processes immediately when they exit.
2042 nil means don't delete them until `list-processes' is run.
2045 delete_exited_processes = 1;
2047 DEFVAR_LISP ("process-connection-type", &Vprocess_connection_type /*
2048 Control type of device used to communicate with subprocesses.
2049 Values are nil to use a pipe, or t or `pty' to use a pty.
2050 The value has no effect if the system has no ptys or if all ptys are busy:
2051 then a pipe is used in any case.
2052 The value takes effect when `start-process' is called.
2054 Vprocess_connection_type = Qt;
2056 DEFVAR_BOOL ("windowed-process-io", &windowed_process_io /*
2057 Enables input/ouptut on standard handles of a windowed process.
2058 When this variable is nil (the default), XEmacs does not attempt to read
2059 standard output handle of a windowed process. Instead, the process is
2060 immediately marked as exited immediately upon successful launching. This is
2061 done because normal windowed processes do not use stadnard I/O, as they are
2062 not connected to any console.
2064 When launching a specially crafted windowed process, which expects to be
2065 launched by XEmacs, or by other program which pipes its standard input and
2066 output, this variable must be set to non-nil, in which case XEmacs will
2067 treat this process just like a console process.
2069 NOTE: You should never set this variable, only bind it.
2071 Only Windows processes can be "windowed" or "console". This variable has no
2072 effect on UNIX processes, because all UNIX processes are "console".
2074 windowed_process_io = 0;
2076 #ifdef PROCESS_IO_BLOCKING
2077 DEFVAR_LISP ("network-stream-blocking-port-list", &network_stream_blocking_port_list /*
2078 List of port numbers or port names to set a blocking I/O mode with connection.
2079 Nil value means to set a default(non-blocking) I/O mode.
2080 The value takes effect when `open-network-stream-internal' is called.
2082 network_stream_blocking_port_list = Qnil;
2083 #endif /* PROCESS_IO_BLOCKING */
2086 #endif /* not NO_SUBPROCESSES */