(Fmake_temp_name): forgot the \n\ in the docstring
[emacs.git] / src / process.c
blob2cb1dd908ceec50f01a343106e63f2464e3698a9
1 /* Asynchronous subprocess control for GNU Emacs.
2 Copyright (C) 1985, 86, 87, 88, 93, 94, 95, 96, 1998
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 #include <signal.h>
25 #include <config.h>
27 /* This file is split into two parts by the following preprocessor
28 conditional. The 'then' clause contains all of the support for
29 asynchronous subprocesses. The 'else' clause contains stub
30 versions of some of the asynchronous subprocess routines that are
31 often called elsewhere in Emacs, so we don't have to #ifdef the
32 sections that call them. */
35 #ifdef subprocesses
37 #include <stdio.h>
38 #include <errno.h>
39 #include <setjmp.h>
40 #include <sys/types.h> /* some typedefs are used in sys/file.h */
41 #include <sys/file.h>
42 #include <sys/stat.h>
43 #ifdef HAVE_UNISTD_H
44 #include <unistd.h>
45 #endif
47 #ifdef WINDOWSNT
48 #include <stdlib.h>
49 #include <fcntl.h>
50 #endif /* not WINDOWSNT */
52 #ifdef HAVE_SOCKETS /* TCP connection support, if kernel can do it */
53 #include <sys/socket.h>
54 #include <netdb.h>
55 #include <netinet/in.h>
56 #include <arpa/inet.h>
57 #ifdef NEED_NET_ERRNO_H
58 #include <net/errno.h>
59 #endif /* NEED_NET_ERRNO_H */
60 #endif /* HAVE_SOCKETS */
62 /* TERM is a poor-man's SLIP, used on Linux. */
63 #ifdef TERM
64 #include <client.h>
65 #endif
67 /* On some systems, e.g. DGUX, inet_addr returns a 'struct in_addr'. */
68 #ifdef HAVE_BROKEN_INET_ADDR
69 #define IN_ADDR struct in_addr
70 #define NUMERIC_ADDR_ERROR (numeric_addr.s_addr == -1)
71 #else
72 #define IN_ADDR unsigned long
73 #define NUMERIC_ADDR_ERROR (numeric_addr == -1)
74 #endif
76 #if defined(BSD_SYSTEM) || defined(STRIDE)
77 #include <sys/ioctl.h>
78 #if !defined (O_NDELAY) && defined (HAVE_PTYS) && !defined(USG5)
79 #include <fcntl.h>
80 #endif /* HAVE_PTYS and no O_NDELAY */
81 #endif /* BSD_SYSTEM || STRIDE */
83 #ifdef BROKEN_O_NONBLOCK
84 #undef O_NONBLOCK
85 #endif /* BROKEN_O_NONBLOCK */
87 #ifdef NEED_BSDTTY
88 #include <bsdtty.h>
89 #endif
91 #ifdef IRIS
92 #include <sys/sysmacros.h> /* for "minor" */
93 #endif /* not IRIS */
95 #include "systime.h"
96 #include "systty.h"
98 #include "lisp.h"
99 #include "window.h"
100 #include "buffer.h"
101 #include "charset.h"
102 #include "coding.h"
103 #include "process.h"
104 #include "termhooks.h"
105 #include "termopts.h"
106 #include "commands.h"
107 #include "frame.h"
108 #include "blockinput.h"
109 #include "keyboard.h"
110 #include "dispextern.h"
112 #define max(a, b) ((a) > (b) ? (a) : (b))
114 Lisp_Object Qprocessp;
115 Lisp_Object Qrun, Qstop, Qsignal, Qopen, Qclosed;
116 Lisp_Object Qlast_nonmenu_event;
117 /* Qexit is declared and initialized in eval.c. */
119 /* a process object is a network connection when its childp field is neither
120 Qt nor Qnil but is instead a cons cell (HOSTNAME PORTNUM). */
122 #ifdef HAVE_SOCKETS
123 #define NETCONN_P(p) (GC_CONSP (XPROCESS (p)->childp))
124 #else
125 #define NETCONN_P(p) 0
126 #endif /* HAVE_SOCKETS */
128 /* Define first descriptor number available for subprocesses. */
129 #ifdef VMS
130 #define FIRST_PROC_DESC 1
131 #else /* Not VMS */
132 #define FIRST_PROC_DESC 3
133 #endif
135 /* Define SIGCHLD as an alias for SIGCLD. There are many conditionals
136 testing SIGCHLD. */
138 #if !defined (SIGCHLD) && defined (SIGCLD)
139 #define SIGCHLD SIGCLD
140 #endif /* SIGCLD */
142 #include "syssignal.h"
144 #include "syswait.h"
146 extern void set_waiting_for_input P_ ((EMACS_TIME *));
148 extern int errno;
149 extern char *strerror ();
150 #ifdef VMS
151 extern char *sys_errlist[];
152 #endif
154 #ifndef HAVE_H_ERRNO
155 extern int h_errno;
156 #endif
158 #ifndef SYS_SIGLIST_DECLARED
159 #ifndef VMS
160 #ifndef BSD4_1
161 #ifndef WINDOWSNT
162 #ifndef LINUX
163 extern char *sys_siglist[];
164 #endif /* not LINUX */
165 #else /* BSD4_1 */
166 char *sys_siglist[] =
168 "bum signal!!",
169 "hangup",
170 "interrupt",
171 "quit",
172 "illegal instruction",
173 "trace trap",
174 "iot instruction",
175 "emt instruction",
176 "floating point exception",
177 "kill",
178 "bus error",
179 "segmentation violation",
180 "bad argument to system call",
181 "write on a pipe with no one to read it",
182 "alarm clock",
183 "software termination signal from kill",
184 "status signal",
185 "sendable stop signal not from tty",
186 "stop signal from tty",
187 "continue a stopped process",
188 "child status has changed",
189 "background read attempted from control tty",
190 "background write attempted from control tty",
191 "input record available at control tty",
192 "exceeded CPU time limit",
193 "exceeded file size limit"
195 #endif /* not WINDOWSNT */
196 #endif
197 #endif /* VMS */
198 #endif /* ! SYS_SIGLIST_DECLARED */
200 /* t means use pty, nil means use a pipe,
201 maybe other values to come. */
202 static Lisp_Object Vprocess_connection_type;
204 #ifdef SKTPAIR
205 #ifndef HAVE_SOCKETS
206 #include <sys/socket.h>
207 #endif
208 #endif /* SKTPAIR */
210 /* These next two vars are non-static since sysdep.c uses them in the
211 emulation of `select'. */
212 /* Number of events of change of status of a process. */
213 int process_tick;
214 /* Number of events for which the user or sentinel has been notified. */
215 int update_tick;
217 #include "sysselect.h"
219 extern int keyboard_bit_set P_ ((SELECT_TYPE *));
221 /* If we support a window system, turn on the code to poll periodically
222 to detect C-g. It isn't actually used when doing interrupt input. */
223 #ifdef HAVE_WINDOW_SYSTEM
224 #define POLL_FOR_INPUT
225 #endif
227 /* Mask of bits indicating the descriptors that we wait for input on. */
229 static SELECT_TYPE input_wait_mask;
231 /* Mask that excludes keyboard input descriptor (s). */
233 static SELECT_TYPE non_keyboard_wait_mask;
235 /* Mask that excludes process input descriptor (s). */
237 static SELECT_TYPE non_process_wait_mask;
239 /* The largest descriptor currently in use for a process object. */
240 static int max_process_desc;
242 /* The largest descriptor currently in use for keyboard input. */
243 static int max_keyboard_desc;
245 /* Nonzero means delete a process right away if it exits. */
246 static int delete_exited_processes;
248 /* Indexed by descriptor, gives the process (if any) for that descriptor */
249 Lisp_Object chan_process[MAXDESC];
251 /* Alist of elements (NAME . PROCESS) */
252 Lisp_Object Vprocess_alist;
254 /* Buffered-ahead input char from process, indexed by channel.
255 -1 means empty (no char is buffered).
256 Used on sys V where the only way to tell if there is any
257 output from the process is to read at least one char.
258 Always -1 on systems that support FIONREAD. */
260 /* Don't make static; need to access externally. */
261 int proc_buffered_char[MAXDESC];
263 /* Table of `struct coding-system' for each process. */
264 static struct coding_system *proc_decode_coding_system[MAXDESC];
265 static struct coding_system *proc_encode_coding_system[MAXDESC];
267 static Lisp_Object get_process ();
269 extern EMACS_TIME timer_check ();
270 extern int timers_run;
272 /* Maximum number of bytes to send to a pty without an eof. */
273 static int pty_max_bytes;
275 extern Lisp_Object Vfile_name_coding_system, Vdefault_file_name_coding_system;
277 #ifdef HAVE_PTYS
278 /* The file name of the pty opened by allocate_pty. */
280 static char pty_name[24];
281 #endif
283 /* Compute the Lisp form of the process status, p->status, from
284 the numeric status that was returned by `wait'. */
286 Lisp_Object status_convert ();
288 void
289 update_status (p)
290 struct Lisp_Process *p;
292 union { int i; WAITTYPE wt; } u;
293 u.i = XFASTINT (p->raw_status_low) + (XFASTINT (p->raw_status_high) << 16);
294 p->status = status_convert (u.wt);
295 p->raw_status_low = Qnil;
296 p->raw_status_high = Qnil;
299 /* Convert a process status word in Unix format to
300 the list that we use internally. */
302 Lisp_Object
303 status_convert (w)
304 WAITTYPE w;
306 if (WIFSTOPPED (w))
307 return Fcons (Qstop, Fcons (make_number (WSTOPSIG (w)), Qnil));
308 else if (WIFEXITED (w))
309 return Fcons (Qexit, Fcons (make_number (WRETCODE (w)),
310 WCOREDUMP (w) ? Qt : Qnil));
311 else if (WIFSIGNALED (w))
312 return Fcons (Qsignal, Fcons (make_number (WTERMSIG (w)),
313 WCOREDUMP (w) ? Qt : Qnil));
314 else
315 return Qrun;
318 /* Given a status-list, extract the three pieces of information
319 and store them individually through the three pointers. */
321 void
322 decode_status (l, symbol, code, coredump)
323 Lisp_Object l;
324 Lisp_Object *symbol;
325 int *code;
326 int *coredump;
328 Lisp_Object tem;
330 if (SYMBOLP (l))
332 *symbol = l;
333 *code = 0;
334 *coredump = 0;
336 else
338 *symbol = XCAR (l);
339 tem = XCDR (l);
340 *code = XFASTINT (XCAR (tem));
341 tem = XCDR (tem);
342 *coredump = !NILP (tem);
346 /* Return a string describing a process status list. */
348 Lisp_Object
349 status_message (status)
350 Lisp_Object status;
352 Lisp_Object symbol;
353 int code, coredump;
354 Lisp_Object string, string2;
356 decode_status (status, &symbol, &code, &coredump);
358 if (EQ (symbol, Qsignal) || EQ (symbol, Qstop))
360 char *signame = 0;
361 if (code < NSIG)
363 #ifndef VMS
364 /* Cast to suppress warning if the table has const char *. */
365 signame = (char *) sys_siglist[code];
366 #else
367 signame = sys_errlist[code];
368 #endif
370 if (signame == 0)
371 signame = "unknown";
372 string = build_string (signame);
373 string2 = build_string (coredump ? " (core dumped)\n" : "\n");
374 XSTRING (string)->data[0] = DOWNCASE (XSTRING (string)->data[0]);
375 return concat2 (string, string2);
377 else if (EQ (symbol, Qexit))
379 if (code == 0)
380 return build_string ("finished\n");
381 string = Fnumber_to_string (make_number (code));
382 string2 = build_string (coredump ? " (core dumped)\n" : "\n");
383 return concat2 (build_string ("exited abnormally with code "),
384 concat2 (string, string2));
386 else
387 return Fcopy_sequence (Fsymbol_name (symbol));
390 #ifdef HAVE_PTYS
392 /* Open an available pty, returning a file descriptor.
393 Return -1 on failure.
394 The file name of the terminal corresponding to the pty
395 is left in the variable pty_name. */
398 allocate_pty ()
400 struct stat stb;
401 register int c, i;
402 int fd;
404 /* Some systems name their pseudoterminals so that there are gaps in
405 the usual sequence - for example, on HP9000/S700 systems, there
406 are no pseudoterminals with names ending in 'f'. So we wait for
407 three failures in a row before deciding that we've reached the
408 end of the ptys. */
409 int failed_count = 0;
411 #ifdef PTY_ITERATION
412 PTY_ITERATION
413 #else
414 for (c = FIRST_PTY_LETTER; c <= 'z'; c++)
415 for (i = 0; i < 16; i++)
416 #endif
418 #ifdef PTY_NAME_SPRINTF
419 PTY_NAME_SPRINTF
420 #else
421 sprintf (pty_name, "/dev/pty%c%x", c, i);
422 #endif /* no PTY_NAME_SPRINTF */
424 #ifdef PTY_OPEN
425 PTY_OPEN;
426 #else /* no PTY_OPEN */
427 #ifdef IRIS
428 /* Unusual IRIS code */
429 *ptyv = open ("/dev/ptc", O_RDWR | O_NDELAY, 0);
430 if (fd < 0)
431 return -1;
432 if (fstat (fd, &stb) < 0)
433 return -1;
434 #else /* not IRIS */
435 if (stat (pty_name, &stb) < 0)
437 failed_count++;
438 if (failed_count >= 3)
439 return -1;
441 else
442 failed_count = 0;
443 #ifdef O_NONBLOCK
444 fd = open (pty_name, O_RDWR | O_NONBLOCK, 0);
445 #else
446 fd = open (pty_name, O_RDWR | O_NDELAY, 0);
447 #endif
448 #endif /* not IRIS */
449 #endif /* no PTY_OPEN */
451 if (fd >= 0)
453 /* check to make certain that both sides are available
454 this avoids a nasty yet stupid bug in rlogins */
455 #ifdef PTY_TTY_NAME_SPRINTF
456 PTY_TTY_NAME_SPRINTF
457 #else
458 sprintf (pty_name, "/dev/tty%c%x", c, i);
459 #endif /* no PTY_TTY_NAME_SPRINTF */
460 #ifndef UNIPLUS
461 if (access (pty_name, 6) != 0)
463 close (fd);
464 #if !defined(IRIS) && !defined(__sgi)
465 continue;
466 #else
467 return -1;
468 #endif /* IRIS */
470 #endif /* not UNIPLUS */
471 setup_pty (fd);
472 return fd;
475 return -1;
477 #endif /* HAVE_PTYS */
479 Lisp_Object
480 make_process (name)
481 Lisp_Object name;
483 struct Lisp_Vector *vec;
484 register Lisp_Object val, tem, name1;
485 register struct Lisp_Process *p;
486 char suffix[10];
487 register int i;
489 vec = allocate_vectorlike ((EMACS_INT) VECSIZE (struct Lisp_Process));
490 for (i = 0; i < VECSIZE (struct Lisp_Process); i++)
491 vec->contents[i] = Qnil;
492 vec->size = VECSIZE (struct Lisp_Process);
493 p = (struct Lisp_Process *)vec;
495 XSETINT (p->infd, -1);
496 XSETINT (p->outfd, -1);
497 XSETFASTINT (p->pid, 0);
498 XSETFASTINT (p->tick, 0);
499 XSETFASTINT (p->update_tick, 0);
500 p->raw_status_low = Qnil;
501 p->raw_status_high = Qnil;
502 p->status = Qrun;
503 p->mark = Fmake_marker ();
505 /* If name is already in use, modify it until it is unused. */
507 name1 = name;
508 for (i = 1; ; i++)
510 tem = Fget_process (name1);
511 if (NILP (tem)) break;
512 sprintf (suffix, "<%d>", i);
513 name1 = concat2 (name, build_string (suffix));
515 name = name1;
516 p->name = name;
517 XSETPROCESS (val, p);
518 Vprocess_alist = Fcons (Fcons (name, val), Vprocess_alist);
519 return val;
522 void
523 remove_process (proc)
524 register Lisp_Object proc;
526 register Lisp_Object pair;
528 pair = Frassq (proc, Vprocess_alist);
529 Vprocess_alist = Fdelq (pair, Vprocess_alist);
531 deactivate_process (proc);
534 DEFUN ("processp", Fprocessp, Sprocessp, 1, 1, 0,
535 "Return t if OBJECT is a process.")
536 (object)
537 Lisp_Object object;
539 return PROCESSP (object) ? Qt : Qnil;
542 DEFUN ("get-process", Fget_process, Sget_process, 1, 1, 0,
543 "Return the process named NAME, or nil if there is none.")
544 (name)
545 register Lisp_Object name;
547 if (PROCESSP (name))
548 return name;
549 CHECK_STRING (name, 0);
550 return Fcdr (Fassoc (name, Vprocess_alist));
553 DEFUN ("get-buffer-process", Fget_buffer_process, Sget_buffer_process, 1, 1, 0,
554 "Return the (or a) process associated with BUFFER.\n\
555 BUFFER may be a buffer or the name of one.")
556 (buffer)
557 register Lisp_Object buffer;
559 register Lisp_Object buf, tail, proc;
561 if (NILP (buffer)) return Qnil;
562 buf = Fget_buffer (buffer);
563 if (NILP (buf)) return Qnil;
565 for (tail = Vprocess_alist; !NILP (tail); tail = Fcdr (tail))
567 proc = Fcdr (Fcar (tail));
568 if (PROCESSP (proc) && EQ (XPROCESS (proc)->buffer, buf))
569 return proc;
571 return Qnil;
574 /* This is how commands for the user decode process arguments. It
575 accepts a process, a process name, a buffer, a buffer name, or nil.
576 Buffers denote the first process in the buffer, and nil denotes the
577 current buffer. */
579 static Lisp_Object
580 get_process (name)
581 register Lisp_Object name;
583 register Lisp_Object proc, obj;
584 if (STRINGP (name))
586 obj = Fget_process (name);
587 if (NILP (obj))
588 obj = Fget_buffer (name);
589 if (NILP (obj))
590 error ("Process %s does not exist", XSTRING (name)->data);
592 else if (NILP (name))
593 obj = Fcurrent_buffer ();
594 else
595 obj = name;
597 /* Now obj should be either a buffer object or a process object.
599 if (BUFFERP (obj))
601 proc = Fget_buffer_process (obj);
602 if (NILP (proc))
603 error ("Buffer %s has no process", XSTRING (XBUFFER (obj)->name)->data);
605 else
607 CHECK_PROCESS (obj, 0);
608 proc = obj;
610 return proc;
613 DEFUN ("delete-process", Fdelete_process, Sdelete_process, 1, 1, 0,
614 "Delete PROCESS: kill it and forget about it immediately.\n\
615 PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
616 nil, indicating the current buffer's process.")
617 (process)
618 register Lisp_Object process;
620 process = get_process (process);
621 XPROCESS (process)->raw_status_low = Qnil;
622 XPROCESS (process)->raw_status_high = Qnil;
623 if (NETCONN_P (process))
625 XPROCESS (process)->status = Fcons (Qexit, Fcons (make_number (0), Qnil));
626 XSETINT (XPROCESS (process)->tick, ++process_tick);
628 else if (XINT (XPROCESS (process)->infd) >= 0)
630 Fkill_process (process, Qnil);
631 /* Do this now, since remove_process will make sigchld_handler do nothing. */
632 XPROCESS (process)->status
633 = Fcons (Qsignal, Fcons (make_number (SIGKILL), Qnil));
634 XSETINT (XPROCESS (process)->tick, ++process_tick);
635 status_notify ();
637 remove_process (process);
638 return Qnil;
641 DEFUN ("process-status", Fprocess_status, Sprocess_status, 1, 1, 0,
642 "Return the status of PROCESS.\n\
643 The returned value is one of the following symbols:\n\
644 run -- for a process that is running.\n\
645 stop -- for a process stopped but continuable.\n\
646 exit -- for a process that has exited.\n\
647 signal -- for a process that has got a fatal signal.\n\
648 open -- for a network stream connection that is open.\n\
649 closed -- for a network stream connection that is closed.\n\
650 nil -- if arg is a process name and no such process exists.\n\
651 PROCESS may be a process, a buffer, the name of a process, or\n\
652 nil, indicating the current buffer's process.")
653 (process)
654 register Lisp_Object process;
656 register struct Lisp_Process *p;
657 register Lisp_Object status;
659 if (STRINGP (process))
660 process = Fget_process (process);
661 else
662 process = get_process (process);
664 if (NILP (process))
665 return process;
667 p = XPROCESS (process);
668 if (!NILP (p->raw_status_low))
669 update_status (p);
670 status = p->status;
671 if (CONSP (status))
672 status = XCAR (status);
673 if (NETCONN_P (process))
675 if (EQ (status, Qrun))
676 status = Qopen;
677 else if (EQ (status, Qexit))
678 status = Qclosed;
680 return status;
683 DEFUN ("process-exit-status", Fprocess_exit_status, Sprocess_exit_status,
684 1, 1, 0,
685 "Return the exit status of PROCESS or the signal number that killed it.\n\
686 If PROCESS has not yet exited or died, return 0.")
687 (process)
688 register Lisp_Object process;
690 CHECK_PROCESS (process, 0);
691 if (!NILP (XPROCESS (process)->raw_status_low))
692 update_status (XPROCESS (process));
693 if (CONSP (XPROCESS (process)->status))
694 return XCAR (XCDR (XPROCESS (process)->status));
695 return make_number (0);
698 DEFUN ("process-id", Fprocess_id, Sprocess_id, 1, 1, 0,
699 "Return the process id of PROCESS.\n\
700 This is the pid of the Unix process which PROCESS uses or talks to.\n\
701 For a network connection, this value is nil.")
702 (process)
703 register Lisp_Object process;
705 CHECK_PROCESS (process, 0);
706 return XPROCESS (process)->pid;
709 DEFUN ("process-name", Fprocess_name, Sprocess_name, 1, 1, 0,
710 "Return the name of PROCESS, as a string.\n\
711 This is the name of the program invoked in PROCESS,\n\
712 possibly modified to make it unique among process names.")
713 (process)
714 register Lisp_Object process;
716 CHECK_PROCESS (process, 0);
717 return XPROCESS (process)->name;
720 DEFUN ("process-command", Fprocess_command, Sprocess_command, 1, 1, 0,
721 "Return the command that was executed to start PROCESS.\n\
722 This is a list of strings, the first string being the program executed\n\
723 and the rest of the strings being the arguments given to it.\n\
724 For a non-child channel, this is nil.")
725 (process)
726 register Lisp_Object process;
728 CHECK_PROCESS (process, 0);
729 return XPROCESS (process)->command;
732 DEFUN ("process-tty-name", Fprocess_tty_name, Sprocess_tty_name, 1, 1, 0,
733 "Return the name of the terminal PROCESS uses, or nil if none.\n\
734 This is the terminal that the process itself reads and writes on,\n\
735 not the name of the pty that Emacs uses to talk with that terminal.")
736 (process)
737 register Lisp_Object process;
739 CHECK_PROCESS (process, 0);
740 return XPROCESS (process)->tty_name;
743 DEFUN ("set-process-buffer", Fset_process_buffer, Sset_process_buffer,
744 2, 2, 0,
745 "Set buffer associated with PROCESS to BUFFER (a buffer, or nil).")
746 (process, buffer)
747 register Lisp_Object process, buffer;
749 CHECK_PROCESS (process, 0);
750 if (!NILP (buffer))
751 CHECK_BUFFER (buffer, 1);
752 XPROCESS (process)->buffer = buffer;
753 return buffer;
756 DEFUN ("process-buffer", Fprocess_buffer, Sprocess_buffer,
757 1, 1, 0,
758 "Return the buffer PROCESS is associated with.\n\
759 Output from PROCESS is inserted in this buffer unless PROCESS has a filter.")
760 (process)
761 register Lisp_Object process;
763 CHECK_PROCESS (process, 0);
764 return XPROCESS (process)->buffer;
767 DEFUN ("process-mark", Fprocess_mark, Sprocess_mark,
768 1, 1, 0,
769 "Return the marker for the end of the last output from PROCESS.")
770 (process)
771 register Lisp_Object process;
773 CHECK_PROCESS (process, 0);
774 return XPROCESS (process)->mark;
777 DEFUN ("set-process-filter", Fset_process_filter, Sset_process_filter,
778 2, 2, 0,
779 "Give PROCESS the filter function FILTER; nil means no filter.\n\
780 t means stop accepting output from the process.\n\
781 When a process has a filter, each time it does output\n\
782 the entire string of output is passed to the filter.\n\
783 The filter gets two arguments: the process and the string of output.\n\
784 If the process has a filter, its buffer is not used for output.")
785 (process, filter)
786 register Lisp_Object process, filter;
788 CHECK_PROCESS (process, 0);
789 if (EQ (filter, Qt))
791 FD_CLR (XINT (XPROCESS (process)->infd), &input_wait_mask);
792 FD_CLR (XINT (XPROCESS (process)->infd), &non_keyboard_wait_mask);
794 else if (EQ (XPROCESS (process)->filter, Qt))
796 FD_SET (XINT (XPROCESS (process)->infd), &input_wait_mask);
797 FD_SET (XINT (XPROCESS (process)->infd), &non_keyboard_wait_mask);
799 XPROCESS (process)->filter = filter;
800 return filter;
803 DEFUN ("process-filter", Fprocess_filter, Sprocess_filter,
804 1, 1, 0,
805 "Returns the filter function of PROCESS; nil if none.\n\
806 See `set-process-filter' for more info on filter functions.")
807 (process)
808 register Lisp_Object process;
810 CHECK_PROCESS (process, 0);
811 return XPROCESS (process)->filter;
814 DEFUN ("set-process-sentinel", Fset_process_sentinel, Sset_process_sentinel,
815 2, 2, 0,
816 "Give PROCESS the sentinel SENTINEL; nil for none.\n\
817 The sentinel is called as a function when the process changes state.\n\
818 It gets two arguments: the process, and a string describing the change.")
819 (process, sentinel)
820 register Lisp_Object process, sentinel;
822 CHECK_PROCESS (process, 0);
823 XPROCESS (process)->sentinel = sentinel;
824 return sentinel;
827 DEFUN ("process-sentinel", Fprocess_sentinel, Sprocess_sentinel,
828 1, 1, 0,
829 "Return the sentinel of PROCESS; nil if none.\n\
830 See `set-process-sentinel' for more info on sentinels.")
831 (process)
832 register Lisp_Object process;
834 CHECK_PROCESS (process, 0);
835 return XPROCESS (process)->sentinel;
838 DEFUN ("set-process-window-size", Fset_process_window_size,
839 Sset_process_window_size, 3, 3, 0,
840 "Tell PROCESS that it has logical window size HEIGHT and WIDTH.")
841 (process, height, width)
842 register Lisp_Object process, height, width;
844 CHECK_PROCESS (process, 0);
845 CHECK_NATNUM (height, 0);
846 CHECK_NATNUM (width, 0);
847 if (set_window_size (XINT (XPROCESS (process)->infd),
848 XINT (height), XINT (width)) <= 0)
849 return Qnil;
850 else
851 return Qt;
854 DEFUN ("set-process-inherit-coding-system-flag",
855 Fset_process_inherit_coding_system_flag,
856 Sset_process_inherit_coding_system_flag, 2, 2, 0,
857 "Determine whether buffer of PROCESS will inherit coding-system.\n\
858 If the second argument FLAG is non-nil, then the variable\n\
859 `buffer-file-coding-system' of the buffer associated with PROCESS\n\
860 will be bound to the value of the coding system used to decode\n\
861 the process output.\n\
863 This is useful when the coding system specified for the process buffer\n\
864 leaves either the character code conversion or the end-of-line conversion\n\
865 unspecified, or if the coding system used to decode the process output\n\
866 is more appropriate for saving the process buffer.\n\
868 Binding the variable `inherit-process-coding-system' to non-nil before\n\
869 starting the process is an alternative way of setting the inherit flag\n\
870 for the process which will run.")
871 (process, flag)
872 register Lisp_Object process, flag;
874 CHECK_PROCESS (process, 0);
875 XPROCESS (process)->inherit_coding_system_flag = flag;
876 return flag;
879 DEFUN ("process-inherit-coding-system-flag",
880 Fprocess_inherit_coding_system_flag, Sprocess_inherit_coding_system_flag,
881 1, 1, 0,
882 "Return the value of inherit-coding-system flag for PROCESS.\n\
883 If this flag is t, `buffer-file-coding-system' of the buffer\n\
884 associated with PROCESS will inherit the coding system used to decode\n\
885 the process output.")
886 (process)
887 register Lisp_Object process;
889 CHECK_PROCESS (process, 0);
890 return XPROCESS (process)->inherit_coding_system_flag;
893 DEFUN ("process-kill-without-query", Fprocess_kill_without_query,
894 Sprocess_kill_without_query, 1, 2, 0,
895 "Say no query needed if PROCESS is running when Emacs is exited.\n\
896 Optional second argument if non-nil says to require a query.\n\
897 Value is t if a query was formerly required.")
898 (process, value)
899 register Lisp_Object process, value;
901 Lisp_Object tem;
903 CHECK_PROCESS (process, 0);
904 tem = XPROCESS (process)->kill_without_query;
905 XPROCESS (process)->kill_without_query = Fnull (value);
907 return Fnull (tem);
910 DEFUN ("process-contact", Fprocess_contact, Sprocess_contact,
911 1, 1, 0,
912 "Return the contact info of PROCESS; t for a real child.\n\
913 For a net connection, the value is a cons cell of the form (HOST SERVICE).")
914 (process)
915 register Lisp_Object process;
917 CHECK_PROCESS (process, 0);
918 return XPROCESS (process)->childp;
921 #if 0 /* Turned off because we don't currently record this info
922 in the process. Perhaps add it. */
923 DEFUN ("process-connection", Fprocess_connection, Sprocess_connection, 1, 1, 0,
924 "Return the connection type of PROCESS.\n\
925 The value is nil for a pipe, t or `pty' for a pty, or `stream' for\n\
926 a socket connection.")
927 (process)
928 Lisp_Object process;
930 return XPROCESS (process)->type;
932 #endif
934 Lisp_Object
935 list_processes_1 ()
937 register Lisp_Object tail, tem;
938 Lisp_Object proc, minspace, tem1;
939 register struct Lisp_Process *p;
940 char tembuf[80];
942 XSETFASTINT (minspace, 1);
944 set_buffer_internal (XBUFFER (Vstandard_output));
945 Fbuffer_disable_undo (Vstandard_output);
947 current_buffer->truncate_lines = Qt;
949 write_string ("\
950 Proc Status Buffer Tty Command\n\
951 ---- ------ ------ --- -------\n", -1);
953 for (tail = Vprocess_alist; !NILP (tail); tail = Fcdr (tail))
955 Lisp_Object symbol;
957 proc = Fcdr (Fcar (tail));
958 p = XPROCESS (proc);
959 if (NILP (p->childp))
960 continue;
962 Finsert (1, &p->name);
963 Findent_to (make_number (13), minspace);
965 if (!NILP (p->raw_status_low))
966 update_status (p);
967 symbol = p->status;
968 if (CONSP (p->status))
969 symbol = XCAR (p->status);
972 if (EQ (symbol, Qsignal))
974 Lisp_Object tem;
975 tem = Fcar (Fcdr (p->status));
976 #ifdef VMS
977 if (XINT (tem) < NSIG)
978 write_string (sys_errlist [XINT (tem)], -1);
979 else
980 #endif
981 Fprinc (symbol, Qnil);
983 else if (NETCONN_P (proc))
985 if (EQ (symbol, Qrun))
986 write_string ("open", -1);
987 else if (EQ (symbol, Qexit))
988 write_string ("closed", -1);
989 else
990 Fprinc (symbol, Qnil);
992 else
993 Fprinc (symbol, Qnil);
995 if (EQ (symbol, Qexit))
997 Lisp_Object tem;
998 tem = Fcar (Fcdr (p->status));
999 if (XFASTINT (tem))
1001 sprintf (tembuf, " %d", (int) XFASTINT (tem));
1002 write_string (tembuf, -1);
1006 if (EQ (symbol, Qsignal) || EQ (symbol, Qexit))
1007 remove_process (proc);
1009 Findent_to (make_number (22), minspace);
1010 if (NILP (p->buffer))
1011 insert_string ("(none)");
1012 else if (NILP (XBUFFER (p->buffer)->name))
1013 insert_string ("(Killed)");
1014 else
1015 Finsert (1, &XBUFFER (p->buffer)->name);
1017 Findent_to (make_number (37), minspace);
1019 if (STRINGP (p->tty_name))
1020 Finsert (1, &p->tty_name);
1021 else
1022 insert_string ("(none)");
1024 Findent_to (make_number (49), minspace);
1026 if (NETCONN_P (proc))
1028 sprintf (tembuf, "(network stream connection to %s)\n",
1029 XSTRING (XCAR (p->childp))->data);
1030 insert_string (tembuf);
1032 else
1034 tem = p->command;
1035 while (1)
1037 tem1 = Fcar (tem);
1038 Finsert (1, &tem1);
1039 tem = Fcdr (tem);
1040 if (NILP (tem))
1041 break;
1042 insert_string (" ");
1044 insert_string ("\n");
1047 return Qnil;
1050 DEFUN ("list-processes", Flist_processes, Slist_processes, 0, 0, "",
1051 "Display a list of all processes.\n\
1052 Any process listed as exited or signaled is actually eliminated\n\
1053 after the listing is made.")
1056 internal_with_output_to_temp_buffer ("*Process List*",
1057 list_processes_1, Qnil);
1058 return Qnil;
1061 DEFUN ("process-list", Fprocess_list, Sprocess_list, 0, 0, 0,
1062 "Return a list of all processes.")
1065 return Fmapcar (Qcdr, Vprocess_alist);
1068 /* Starting asynchronous inferior processes. */
1070 static Lisp_Object start_process_unwind ();
1072 DEFUN ("start-process", Fstart_process, Sstart_process, 3, MANY, 0,
1073 "Start a program in a subprocess. Return the process object for it.\n\
1074 Args are NAME BUFFER PROGRAM &rest PROGRAM-ARGS\n\
1075 NAME is name for process. It is modified if necessary to make it unique.\n\
1076 BUFFER is the buffer or (buffer-name) to associate with the process.\n\
1077 Process output goes at end of that buffer, unless you specify\n\
1078 an output stream or filter function to handle the output.\n\
1079 BUFFER may be also nil, meaning that this process is not associated\n\
1080 with any buffer.\n\
1081 Third arg is program file name. It is searched for in PATH.\n\
1082 Remaining arguments are strings to give program as arguments.")
1083 (nargs, args)
1084 int nargs;
1085 register Lisp_Object *args;
1087 Lisp_Object buffer, name, program, proc, current_dir, tem;
1088 #ifdef VMS
1089 register unsigned char *new_argv;
1090 int len;
1091 #else
1092 register unsigned char **new_argv;
1093 #endif
1094 register int i;
1095 int count = specpdl_ptr - specpdl;
1097 buffer = args[1];
1098 if (!NILP (buffer))
1099 buffer = Fget_buffer_create (buffer);
1101 /* Make sure that the child will be able to chdir to the current
1102 buffer's current directory, or its unhandled equivalent. We
1103 can't just have the child check for an error when it does the
1104 chdir, since it's in a vfork.
1106 We have to GCPRO around this because Fexpand_file_name and
1107 Funhandled_file_name_directory might call a file name handling
1108 function. The argument list is protected by the caller, so all
1109 we really have to worry about is buffer. */
1111 struct gcpro gcpro1, gcpro2;
1113 current_dir = current_buffer->directory;
1115 GCPRO2 (buffer, current_dir);
1117 current_dir
1118 = expand_and_dir_to_file (Funhandled_file_name_directory (current_dir),
1119 Qnil);
1120 if (NILP (Ffile_accessible_directory_p (current_dir)))
1121 report_file_error ("Setting current directory",
1122 Fcons (current_buffer->directory, Qnil));
1124 UNGCPRO;
1127 name = args[0];
1128 CHECK_STRING (name, 0);
1130 program = args[2];
1132 CHECK_STRING (program, 2);
1134 #ifdef VMS
1135 /* Make a one member argv with all args concatenated
1136 together separated by a blank. */
1137 len = STRING_BYTES (XSTRING (program)) + 2;
1138 for (i = 3; i < nargs; i++)
1140 tem = args[i];
1141 CHECK_STRING (tem, i);
1142 len += STRING_BYTES (XSTRING (tem)) + 1; /* count the blank */
1144 new_argv = (unsigned char *) alloca (len);
1145 strcpy (new_argv, XSTRING (program)->data);
1146 for (i = 3; i < nargs; i++)
1148 tem = args[i];
1149 CHECK_STRING (tem, i);
1150 strcat (new_argv, " ");
1151 strcat (new_argv, XSTRING (tem)->data);
1153 /* Need to add code here to check for program existence on VMS */
1155 #else /* not VMS */
1156 new_argv = (unsigned char **) alloca ((nargs - 1) * sizeof (char *));
1158 /* If program file name is not absolute, search our path for it */
1159 if (!IS_DIRECTORY_SEP (XSTRING (program)->data[0])
1160 && !(XSTRING (program)->size > 1
1161 && IS_DEVICE_SEP (XSTRING (program)->data[1])))
1163 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
1165 tem = Qnil;
1166 GCPRO4 (name, program, buffer, current_dir);
1167 openp (Vexec_path, program, EXEC_SUFFIXES, &tem, 1);
1168 UNGCPRO;
1169 if (NILP (tem))
1170 report_file_error ("Searching for program", Fcons (program, Qnil));
1171 tem = Fexpand_file_name (tem, Qnil);
1172 new_argv[0] = XSTRING (tem)->data;
1174 else
1176 if (!NILP (Ffile_directory_p (program)))
1177 error ("Specified program for new process is a directory");
1179 new_argv[0] = XSTRING (program)->data;
1182 for (i = 3; i < nargs; i++)
1184 tem = args[i];
1185 CHECK_STRING (tem, i);
1186 new_argv[i - 2] = XSTRING (tem)->data;
1188 new_argv[i - 2] = 0;
1189 #endif /* not VMS */
1191 proc = make_process (name);
1192 /* If an error occurs and we can't start the process, we want to
1193 remove it from the process list. This means that each error
1194 check in create_process doesn't need to call remove_process
1195 itself; it's all taken care of here. */
1196 record_unwind_protect (start_process_unwind, proc);
1198 XPROCESS (proc)->childp = Qt;
1199 XPROCESS (proc)->command_channel_p = Qnil;
1200 XPROCESS (proc)->buffer = buffer;
1201 XPROCESS (proc)->sentinel = Qnil;
1202 XPROCESS (proc)->filter = Qnil;
1203 XPROCESS (proc)->command = Flist (nargs - 2, args + 2);
1205 /* Make the process marker point into the process buffer (if any). */
1206 if (!NILP (buffer))
1207 set_marker_both (XPROCESS (proc)->mark, buffer,
1208 BUF_ZV (XBUFFER (buffer)),
1209 BUF_ZV_BYTE (XBUFFER (buffer)));
1212 /* Decide coding systems for communicating with the process. Here
1213 we don't setup the structure coding_system nor pay attention to
1214 unibyte mode. They are done in create_process. */
1216 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
1217 Lisp_Object coding_systems = Qt;
1218 Lisp_Object val, *args2;
1219 struct gcpro gcpro1;
1221 val = Vcoding_system_for_read;
1222 if (NILP (val))
1224 args2 = (Lisp_Object *) alloca ((nargs + 1) * sizeof *args2);
1225 args2[0] = Qstart_process;
1226 for (i = 0; i < nargs; i++) args2[i + 1] = args[i];
1227 GCPRO1 (proc);
1228 coding_systems = Ffind_operation_coding_system (nargs + 1, args2);
1229 UNGCPRO;
1230 if (CONSP (coding_systems))
1231 val = XCAR (coding_systems);
1232 else if (CONSP (Vdefault_process_coding_system))
1233 val = XCAR (Vdefault_process_coding_system);
1235 XPROCESS (proc)->decode_coding_system = val;
1237 val = Vcoding_system_for_write;
1238 if (NILP (val))
1240 if (EQ (coding_systems, Qt))
1242 args2 = (Lisp_Object *) alloca ((nargs + 1) * sizeof args2);
1243 args2[0] = Qstart_process;
1244 for (i = 0; i < nargs; i++) args2[i + 1] = args[i];
1245 GCPRO1 (proc);
1246 coding_systems = Ffind_operation_coding_system (nargs + 1, args2);
1247 UNGCPRO;
1249 if (CONSP (coding_systems))
1250 val = XCDR (coding_systems);
1251 else if (CONSP (Vdefault_process_coding_system))
1252 val = XCDR (Vdefault_process_coding_system);
1254 XPROCESS (proc)->encode_coding_system = val;
1257 XPROCESS (proc)->decoding_buf = make_uninit_string (0);
1258 XPROCESS (proc)->decoding_carryover = make_number (0);
1259 XPROCESS (proc)->encoding_buf = make_uninit_string (0);
1260 XPROCESS (proc)->encoding_carryover = make_number (0);
1262 XPROCESS (proc)->inherit_coding_system_flag
1263 = (NILP (buffer) || !inherit_process_coding_system
1264 ? Qnil : Qt);
1266 create_process (proc, (char **) new_argv, current_dir);
1268 return unbind_to (count, proc);
1271 /* This function is the unwind_protect form for Fstart_process. If
1272 PROC doesn't have its pid set, then we know someone has signaled
1273 an error and the process wasn't started successfully, so we should
1274 remove it from the process list. */
1275 static Lisp_Object
1276 start_process_unwind (proc)
1277 Lisp_Object proc;
1279 if (!PROCESSP (proc))
1280 abort ();
1282 /* Was PROC started successfully? */
1283 if (XINT (XPROCESS (proc)->pid) <= 0)
1284 remove_process (proc);
1286 return Qnil;
1290 SIGTYPE
1291 create_process_1 (signo)
1292 int signo;
1294 #if defined (USG) && !defined (POSIX_SIGNALS)
1295 /* USG systems forget handlers when they are used;
1296 must reestablish each time */
1297 signal (signo, create_process_1);
1298 #endif /* USG */
1301 #if 0 /* This doesn't work; see the note before sigchld_handler. */
1302 #ifdef USG
1303 #ifdef SIGCHLD
1304 /* Mimic blocking of signals on system V, which doesn't really have it. */
1306 /* Nonzero means we got a SIGCHLD when it was supposed to be blocked. */
1307 int sigchld_deferred;
1309 SIGTYPE
1310 create_process_sigchld ()
1312 signal (SIGCHLD, create_process_sigchld);
1314 sigchld_deferred = 1;
1316 #endif
1317 #endif
1318 #endif
1320 #ifndef VMS /* VMS version of this function is in vmsproc.c. */
1321 void
1322 create_process (process, new_argv, current_dir)
1323 Lisp_Object process;
1324 char **new_argv;
1325 Lisp_Object current_dir;
1327 int pid, inchannel, outchannel;
1328 int sv[2];
1329 #ifdef POSIX_SIGNALS
1330 sigset_t procmask;
1331 sigset_t blocked;
1332 struct sigaction sigint_action;
1333 struct sigaction sigquit_action;
1334 #ifdef AIX
1335 struct sigaction sighup_action;
1336 #endif
1337 #else /* !POSIX_SIGNALS */
1338 #if 0
1339 #ifdef SIGCHLD
1340 SIGTYPE (*sigchld)();
1341 #endif
1342 #endif /* 0 */
1343 #endif /* !POSIX_SIGNALS */
1344 /* Use volatile to protect variables from being clobbered by longjmp. */
1345 volatile int forkin, forkout;
1346 volatile int pty_flag = 0;
1347 extern char **environ;
1348 Lisp_Object buffer = XPROCESS (process)->buffer;
1350 inchannel = outchannel = -1;
1352 #ifdef HAVE_PTYS
1353 if (!NILP (Vprocess_connection_type))
1354 outchannel = inchannel = allocate_pty ();
1356 if (inchannel >= 0)
1358 #ifndef USG
1359 /* On USG systems it does not work to open the pty's tty here
1360 and then close and reopen it in the child. */
1361 #ifdef O_NOCTTY
1362 /* Don't let this terminal become our controlling terminal
1363 (in case we don't have one). */
1364 forkout = forkin = open (pty_name, O_RDWR | O_NOCTTY, 0);
1365 #else
1366 forkout = forkin = open (pty_name, O_RDWR, 0);
1367 #endif
1368 if (forkin < 0)
1369 report_file_error ("Opening pty", Qnil);
1370 #else
1371 forkin = forkout = -1;
1372 #endif /* not USG */
1373 pty_flag = 1;
1375 else
1376 #endif /* HAVE_PTYS */
1377 #ifdef SKTPAIR
1379 if (socketpair (AF_UNIX, SOCK_STREAM, 0, sv) < 0)
1380 report_file_error ("Opening socketpair", Qnil);
1381 outchannel = inchannel = sv[0];
1382 forkout = forkin = sv[1];
1384 #else /* not SKTPAIR */
1386 int tem;
1387 tem = pipe (sv);
1388 if (tem < 0)
1389 report_file_error ("Creating pipe", Qnil);
1390 inchannel = sv[0];
1391 forkout = sv[1];
1392 tem = pipe (sv);
1393 if (tem < 0)
1395 close (inchannel);
1396 close (forkout);
1397 report_file_error ("Creating pipe", Qnil);
1399 outchannel = sv[1];
1400 forkin = sv[0];
1402 #endif /* not SKTPAIR */
1404 #if 0
1405 /* Replaced by close_process_descs */
1406 set_exclusive_use (inchannel);
1407 set_exclusive_use (outchannel);
1408 #endif
1410 /* Stride people say it's a mystery why this is needed
1411 as well as the O_NDELAY, but that it fails without this. */
1412 #if defined (STRIDE) || (defined (pfa) && defined (HAVE_PTYS))
1414 int one = 1;
1415 ioctl (inchannel, FIONBIO, &one);
1417 #endif
1419 #ifdef O_NONBLOCK
1420 fcntl (inchannel, F_SETFL, O_NONBLOCK);
1421 fcntl (outchannel, F_SETFL, O_NONBLOCK);
1422 #else
1423 #ifdef O_NDELAY
1424 fcntl (inchannel, F_SETFL, O_NDELAY);
1425 fcntl (outchannel, F_SETFL, O_NDELAY);
1426 #endif
1427 #endif
1429 /* Record this as an active process, with its channels.
1430 As a result, child_setup will close Emacs's side of the pipes. */
1431 chan_process[inchannel] = process;
1432 XSETINT (XPROCESS (process)->infd, inchannel);
1433 XSETINT (XPROCESS (process)->outfd, outchannel);
1434 /* Record the tty descriptor used in the subprocess. */
1435 if (forkin < 0)
1436 XPROCESS (process)->subtty = Qnil;
1437 else
1438 XSETFASTINT (XPROCESS (process)->subtty, forkin);
1439 XPROCESS (process)->pty_flag = (pty_flag ? Qt : Qnil);
1440 XPROCESS (process)->status = Qrun;
1441 if (!proc_decode_coding_system[inchannel])
1442 proc_decode_coding_system[inchannel]
1443 = (struct coding_system *) xmalloc (sizeof (struct coding_system));
1444 setup_coding_system (XPROCESS (process)->decode_coding_system,
1445 proc_decode_coding_system[inchannel]);
1446 if (!proc_encode_coding_system[outchannel])
1447 proc_encode_coding_system[outchannel]
1448 = (struct coding_system *) xmalloc (sizeof (struct coding_system));
1449 setup_coding_system (XPROCESS (process)->encode_coding_system,
1450 proc_encode_coding_system[outchannel]);
1452 if ((!NILP (buffer) && NILP (XBUFFER (buffer)->enable_multibyte_characters))
1453 || (NILP (buffer) && NILP (buffer_defaults.enable_multibyte_characters)))
1455 /* In unibyte mode, character code conversion should not take
1456 place but EOL conversion should. So, setup raw-text or one
1457 of the subsidiary according to the information just setup. */
1458 if (!NILP (XPROCESS (process)->decode_coding_system))
1459 setup_raw_text_coding_system (proc_decode_coding_system[inchannel]);
1460 if (!NILP (XPROCESS (process)->encode_coding_system))
1461 setup_raw_text_coding_system (proc_encode_coding_system[outchannel]);
1464 if (CODING_REQUIRE_ENCODING (proc_encode_coding_system[outchannel]))
1466 /* Here we encode arguments by the coding system used for
1467 sending data to the process. We don't support using
1468 different coding systems for encoding arguments and for
1469 encoding data sent to the process. */
1470 struct gcpro gcpro1;
1471 int i = 1;
1472 struct coding_system *coding = proc_encode_coding_system[outchannel];
1474 coding->mode |= CODING_MODE_LAST_BLOCK;
1475 GCPRO1 (process);
1476 while (new_argv[i] != 0)
1478 int len = strlen (new_argv[i]);
1479 int size = encoding_buffer_size (coding, len);
1480 unsigned char *buf = (unsigned char *) alloca (size);
1482 encode_coding (coding, (unsigned char *)new_argv[i], buf, len, size);
1483 buf[coding->produced] = 0;
1484 /* We don't have to free new_argv[i] because it points to a
1485 Lisp string given as an argument to `start-process'. */
1486 new_argv[i++] = (char *) buf;
1488 UNGCPRO;
1489 coding->mode &= ~CODING_MODE_LAST_BLOCK;
1492 /* Delay interrupts until we have a chance to store
1493 the new fork's pid in its process structure */
1494 #ifdef POSIX_SIGNALS
1495 sigemptyset (&blocked);
1496 #ifdef SIGCHLD
1497 sigaddset (&blocked, SIGCHLD);
1498 #endif
1499 #ifdef HAVE_VFORK
1500 /* On many hosts (e.g. Solaris 2.4), if a vforked child calls `signal',
1501 this sets the parent's signal handlers as well as the child's.
1502 So delay all interrupts whose handlers the child might munge,
1503 and record the current handlers so they can be restored later. */
1504 sigaddset (&blocked, SIGINT ); sigaction (SIGINT , 0, &sigint_action );
1505 sigaddset (&blocked, SIGQUIT); sigaction (SIGQUIT, 0, &sigquit_action);
1506 #ifdef AIX
1507 sigaddset (&blocked, SIGHUP ); sigaction (SIGHUP , 0, &sighup_action );
1508 #endif
1509 #endif /* HAVE_VFORK */
1510 sigprocmask (SIG_BLOCK, &blocked, &procmask);
1511 #else /* !POSIX_SIGNALS */
1512 #ifdef SIGCHLD
1513 #ifdef BSD4_1
1514 sighold (SIGCHLD);
1515 #else /* not BSD4_1 */
1516 #if defined (BSD_SYSTEM) || defined (UNIPLUS) || defined (HPUX)
1517 sigsetmask (sigmask (SIGCHLD));
1518 #else /* ordinary USG */
1519 #if 0
1520 sigchld_deferred = 0;
1521 sigchld = signal (SIGCHLD, create_process_sigchld);
1522 #endif
1523 #endif /* ordinary USG */
1524 #endif /* not BSD4_1 */
1525 #endif /* SIGCHLD */
1526 #endif /* !POSIX_SIGNALS */
1528 FD_SET (inchannel, &input_wait_mask);
1529 FD_SET (inchannel, &non_keyboard_wait_mask);
1530 if (inchannel > max_process_desc)
1531 max_process_desc = inchannel;
1533 /* Until we store the proper pid, enable sigchld_handler
1534 to recognize an unknown pid as standing for this process.
1535 It is very important not to let this `marker' value stay
1536 in the table after this function has returned; if it does
1537 it might cause call-process to hang and subsequent asynchronous
1538 processes to get their return values scrambled. */
1539 XSETINT (XPROCESS (process)->pid, -1);
1541 BLOCK_INPUT;
1544 /* child_setup must clobber environ on systems with true vfork.
1545 Protect it from permanent change. */
1546 char **save_environ = environ;
1548 current_dir = ENCODE_FILE (current_dir);
1550 #ifndef WINDOWSNT
1551 pid = vfork ();
1552 if (pid == 0)
1553 #endif /* not WINDOWSNT */
1555 int xforkin = forkin;
1556 int xforkout = forkout;
1558 #if 0 /* This was probably a mistake--it duplicates code later on,
1559 but fails to handle all the cases. */
1560 /* Make sure SIGCHLD is not blocked in the child. */
1561 sigsetmask (SIGEMPTYMASK);
1562 #endif
1564 /* Make the pty be the controlling terminal of the process. */
1565 #ifdef HAVE_PTYS
1566 /* First, disconnect its current controlling terminal. */
1567 #ifdef HAVE_SETSID
1568 /* We tried doing setsid only if pty_flag, but it caused
1569 process_set_signal to fail on SGI when using a pipe. */
1570 setsid ();
1571 /* Make the pty's terminal the controlling terminal. */
1572 if (pty_flag)
1574 #ifdef TIOCSCTTY
1575 /* We ignore the return value
1576 because faith@cs.unc.edu says that is necessary on Linux. */
1577 ioctl (xforkin, TIOCSCTTY, 0);
1578 #endif
1580 #else /* not HAVE_SETSID */
1581 #ifdef USG
1582 /* It's very important to call setpgrp here and no time
1583 afterwards. Otherwise, we lose our controlling tty which
1584 is set when we open the pty. */
1585 setpgrp ();
1586 #endif /* USG */
1587 #endif /* not HAVE_SETSID */
1588 #if defined (HAVE_TERMIOS) && defined (LDISC1)
1589 if (pty_flag && xforkin >= 0)
1591 struct termios t;
1592 tcgetattr (xforkin, &t);
1593 t.c_lflag = LDISC1;
1594 if (tcsetattr (xforkin, TCSANOW, &t) < 0)
1595 write (1, "create_process/tcsetattr LDISC1 failed\n", 39);
1597 #else
1598 #if defined (NTTYDISC) && defined (TIOCSETD)
1599 if (pty_flag && xforkin >= 0)
1601 /* Use new line discipline. */
1602 int ldisc = NTTYDISC;
1603 ioctl (xforkin, TIOCSETD, &ldisc);
1605 #endif
1606 #endif
1607 #ifdef TIOCNOTTY
1608 /* In 4.3BSD, the TIOCSPGRP bug has been fixed, and now you
1609 can do TIOCSPGRP only to the process's controlling tty. */
1610 if (pty_flag)
1612 /* I wonder: would just ioctl (0, TIOCNOTTY, 0) work here?
1613 I can't test it since I don't have 4.3. */
1614 int j = open ("/dev/tty", O_RDWR, 0);
1615 ioctl (j, TIOCNOTTY, 0);
1616 close (j);
1617 #ifndef USG
1618 /* In order to get a controlling terminal on some versions
1619 of BSD, it is necessary to put the process in pgrp 0
1620 before it opens the terminal. */
1621 #ifdef HAVE_SETPGID
1622 setpgid (0, 0);
1623 #else
1624 setpgrp (0, 0);
1625 #endif
1626 #endif
1628 #endif /* TIOCNOTTY */
1630 #if !defined (RTU) && !defined (UNIPLUS) && !defined (DONT_REOPEN_PTY)
1631 /*** There is a suggestion that this ought to be a
1632 conditional on TIOCSPGRP,
1633 or !(defined (HAVE_SETSID) && defined (TIOCSCTTY)).
1634 Trying the latter gave the wrong results on Debian GNU/Linux 1.1;
1635 that system does seem to need this code, even though
1636 both HAVE_SETSID and TIOCSCTTY are defined. */
1637 /* Now close the pty (if we had it open) and reopen it.
1638 This makes the pty the controlling terminal of the subprocess. */
1639 if (pty_flag)
1641 #ifdef SET_CHILD_PTY_PGRP
1642 int pgrp = getpid ();
1643 #endif
1645 /* I wonder if close (open (pty_name, ...)) would work? */
1646 if (xforkin >= 0)
1647 close (xforkin);
1648 xforkout = xforkin = open (pty_name, O_RDWR, 0);
1650 if (xforkin < 0)
1652 write (1, "Couldn't open the pty terminal ", 31);
1653 write (1, pty_name, strlen (pty_name));
1654 write (1, "\n", 1);
1655 _exit (1);
1658 #ifdef SET_CHILD_PTY_PGRP
1659 ioctl (xforkin, TIOCSPGRP, &pgrp);
1660 ioctl (xforkout, TIOCSPGRP, &pgrp);
1661 #endif
1663 #endif /* not UNIPLUS and not RTU and not DONT_REOPEN_PTY */
1665 #ifdef SETUP_SLAVE_PTY
1666 if (pty_flag)
1668 SETUP_SLAVE_PTY;
1670 #endif /* SETUP_SLAVE_PTY */
1671 #ifdef AIX
1672 /* On AIX, we've disabled SIGHUP above once we start a child on a pty.
1673 Now reenable it in the child, so it will die when we want it to. */
1674 if (pty_flag)
1675 signal (SIGHUP, SIG_DFL);
1676 #endif
1677 #endif /* HAVE_PTYS */
1679 signal (SIGINT, SIG_DFL);
1680 signal (SIGQUIT, SIG_DFL);
1682 /* Stop blocking signals in the child. */
1683 #ifdef POSIX_SIGNALS
1684 sigprocmask (SIG_SETMASK, &procmask, 0);
1685 #else /* !POSIX_SIGNALS */
1686 #ifdef SIGCHLD
1687 #ifdef BSD4_1
1688 sigrelse (SIGCHLD);
1689 #else /* not BSD4_1 */
1690 #if defined (BSD_SYSTEM) || defined (UNIPLUS) || defined (HPUX)
1691 sigsetmask (SIGEMPTYMASK);
1692 #else /* ordinary USG */
1693 #if 0
1694 signal (SIGCHLD, sigchld);
1695 #endif
1696 #endif /* ordinary USG */
1697 #endif /* not BSD4_1 */
1698 #endif /* SIGCHLD */
1699 #endif /* !POSIX_SIGNALS */
1701 if (pty_flag)
1702 child_setup_tty (xforkout);
1703 #ifdef WINDOWSNT
1704 pid = child_setup (xforkin, xforkout, xforkout,
1705 new_argv, 1, current_dir);
1706 #else /* not WINDOWSNT */
1707 child_setup (xforkin, xforkout, xforkout,
1708 new_argv, 1, current_dir);
1709 #endif /* not WINDOWSNT */
1711 environ = save_environ;
1714 UNBLOCK_INPUT;
1716 /* This runs in the Emacs process. */
1717 if (pid < 0)
1719 if (forkin >= 0)
1720 close (forkin);
1721 if (forkin != forkout && forkout >= 0)
1722 close (forkout);
1724 else
1726 /* vfork succeeded. */
1727 XSETFASTINT (XPROCESS (process)->pid, pid);
1729 #ifdef WINDOWSNT
1730 register_child (pid, inchannel);
1731 #endif /* WINDOWSNT */
1733 /* If the subfork execv fails, and it exits,
1734 this close hangs. I don't know why.
1735 So have an interrupt jar it loose. */
1736 stop_polling ();
1737 signal (SIGALRM, create_process_1);
1738 alarm (1);
1739 XPROCESS (process)->subtty = Qnil;
1740 if (forkin >= 0)
1741 close (forkin);
1742 alarm (0);
1743 start_polling ();
1744 if (forkin != forkout && forkout >= 0)
1745 close (forkout);
1747 #ifdef HAVE_PTYS
1748 if (pty_flag)
1749 XPROCESS (process)->tty_name = build_string (pty_name);
1750 else
1751 #endif
1752 XPROCESS (process)->tty_name = Qnil;
1755 /* Restore the signal state whether vfork succeeded or not.
1756 (We will signal an error, below, if it failed.) */
1757 #ifdef POSIX_SIGNALS
1758 #ifdef HAVE_VFORK
1759 /* Restore the parent's signal handlers. */
1760 sigaction (SIGINT, &sigint_action, 0);
1761 sigaction (SIGQUIT, &sigquit_action, 0);
1762 #ifdef AIX
1763 sigaction (SIGHUP, &sighup_action, 0);
1764 #endif
1765 #endif /* HAVE_VFORK */
1766 /* Stop blocking signals in the parent. */
1767 sigprocmask (SIG_SETMASK, &procmask, 0);
1768 #else /* !POSIX_SIGNALS */
1769 #ifdef SIGCHLD
1770 #ifdef BSD4_1
1771 sigrelse (SIGCHLD);
1772 #else /* not BSD4_1 */
1773 #if defined (BSD_SYSTEM) || defined (UNIPLUS) || defined (HPUX)
1774 sigsetmask (SIGEMPTYMASK);
1775 #else /* ordinary USG */
1776 #if 0
1777 signal (SIGCHLD, sigchld);
1778 /* Now really handle any of these signals
1779 that came in during this function. */
1780 if (sigchld_deferred)
1781 kill (getpid (), SIGCHLD);
1782 #endif
1783 #endif /* ordinary USG */
1784 #endif /* not BSD4_1 */
1785 #endif /* SIGCHLD */
1786 #endif /* !POSIX_SIGNALS */
1788 /* Now generate the error if vfork failed. */
1789 if (pid < 0)
1790 report_file_error ("Doing vfork", Qnil);
1792 #endif /* not VMS */
1794 #ifdef HAVE_SOCKETS
1796 /* open a TCP network connection to a given HOST/SERVICE. Treated
1797 exactly like a normal process when reading and writing. Only
1798 differences are in status display and process deletion. A network
1799 connection has no PID; you cannot signal it. All you can do is
1800 deactivate and close it via delete-process */
1802 DEFUN ("open-network-stream", Fopen_network_stream, Sopen_network_stream,
1803 4, 4, 0,
1804 "Open a TCP connection for a service to a host.\n\
1805 Returns a subprocess-object to represent the connection.\n\
1806 Input and output work as for subprocesses; `delete-process' closes it.\n\
1807 Args are NAME BUFFER HOST SERVICE.\n\
1808 NAME is name for process. It is modified if necessary to make it unique.\n\
1809 BUFFER is the buffer (or buffer-name) to associate with the process.\n\
1810 Process output goes at end of that buffer, unless you specify\n\
1811 an output stream or filter function to handle the output.\n\
1812 BUFFER may be also nil, meaning that this process is not associated\n\
1813 with any buffer\n\
1814 Third arg is name of the host to connect to, or its IP address.\n\
1815 Fourth arg SERVICE is name of the service desired, or an integer\n\
1816 specifying a port number to connect to.")
1817 (name, buffer, host, service)
1818 Lisp_Object name, buffer, host, service;
1820 Lisp_Object proc;
1821 #ifndef HAVE_GETADDRINFO
1822 struct sockaddr_in address;
1823 struct servent *svc_info;
1824 struct hostent *host_info_ptr, host_info;
1825 char *(addr_list[2]);
1826 IN_ADDR numeric_addr;
1827 int port;
1828 #else /* HAVE_GETADDRINFO */
1829 struct addrinfo hints, *res, *lres;
1830 int ret = 0;
1831 int xerrno = 0;
1832 char *portstring, portbuf[128];
1833 #endif /* HAVE_GETADDRINFO */
1834 int s = -1, outch, inch;
1835 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
1836 int retry = 0;
1837 int count = specpdl_ptr - specpdl;
1838 int count1;
1840 #ifdef WINDOWSNT
1841 /* Ensure socket support is loaded if available. */
1842 init_winsock (TRUE);
1843 #endif
1845 GCPRO4 (name, buffer, host, service);
1846 CHECK_STRING (name, 0);
1847 CHECK_STRING (host, 0);
1849 #ifdef HAVE_GETADDRINFO
1851 * SERVICE can either be a string or int.
1852 * Convert to a C string for later use by getaddrinfo.
1854 if (INTEGERP (service))
1856 sprintf (portbuf, "%d", XINT (service));
1857 portstring = portbuf;
1859 else
1861 CHECK_STRING (service, 0);
1862 portstring = XSTRING (service)->data;
1864 #else /* ! HAVE_GETADDRINFO */
1865 if (INTEGERP (service))
1866 port = htons ((unsigned short) XINT (service));
1867 else
1869 CHECK_STRING (service, 0);
1870 svc_info = getservbyname (XSTRING (service)->data, "tcp");
1871 if (svc_info == 0)
1872 error ("Unknown service \"%s\"", XSTRING (service)->data);
1873 port = svc_info->s_port;
1875 #endif /* ! HAVE_GETADDRINFO */
1878 /* Slow down polling to every ten seconds.
1879 Some kernels have a bug which causes retrying connect to fail
1880 after a connect. Polling can interfere with gethostbyname too. */
1881 #ifdef POLL_FOR_INPUT
1882 bind_polling_period (10);
1883 #endif
1885 #ifndef TERM
1886 #ifdef HAVE_GETADDRINFO
1888 immediate_quit = 1;
1889 QUIT;
1890 memset (&hints, 0, sizeof (hints));
1891 hints.ai_flags = 0;
1892 hints.ai_family = AF_UNSPEC;
1893 hints.ai_socktype = SOCK_STREAM;
1894 hints.ai_protocol = 0;
1895 ret = getaddrinfo (XSTRING (host)->data, portstring, &hints, &res);
1896 if (ret)
1898 error ("%s/%s %s", XSTRING (host)->data, portstring,
1899 strerror (ret));
1901 immediate_quit = 0;
1904 s = -1;
1905 count1 = specpdl_ptr - specpdl;
1906 record_unwind_protect (close_file_unwind, make_number (s));
1908 for (lres = res; lres; lres = lres->ai_next)
1910 s = socket (lres->ai_family, lres->ai_socktype, lres->ai_protocol);
1911 if (s < 0)
1912 continue;
1914 /* Kernel bugs (on Ultrix at least) cause lossage (not just EINTR)
1915 when connect is interrupted. So let's not let it get interrupted.
1916 Note we do not turn off polling, because polling is only used
1917 when not interrupt_input, and thus not normally used on the systems
1918 which have this bug. On systems which use polling, there's no way
1919 to quit if polling is turned off. */
1920 if (interrupt_input)
1921 unrequest_sigio ();
1923 immediate_quit = 1;
1924 QUIT;
1926 ret = connect (s, lres->ai_addr, lres->ai_addrlen);
1927 if (ret == 0)
1928 break;
1929 close (s);
1930 s = -1;
1933 freeaddrinfo (res);
1934 if (s < 0)
1936 if (interrupt_input)
1937 request_sigio ();
1939 errno = xerrno;
1940 report_file_error ("connection failed",
1941 Fcons (host, Fcons (name, Qnil)));
1943 #else /* ! HAVE_GETADDRINFO */
1945 while (1)
1947 #ifdef TRY_AGAIN
1948 h_errno = 0;
1949 #endif
1950 immediate_quit = 1;
1951 QUIT;
1952 host_info_ptr = gethostbyname (XSTRING (host)->data);
1953 immediate_quit = 0;
1954 #ifdef TRY_AGAIN
1955 if (! (host_info_ptr == 0 && h_errno == TRY_AGAIN))
1956 #endif
1957 break;
1958 Fsleep_for (make_number (1), Qnil);
1960 if (host_info_ptr == 0)
1961 /* Attempt to interpret host as numeric inet address */
1963 numeric_addr = inet_addr ((char *) XSTRING (host)->data);
1964 if (NUMERIC_ADDR_ERROR)
1965 error ("Unknown host \"%s\"", XSTRING (host)->data);
1967 host_info_ptr = &host_info;
1968 host_info.h_name = 0;
1969 host_info.h_aliases = 0;
1970 host_info.h_addrtype = AF_INET;
1971 #ifdef h_addr
1972 /* Older machines have only one address slot called h_addr.
1973 Newer machines have h_addr_list, but #define h_addr to
1974 be its first element. */
1975 host_info.h_addr_list = &(addr_list[0]);
1976 #endif
1977 host_info.h_addr = (char*)(&numeric_addr);
1978 addr_list[1] = 0;
1979 /* numeric_addr isn't null-terminated; it has fixed length. */
1980 host_info.h_length = sizeof (numeric_addr);
1983 bzero (&address, sizeof address);
1984 bcopy (host_info_ptr->h_addr, (char *) &address.sin_addr,
1985 host_info_ptr->h_length);
1986 address.sin_family = host_info_ptr->h_addrtype;
1987 address.sin_port = port;
1989 s = socket (host_info_ptr->h_addrtype, SOCK_STREAM, 0);
1990 if (s < 0)
1991 report_file_error ("error creating socket", Fcons (name, Qnil));
1993 count1 = specpdl_ptr - specpdl;
1994 record_unwind_protect (close_file_unwind, make_number (s));
1996 /* Kernel bugs (on Ultrix at least) cause lossage (not just EINTR)
1997 when connect is interrupted. So let's not let it get interrupted.
1998 Note we do not turn off polling, because polling is only used
1999 when not interrupt_input, and thus not normally used on the systems
2000 which have this bug. On systems which use polling, there's no way
2001 to quit if polling is turned off. */
2002 if (interrupt_input)
2003 unrequest_sigio ();
2005 loop:
2007 immediate_quit = 1;
2008 QUIT;
2010 if (connect (s, (struct sockaddr *) &address, sizeof address) == -1
2011 && errno != EISCONN)
2013 int xerrno = errno;
2015 immediate_quit = 0;
2017 if (errno == EINTR)
2018 goto loop;
2019 if (errno == EADDRINUSE && retry < 20)
2021 /* A delay here is needed on some FreeBSD systems,
2022 and it is harmless, since this retrying takes time anyway
2023 and should be infrequent. */
2024 Fsleep_for (make_number (1), Qnil);
2025 retry++;
2026 goto loop;
2029 /* Discard the unwind protect. */
2030 specpdl_ptr = specpdl + count1;
2032 close (s);
2034 if (interrupt_input)
2035 request_sigio ();
2037 errno = xerrno;
2038 report_file_error ("connection failed",
2039 Fcons (host, Fcons (name, Qnil)));
2041 #endif /* ! HAVE_GETADDRINFO */
2043 immediate_quit = 0;
2045 /* Discard the unwind protect. */
2046 specpdl_ptr = specpdl + count1;
2048 #ifdef POLL_FOR_INPUT
2049 unbind_to (count, Qnil);
2050 #endif
2052 if (interrupt_input)
2053 request_sigio ();
2055 #else /* TERM */
2056 s = connect_server (0);
2057 if (s < 0)
2058 report_file_error ("error creating socket", Fcons (name, Qnil));
2059 send_command (s, C_PORT, 0, "%s:%d", XSTRING (host)->data, ntohs (port));
2060 send_command (s, C_DUMB, 1, 0);
2061 #endif /* TERM */
2063 inch = s;
2064 outch = s;
2066 if (!NILP (buffer))
2067 buffer = Fget_buffer_create (buffer);
2068 proc = make_process (name);
2070 chan_process[inch] = proc;
2072 #ifdef O_NONBLOCK
2073 fcntl (inch, F_SETFL, O_NONBLOCK);
2074 #else
2075 #ifdef O_NDELAY
2076 fcntl (inch, F_SETFL, O_NDELAY);
2077 #endif
2078 #endif
2080 XPROCESS (proc)->childp = Fcons (host, Fcons (service, Qnil));
2081 XPROCESS (proc)->command_channel_p = Qnil;
2082 XPROCESS (proc)->buffer = buffer;
2083 XPROCESS (proc)->sentinel = Qnil;
2084 XPROCESS (proc)->filter = Qnil;
2085 XPROCESS (proc)->command = Qnil;
2086 XPROCESS (proc)->pid = Qnil;
2087 XSETINT (XPROCESS (proc)->infd, inch);
2088 XSETINT (XPROCESS (proc)->outfd, outch);
2089 XPROCESS (proc)->status = Qrun;
2090 FD_SET (inch, &input_wait_mask);
2091 FD_SET (inch, &non_keyboard_wait_mask);
2092 if (inch > max_process_desc)
2093 max_process_desc = inch;
2096 /* Setup coding systems for communicating with the network stream. */
2097 struct gcpro gcpro1;
2098 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
2099 Lisp_Object coding_systems = Qt;
2100 Lisp_Object args[5], val;
2102 if (!NILP (Vcoding_system_for_read))
2103 val = Vcoding_system_for_read;
2104 else if ((!NILP (buffer) && NILP (XBUFFER (buffer)->enable_multibyte_characters))
2105 || (NILP (buffer) && NILP (buffer_defaults.enable_multibyte_characters)))
2106 /* We dare not decode end-of-line format by setting VAL to
2107 Qraw_text, because the existing Emacs Lisp libraries
2108 assume that they receive bare code including a sequene of
2109 CR LF. */
2110 val = Qnil;
2111 else
2113 args[0] = Qopen_network_stream, args[1] = name,
2114 args[2] = buffer, args[3] = host, args[4] = service;
2115 GCPRO1 (proc);
2116 coding_systems = Ffind_operation_coding_system (5, args);
2117 UNGCPRO;
2118 if (CONSP (coding_systems))
2119 val = XCAR (coding_systems);
2120 else if (CONSP (Vdefault_process_coding_system))
2121 val = XCAR (Vdefault_process_coding_system);
2122 else
2123 val = Qnil;
2125 XPROCESS (proc)->decode_coding_system = val;
2127 if (!NILP (Vcoding_system_for_write))
2128 val = Vcoding_system_for_write;
2129 else if (NILP (current_buffer->enable_multibyte_characters))
2130 val = Qnil;
2131 else
2133 if (EQ (coding_systems, Qt))
2135 args[0] = Qopen_network_stream, args[1] = name,
2136 args[2] = buffer, args[3] = host, args[4] = service;
2137 GCPRO1 (proc);
2138 coding_systems = Ffind_operation_coding_system (5, args);
2139 UNGCPRO;
2141 if (CONSP (coding_systems))
2142 val = XCDR (coding_systems);
2143 else if (CONSP (Vdefault_process_coding_system))
2144 val = XCDR (Vdefault_process_coding_system);
2145 else
2146 val = Qnil;
2148 XPROCESS (proc)->encode_coding_system = val;
2151 if (!proc_decode_coding_system[inch])
2152 proc_decode_coding_system[inch]
2153 = (struct coding_system *) xmalloc (sizeof (struct coding_system));
2154 setup_coding_system (XPROCESS (proc)->decode_coding_system,
2155 proc_decode_coding_system[inch]);
2156 if (!proc_encode_coding_system[outch])
2157 proc_encode_coding_system[outch]
2158 = (struct coding_system *) xmalloc (sizeof (struct coding_system));
2159 setup_coding_system (XPROCESS (proc)->encode_coding_system,
2160 proc_encode_coding_system[outch]);
2162 XPROCESS (proc)->decoding_buf = make_uninit_string (0);
2163 XPROCESS (proc)->decoding_carryover = make_number (0);
2164 XPROCESS (proc)->encoding_buf = make_uninit_string (0);
2165 XPROCESS (proc)->encoding_carryover = make_number (0);
2167 XPROCESS (proc)->inherit_coding_system_flag
2168 = (NILP (buffer) || !inherit_process_coding_system
2169 ? Qnil : Qt);
2171 UNGCPRO;
2172 return proc;
2174 #endif /* HAVE_SOCKETS */
2176 void
2177 deactivate_process (proc)
2178 Lisp_Object proc;
2180 register int inchannel, outchannel;
2181 register struct Lisp_Process *p = XPROCESS (proc);
2183 inchannel = XINT (p->infd);
2184 outchannel = XINT (p->outfd);
2186 if (inchannel >= 0)
2188 /* Beware SIGCHLD hereabouts. */
2189 flush_pending_output (inchannel);
2190 #ifdef VMS
2192 VMS_PROC_STUFF *get_vms_process_pointer (), *vs;
2193 sys$dassgn (outchannel);
2194 vs = get_vms_process_pointer (p->pid);
2195 if (vs)
2196 give_back_vms_process_stuff (vs);
2198 #else
2199 close (inchannel);
2200 if (outchannel >= 0 && outchannel != inchannel)
2201 close (outchannel);
2202 #endif
2204 XSETINT (p->infd, -1);
2205 XSETINT (p->outfd, -1);
2206 chan_process[inchannel] = Qnil;
2207 FD_CLR (inchannel, &input_wait_mask);
2208 FD_CLR (inchannel, &non_keyboard_wait_mask);
2209 if (inchannel == max_process_desc)
2211 int i;
2212 /* We just closed the highest-numbered process input descriptor,
2213 so recompute the highest-numbered one now. */
2214 max_process_desc = 0;
2215 for (i = 0; i < MAXDESC; i++)
2216 if (!NILP (chan_process[i]))
2217 max_process_desc = i;
2222 /* Close all descriptors currently in use for communication
2223 with subprocess. This is used in a newly-forked subprocess
2224 to get rid of irrelevant descriptors. */
2226 void
2227 close_process_descs ()
2229 #ifndef WINDOWSNT
2230 int i;
2231 for (i = 0; i < MAXDESC; i++)
2233 Lisp_Object process;
2234 process = chan_process[i];
2235 if (!NILP (process))
2237 int in = XINT (XPROCESS (process)->infd);
2238 int out = XINT (XPROCESS (process)->outfd);
2239 if (in >= 0)
2240 close (in);
2241 if (out >= 0 && in != out)
2242 close (out);
2245 #endif
2248 DEFUN ("accept-process-output", Faccept_process_output, Saccept_process_output,
2249 0, 3, 0,
2250 "Allow any pending output from subprocesses to be read by Emacs.\n\
2251 It is read into the process' buffers or given to their filter functions.\n\
2252 Non-nil arg PROCESS means do not return until some output has been received\n\
2253 from PROCESS.\n\
2254 Non-nil second arg TIMEOUT and third arg TIMEOUT-MSECS are number of\n\
2255 seconds and microseconds to wait; return after that much time whether\n\
2256 or not there is input.\n\
2257 Return non-nil iff we received any output before the timeout expired.")
2258 (process, timeout, timeout_msecs)
2259 register Lisp_Object process, timeout, timeout_msecs;
2261 int seconds;
2262 int useconds;
2264 if (! NILP (process))
2265 CHECK_PROCESS (process, 0);
2267 if (! NILP (timeout_msecs))
2269 CHECK_NUMBER (timeout_msecs, 2);
2270 useconds = XINT (timeout_msecs);
2271 if (!INTEGERP (timeout))
2272 XSETINT (timeout, 0);
2275 int carry = useconds / 1000000;
2277 XSETINT (timeout, XINT (timeout) + carry);
2278 useconds -= carry * 1000000;
2280 /* I think this clause is necessary because C doesn't
2281 guarantee a particular rounding direction for negative
2282 integers. */
2283 if (useconds < 0)
2285 XSETINT (timeout, XINT (timeout) - 1);
2286 useconds += 1000000;
2290 else
2291 useconds = 0;
2293 if (! NILP (timeout))
2295 CHECK_NUMBER (timeout, 1);
2296 seconds = XINT (timeout);
2297 if (seconds < 0 || (seconds == 0 && useconds == 0))
2298 seconds = -1;
2300 else
2302 if (NILP (process))
2303 seconds = -1;
2304 else
2305 seconds = 0;
2308 if (NILP (process))
2309 XSETFASTINT (process, 0);
2311 return
2312 (wait_reading_process_input (seconds, useconds, process, 0)
2313 ? Qt : Qnil);
2316 /* This variable is different from waiting_for_input in keyboard.c.
2317 It is used to communicate to a lisp process-filter/sentinel (via the
2318 function Fwaiting_for_user_input_p below) whether emacs was waiting
2319 for user-input when that process-filter was called.
2320 waiting_for_input cannot be used as that is by definition 0 when
2321 lisp code is being evalled.
2322 This is also used in record_asynch_buffer_change.
2323 For that purpose, this must be 0
2324 when not inside wait_reading_process_input. */
2325 static int waiting_for_user_input_p;
2327 /* This is here so breakpoints can be put on it. */
2328 static void
2329 wait_reading_process_input_1 ()
2333 /* Read and dispose of subprocess output while waiting for timeout to
2334 elapse and/or keyboard input to be available.
2336 TIME_LIMIT is:
2337 timeout in seconds, or
2338 zero for no limit, or
2339 -1 means gobble data immediately available but don't wait for any.
2341 MICROSECS is:
2342 an additional duration to wait, measured in microseconds.
2343 If this is nonzero and time_limit is 0, then the timeout
2344 consists of MICROSECS only.
2346 READ_KBD is a lisp value:
2347 0 to ignore keyboard input, or
2348 1 to return when input is available, or
2349 -1 meaning caller will actually read the input, so don't throw to
2350 the quit handler, or
2351 a cons cell, meaning wait until its car is non-nil
2352 (and gobble terminal input into the buffer if any arrives), or
2353 a process object, meaning wait until something arrives from that
2354 process. The return value is true iff we read some input from
2355 that process.
2357 DO_DISPLAY != 0 means redisplay should be done to show subprocess
2358 output that arrives.
2360 If READ_KBD is a pointer to a struct Lisp_Process, then the
2361 function returns true iff we received input from that process
2362 before the timeout elapsed.
2363 Otherwise, return true iff we received input from any process. */
2366 wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
2367 int time_limit, microsecs;
2368 Lisp_Object read_kbd;
2369 int do_display;
2371 register int channel, nfds;
2372 static SELECT_TYPE Available;
2373 int xerrno;
2374 Lisp_Object proc;
2375 EMACS_TIME timeout, end_time;
2376 SELECT_TYPE Atemp;
2377 int wait_channel = -1;
2378 struct Lisp_Process *wait_proc = 0;
2379 int got_some_input = 0;
2380 Lisp_Object *wait_for_cell = 0;
2382 FD_ZERO (&Available);
2384 /* If read_kbd is a process to watch, set wait_proc and wait_channel
2385 accordingly. */
2386 if (PROCESSP (read_kbd))
2388 wait_proc = XPROCESS (read_kbd);
2389 wait_channel = XINT (wait_proc->infd);
2390 XSETFASTINT (read_kbd, 0);
2393 /* If waiting for non-nil in a cell, record where. */
2394 if (CONSP (read_kbd))
2396 wait_for_cell = &XCAR (read_kbd);
2397 XSETFASTINT (read_kbd, 0);
2400 waiting_for_user_input_p = XINT (read_kbd);
2402 /* Since we may need to wait several times,
2403 compute the absolute time to return at. */
2404 if (time_limit || microsecs)
2406 EMACS_GET_TIME (end_time);
2407 EMACS_SET_SECS_USECS (timeout, time_limit, microsecs);
2408 EMACS_ADD_TIME (end_time, end_time, timeout);
2410 #ifdef hpux
2411 /* AlainF 5-Jul-1996
2412 HP-UX 10.10 seem to have problems with signals coming in
2413 Causes "poll: interrupted system call" messages when Emacs is run
2414 in an X window
2415 Turn off periodic alarms (in case they are in use) */
2416 stop_polling ();
2417 #endif
2419 while (1)
2421 int timeout_reduced_for_timers = 0;
2423 #ifdef HAVE_X_WINDOWS
2424 if (display_busy_cursor_p)
2425 Fx_hide_busy_cursor (Qnil);
2426 #endif
2428 /* If calling from keyboard input, do not quit
2429 since we want to return C-g as an input character.
2430 Otherwise, do pending quit if requested. */
2431 if (XINT (read_kbd) >= 0)
2432 QUIT;
2434 /* Exit now if the cell we're waiting for became non-nil. */
2435 if (wait_for_cell && ! NILP (*wait_for_cell))
2436 break;
2438 /* Compute time from now till when time limit is up */
2439 /* Exit if already run out */
2440 if (time_limit == -1)
2442 /* -1 specified for timeout means
2443 gobble output available now
2444 but don't wait at all. */
2446 EMACS_SET_SECS_USECS (timeout, 0, 0);
2448 else if (time_limit || microsecs)
2450 EMACS_GET_TIME (timeout);
2451 EMACS_SUB_TIME (timeout, end_time, timeout);
2452 if (EMACS_TIME_NEG_P (timeout))
2453 break;
2455 else
2457 EMACS_SET_SECS_USECS (timeout, 100000, 0);
2460 /* Normally we run timers here.
2461 But not if wait_for_cell; in those cases,
2462 the wait is supposed to be short,
2463 and those callers cannot handle running arbitrary Lisp code here. */
2464 if (! wait_for_cell)
2466 EMACS_TIME timer_delay;
2467 int old_timers_run;
2469 retry:
2470 old_timers_run = timers_run;
2471 timer_delay = timer_check (1);
2472 if (timers_run != old_timers_run && do_display)
2474 redisplay_preserve_echo_area ();
2475 /* We must retry, since a timer may have requeued itself
2476 and that could alter the time_delay. */
2477 goto retry;
2480 /* If there is unread keyboard input, also return. */
2481 if (XINT (read_kbd) != 0
2482 && requeued_events_pending_p ())
2483 break;
2485 if (! EMACS_TIME_NEG_P (timer_delay) && time_limit != -1)
2487 EMACS_TIME difference;
2488 EMACS_SUB_TIME (difference, timer_delay, timeout);
2489 if (EMACS_TIME_NEG_P (difference))
2491 timeout = timer_delay;
2492 timeout_reduced_for_timers = 1;
2495 /* If time_limit is -1, we are not going to wait at all. */
2496 else if (time_limit != -1)
2498 /* This is so a breakpoint can be put here. */
2499 wait_reading_process_input_1 ();
2503 /* Cause C-g and alarm signals to take immediate action,
2504 and cause input available signals to zero out timeout.
2506 It is important that we do this before checking for process
2507 activity. If we get a SIGCHLD after the explicit checks for
2508 process activity, timeout is the only way we will know. */
2509 if (XINT (read_kbd) < 0)
2510 set_waiting_for_input (&timeout);
2512 /* If status of something has changed, and no input is
2513 available, notify the user of the change right away. After
2514 this explicit check, we'll let the SIGCHLD handler zap
2515 timeout to get our attention. */
2516 if (update_tick != process_tick && do_display)
2518 Atemp = input_wait_mask;
2519 EMACS_SET_SECS_USECS (timeout, 0, 0);
2520 if ((select (max (max_process_desc, max_keyboard_desc) + 1,
2521 &Atemp, (SELECT_TYPE *)0, (SELECT_TYPE *)0,
2522 &timeout)
2523 <= 0))
2525 /* It's okay for us to do this and then continue with
2526 the loop, since timeout has already been zeroed out. */
2527 clear_waiting_for_input ();
2528 status_notify ();
2532 /* Don't wait for output from a non-running process. */
2533 if (wait_proc != 0 && !NILP (wait_proc->raw_status_low))
2534 update_status (wait_proc);
2535 if (wait_proc != 0
2536 && ! EQ (wait_proc->status, Qrun))
2538 int nread, total_nread = 0;
2540 clear_waiting_for_input ();
2541 XSETPROCESS (proc, wait_proc);
2543 /* Read data from the process, until we exhaust it. */
2544 while (XINT (wait_proc->infd) >= 0)
2546 nread = read_process_output (proc, XINT (wait_proc->infd));
2548 if (nread == 0)
2549 break;
2551 if (0 < nread)
2552 total_nread += nread;
2553 #ifdef EIO
2554 else if (nread == -1 && EIO == errno)
2555 break;
2556 #endif
2557 #ifdef EAGAIN
2558 else if (nread == -1 && EAGAIN == errno)
2559 break;
2560 #endif
2561 #ifdef EWOULDBLOCK
2562 else if (nread == -1 && EWOULDBLOCK == errno)
2563 break;
2564 #endif
2566 if (total_nread > 0 && do_display)
2567 redisplay_preserve_echo_area ();
2569 break;
2572 /* Wait till there is something to do */
2574 if (wait_for_cell)
2575 Available = non_process_wait_mask;
2576 else if (! XINT (read_kbd))
2577 Available = non_keyboard_wait_mask;
2578 else
2579 Available = input_wait_mask;
2581 /* If frame size has changed or the window is newly mapped,
2582 redisplay now, before we start to wait. There is a race
2583 condition here; if a SIGIO arrives between now and the select
2584 and indicates that a frame is trashed, the select may block
2585 displaying a trashed screen. */
2586 if (frame_garbaged && do_display)
2588 clear_waiting_for_input ();
2589 redisplay_preserve_echo_area ();
2590 if (XINT (read_kbd) < 0)
2591 set_waiting_for_input (&timeout);
2594 if (XINT (read_kbd) && detect_input_pending ())
2596 nfds = 0;
2597 FD_ZERO (&Available);
2599 else
2600 nfds = select (max (max_process_desc, max_keyboard_desc) + 1,
2601 &Available, (SELECT_TYPE *)0, (SELECT_TYPE *)0,
2602 &timeout);
2604 xerrno = errno;
2606 /* Make C-g and alarm signals set flags again */
2607 clear_waiting_for_input ();
2609 /* If we woke up due to SIGWINCH, actually change size now. */
2610 do_pending_window_change (0);
2612 if (time_limit && nfds == 0 && ! timeout_reduced_for_timers)
2613 /* We wanted the full specified time, so return now. */
2614 break;
2615 if (nfds < 0)
2617 if (xerrno == EINTR)
2618 FD_ZERO (&Available);
2619 #ifdef ultrix
2620 /* Ultrix select seems to return ENOMEM when it is
2621 interrupted. Treat it just like EINTR. Bleah. Note
2622 that we want to test for the "ultrix" CPP symbol, not
2623 "__ultrix__"; the latter is only defined under GCC, but
2624 not by DEC's bundled CC. -JimB */
2625 else if (xerrno == ENOMEM)
2626 FD_ZERO (&Available);
2627 #endif
2628 #ifdef ALLIANT
2629 /* This happens for no known reason on ALLIANT.
2630 I am guessing that this is the right response. -- RMS. */
2631 else if (xerrno == EFAULT)
2632 FD_ZERO (&Available);
2633 #endif
2634 else if (xerrno == EBADF)
2636 #ifdef AIX
2637 /* AIX doesn't handle PTY closure the same way BSD does. On AIX,
2638 the child's closure of the pts gives the parent a SIGHUP, and
2639 the ptc file descriptor is automatically closed,
2640 yielding EBADF here or at select() call above.
2641 So, SIGHUP is ignored (see def of PTY_TTY_NAME_SPRINTF
2642 in m/ibmrt-aix.h), and here we just ignore the select error.
2643 Cleanup occurs c/o status_notify after SIGCLD. */
2644 FD_ZERO (&Available); /* Cannot depend on values returned */
2645 #else
2646 abort ();
2647 #endif
2649 else
2650 error ("select error: %s", strerror (xerrno));
2652 #if defined(sun) && !defined(USG5_4)
2653 else if (nfds > 0 && keyboard_bit_set (&Available)
2654 && interrupt_input)
2655 /* System sometimes fails to deliver SIGIO.
2657 David J. Mackenzie says that Emacs doesn't compile under
2658 Solaris if this code is enabled, thus the USG5_4 in the CPP
2659 conditional. "I haven't noticed any ill effects so far.
2660 If you find a Solaris expert somewhere, they might know
2661 better." */
2662 kill (getpid (), SIGIO);
2663 #endif
2665 #if 0 /* When polling is used, interrupt_input is 0,
2666 so get_input_pending should read the input.
2667 So this should not be needed. */
2668 /* If we are using polling for input,
2669 and we see input available, make it get read now.
2670 Otherwise it might not actually get read for a second.
2671 And on hpux, since we turn off polling in wait_reading_process_input,
2672 it might never get read at all if we don't spend much time
2673 outside of wait_reading_process_input. */
2674 if (XINT (read_kbd) && interrupt_input
2675 && keyboard_bit_set (&Available)
2676 && input_polling_used ())
2677 kill (getpid (), SIGALRM);
2678 #endif
2680 /* Check for keyboard input */
2681 /* If there is any, return immediately
2682 to give it higher priority than subprocesses */
2684 if (XINT (read_kbd) != 0
2685 && detect_input_pending_run_timers (do_display))
2687 swallow_events (do_display);
2688 if (detect_input_pending_run_timers (do_display))
2689 break;
2692 /* If there is unread keyboard input, also return. */
2693 if (XINT (read_kbd) != 0
2694 && requeued_events_pending_p ())
2695 break;
2697 /* If we are not checking for keyboard input now,
2698 do process events (but don't run any timers).
2699 This is so that X events will be processed.
2700 Otherwise they may have to wait until polling takes place.
2701 That would causes delays in pasting selections, for example.
2703 (We used to do this only if wait_for_cell.) */
2704 if (XINT (read_kbd) == 0 && detect_input_pending ())
2706 swallow_events (do_display);
2707 #if 0 /* Exiting when read_kbd doesn't request that seems wrong, though. */
2708 if (detect_input_pending ())
2709 break;
2710 #endif
2713 /* Exit now if the cell we're waiting for became non-nil. */
2714 if (wait_for_cell && ! NILP (*wait_for_cell))
2715 break;
2717 #ifdef SIGIO
2718 /* If we think we have keyboard input waiting, but didn't get SIGIO,
2719 go read it. This can happen with X on BSD after logging out.
2720 In that case, there really is no input and no SIGIO,
2721 but select says there is input. */
2723 if (XINT (read_kbd) && interrupt_input
2724 && keyboard_bit_set (&Available))
2725 kill (getpid (), SIGIO);
2726 #endif
2728 if (! wait_proc)
2729 got_some_input |= nfds > 0;
2731 /* If checking input just got us a size-change event from X,
2732 obey it now if we should. */
2733 if (XINT (read_kbd) || wait_for_cell)
2734 do_pending_window_change (0);
2736 /* Check for data from a process. */
2737 /* Really FIRST_PROC_DESC should be 0 on Unix,
2738 but this is safer in the short run. */
2739 for (channel = 0; channel <= max_process_desc; channel++)
2741 if (FD_ISSET (channel, &Available)
2742 && FD_ISSET (channel, &non_keyboard_wait_mask))
2744 int nread;
2746 /* If waiting for this channel, arrange to return as
2747 soon as no more input to be processed. No more
2748 waiting. */
2749 if (wait_channel == channel)
2751 wait_channel = -1;
2752 time_limit = -1;
2753 got_some_input = 1;
2755 proc = chan_process[channel];
2756 if (NILP (proc))
2757 continue;
2759 /* Read data from the process, starting with our
2760 buffered-ahead character if we have one. */
2762 nread = read_process_output (proc, channel);
2763 if (nread > 0)
2765 /* Since read_process_output can run a filter,
2766 which can call accept-process-output,
2767 don't try to read from any other processes
2768 before doing the select again. */
2769 FD_ZERO (&Available);
2771 if (do_display)
2772 redisplay_preserve_echo_area ();
2774 #ifdef EWOULDBLOCK
2775 else if (nread == -1 && errno == EWOULDBLOCK)
2777 #endif
2778 /* ISC 4.1 defines both EWOULDBLOCK and O_NONBLOCK,
2779 and Emacs uses O_NONBLOCK, so what we get is EAGAIN. */
2780 #ifdef O_NONBLOCK
2781 else if (nread == -1 && errno == EAGAIN)
2783 #else
2784 #ifdef O_NDELAY
2785 else if (nread == -1 && errno == EAGAIN)
2787 /* Note that we cannot distinguish between no input
2788 available now and a closed pipe.
2789 With luck, a closed pipe will be accompanied by
2790 subprocess termination and SIGCHLD. */
2791 else if (nread == 0 && !NETCONN_P (proc))
2793 #endif /* O_NDELAY */
2794 #endif /* O_NONBLOCK */
2795 #ifdef HAVE_PTYS
2796 /* On some OSs with ptys, when the process on one end of
2797 a pty exits, the other end gets an error reading with
2798 errno = EIO instead of getting an EOF (0 bytes read).
2799 Therefore, if we get an error reading and errno =
2800 EIO, just continue, because the child process has
2801 exited and should clean itself up soon (e.g. when we
2802 get a SIGCHLD).
2804 However, it has been known to happen that the SIGCHLD
2805 got lost. So raise the signl again just in case.
2806 It can't hurt. */
2807 else if (nread == -1 && errno == EIO)
2808 kill (getpid (), SIGCHLD);
2809 #endif /* HAVE_PTYS */
2810 /* If we can detect process termination, don't consider the process
2811 gone just because its pipe is closed. */
2812 #ifdef SIGCHLD
2813 else if (nread == 0 && !NETCONN_P (proc))
2815 #endif
2816 else
2818 /* Preserve status of processes already terminated. */
2819 XSETINT (XPROCESS (proc)->tick, ++process_tick);
2820 deactivate_process (proc);
2821 if (!NILP (XPROCESS (proc)->raw_status_low))
2822 update_status (XPROCESS (proc));
2823 if (EQ (XPROCESS (proc)->status, Qrun))
2824 XPROCESS (proc)->status
2825 = Fcons (Qexit, Fcons (make_number (256), Qnil));
2828 } /* end for each file descriptor */
2829 } /* end while exit conditions not met */
2831 waiting_for_user_input_p = 0;
2833 /* If calling from keyboard input, do not quit
2834 since we want to return C-g as an input character.
2835 Otherwise, do pending quit if requested. */
2836 if (XINT (read_kbd) >= 0)
2838 /* Prevent input_pending from remaining set if we quit. */
2839 clear_input_pending ();
2840 QUIT;
2842 #ifdef hpux
2843 /* AlainF 5-Jul-1996
2844 HP-UX 10.10 seems to have problems with signals coming in
2845 Causes "poll: interrupted system call" messages when Emacs is run
2846 in an X window
2847 Turn periodic alarms back on */
2848 start_polling ();
2849 #endif
2851 #ifdef HAVE_X_WINDOWS
2852 if (display_busy_cursor_p)
2853 if (!inhibit_busy_cursor)
2854 Fx_show_busy_cursor ();
2855 #endif
2857 return got_some_input;
2860 /* Given a list (FUNCTION ARGS...), apply FUNCTION to the ARGS. */
2862 static Lisp_Object
2863 read_process_output_call (fun_and_args)
2864 Lisp_Object fun_and_args;
2866 return apply1 (XCAR (fun_and_args), XCDR (fun_and_args));
2869 static Lisp_Object
2870 read_process_output_error_handler (error)
2871 Lisp_Object error;
2873 cmd_error_internal (error, "error in process filter: ");
2874 Vinhibit_quit = Qt;
2875 update_echo_area ();
2876 Fsleep_for (make_number (2), Qnil);
2879 /* Read pending output from the process channel,
2880 starting with our buffered-ahead character if we have one.
2881 Yield number of decoded characters read.
2883 This function reads at most 1024 characters.
2884 If you want to read all available subprocess output,
2885 you must call it repeatedly until it returns zero.
2887 The characters read are decoded according to PROC's coding-system
2888 for decoding. */
2891 read_process_output (proc, channel)
2892 Lisp_Object proc;
2893 register int channel;
2895 register int nchars, nbytes;
2896 char *chars;
2897 #ifdef VMS
2898 int chars_allocated = 0; /* If 1, `chars' should be freed later. */
2899 #else
2900 char buf[1024];
2901 #endif
2902 register Lisp_Object outstream;
2903 register struct buffer *old = current_buffer;
2904 register struct Lisp_Process *p = XPROCESS (proc);
2905 register int opoint;
2906 struct coding_system *coding = proc_decode_coding_system[channel];
2907 int chars_in_decoding_buf = 0; /* If 1, `chars' points
2908 XSTRING (p->decoding_buf)->data. */
2909 int carryover = XINT (p->decoding_carryover);
2911 #ifdef VMS
2912 VMS_PROC_STUFF *vs, *get_vms_process_pointer();
2914 vs = get_vms_process_pointer (p->pid);
2915 if (vs)
2917 if (!vs->iosb[0])
2918 return (0); /* Really weird if it does this */
2919 if (!(vs->iosb[0] & 1))
2920 return -1; /* I/O error */
2922 else
2923 error ("Could not get VMS process pointer");
2924 chars = vs->inputBuffer;
2925 nbytes = clean_vms_buffer (chars, vs->iosb[1]);
2926 if (nbytes <= 0)
2928 start_vms_process_read (vs); /* Crank up the next read on the process */
2929 return 1; /* Nothing worth printing, say we got 1 */
2931 if (carryover > 0)
2933 /* The data carried over in the previous decoding (which are at
2934 the tail of decoding buffer) should be prepended to the new
2935 data read to decode all together. */
2936 char *buf = (char *) xmalloc (nbytes + carryover);
2938 bcopy (XSTRING (p->decoding_buf)->data
2939 + STRING_BYTES (XSTRING (p->decoding_buf)) - carryover,
2940 buf, carryover);
2941 bcopy (chars, buf + carryover, nbytes);
2942 chars = buf;
2943 chars_allocated = 1;
2945 #else /* not VMS */
2947 if (carryover)
2948 /* See the comment above. */
2949 bcopy (XSTRING (p->decoding_buf)->data
2950 + STRING_BYTES (XSTRING (p->decoding_buf)) - carryover,
2951 buf, carryover);
2953 if (proc_buffered_char[channel] < 0)
2954 nbytes = read (channel, buf + carryover, (sizeof buf) - carryover);
2955 else
2957 buf[carryover] = proc_buffered_char[channel];
2958 proc_buffered_char[channel] = -1;
2959 nbytes = read (channel, buf + carryover + 1,
2960 (sizeof buf) - carryover - 1);
2961 if (nbytes < 0)
2962 nbytes = 1;
2963 else
2964 nbytes = nbytes + 1;
2966 chars = buf;
2967 #endif /* not VMS */
2969 XSETINT (p->decoding_carryover, 0);
2971 /* At this point, NBYTES holds number of characters just received
2972 (including the one in proc_buffered_char[channel]). */
2973 if (nbytes <= 0)
2975 if (nbytes < 0 || coding->mode & CODING_MODE_LAST_BLOCK)
2976 return nbytes;
2977 coding->mode |= CODING_MODE_LAST_BLOCK;
2980 /* Now set NBYTES how many bytes we must decode. */
2981 nbytes += carryover;
2982 nchars = nbytes;
2984 if (CODING_MAY_REQUIRE_DECODING (coding))
2986 int require = decoding_buffer_size (coding, nbytes);
2987 int result;
2989 if (STRING_BYTES (XSTRING (p->decoding_buf)) < require)
2990 p->decoding_buf = make_uninit_string (require);
2991 result = decode_coding (coding, chars, XSTRING (p->decoding_buf)->data,
2992 nbytes, STRING_BYTES (XSTRING (p->decoding_buf)));
2993 carryover = nbytes - coding->consumed;
2994 if (carryover > 0)
2996 /* Copy the carryover bytes to the end of p->decoding_buf, to
2997 be processed on the next read. Since decoding_buffer_size
2998 asks for an extra amount of space beyond the maximum
2999 expected for the output, there should always be sufficient
3000 space for the carryover (which is by definition a sequence
3001 of bytes that was not long enough to be decoded, and thus
3002 has a bounded length). */
3003 if (STRING_BYTES (XSTRING (p->decoding_buf))
3004 < coding->produced + carryover)
3005 abort ();
3006 bcopy (chars + coding->consumed,
3007 XSTRING (p->decoding_buf)->data
3008 + STRING_BYTES (XSTRING (p->decoding_buf)) - carryover,
3009 carryover);
3010 XSETINT (p->decoding_carryover, carryover);
3013 /* A new coding system might be found by `decode_coding'. */
3014 if (!EQ (p->decode_coding_system, coding->symbol))
3016 p->decode_coding_system = coding->symbol;
3018 /* Don't call setup_coding_system for
3019 proc_decode_coding_system[channel] here. It is done in
3020 detect_coding called via decode_coding above. */
3022 /* If a coding system for encoding is not yet decided, we set
3023 it as the same as coding-system for decoding.
3025 But, before doing that we must check if
3026 proc_encode_coding_system[p->outfd] surely points to a
3027 valid memory because p->outfd will be changed once EOF is
3028 sent to the process. */
3029 if (NILP (p->encode_coding_system)
3030 && proc_encode_coding_system[XINT (p->outfd)])
3032 p->encode_coding_system = coding->symbol;
3033 setup_coding_system (coding->symbol,
3034 proc_encode_coding_system[XINT (p->outfd)]);
3038 #ifdef VMS
3039 /* Now we don't need the contents of `chars'. */
3040 if (chars_allocated)
3041 free (chars);
3042 #endif
3043 if (coding->produced == 0)
3044 return 0;
3045 chars = (char *) XSTRING (p->decoding_buf)->data;
3046 nbytes = coding->produced;
3047 nchars = (coding->fake_multibyte
3048 ? multibyte_chars_in_text (chars, nbytes)
3049 : coding->produced_char);
3050 chars_in_decoding_buf = 1;
3052 else
3054 #ifdef VMS
3055 if (chars_allocated)
3057 /* Although we don't have to decode the received data, we
3058 must move it to an area which we don't have to free. */
3059 if (! STRINGP (p->decoding_buf)
3060 || STRING_BYTES (XSTRING (p->decoding_buf)) < nbytes)
3061 p->decoding_buf = make_uninit_string (nbytes);
3062 bcopy (chars, XSTRING (p->decoding_buf)->data, nbytes);
3063 free (chars);
3064 chars = XSTRING (p->decoding_buf)->data;
3065 chars_in_decoding_buf = 1;
3067 #endif
3068 nchars = multibyte_chars_in_text (chars, nbytes);
3071 Vlast_coding_system_used = coding->symbol;
3073 /* If the caller required, let the process associated buffer
3074 inherit the coding-system used to decode the process output. */
3075 if (! NILP (p->inherit_coding_system_flag)
3076 && !NILP (p->buffer) && !NILP (XBUFFER (p->buffer)->name))
3078 struct buffer *prev_buf = current_buffer;
3080 Fset_buffer (p->buffer);
3081 call1 (intern ("after-insert-file-set-buffer-file-coding-system"),
3082 make_number (nbytes));
3083 set_buffer_internal (prev_buf);
3086 /* Read and dispose of the process output. */
3087 outstream = p->filter;
3088 if (!NILP (outstream))
3090 /* We inhibit quit here instead of just catching it so that
3091 hitting ^G when a filter happens to be running won't screw
3092 it up. */
3093 int count = specpdl_ptr - specpdl;
3094 Lisp_Object odeactivate;
3095 Lisp_Object obuffer, okeymap;
3096 Lisp_Object text;
3097 int outer_running_asynch_code = running_asynch_code;
3098 int waiting = waiting_for_user_input_p;
3100 /* No need to gcpro these, because all we do with them later
3101 is test them for EQness, and none of them should be a string. */
3102 odeactivate = Vdeactivate_mark;
3103 XSETBUFFER (obuffer, current_buffer);
3104 okeymap = current_buffer->keymap;
3106 specbind (Qinhibit_quit, Qt);
3107 specbind (Qlast_nonmenu_event, Qt);
3109 /* In case we get recursively called,
3110 and we already saved the match data nonrecursively,
3111 save the same match data in safely recursive fashion. */
3112 if (outer_running_asynch_code)
3114 Lisp_Object tem;
3115 /* Don't clobber the CURRENT match data, either! */
3116 tem = Fmatch_data (Qnil, Qnil);
3117 restore_match_data ();
3118 record_unwind_protect (Fset_match_data, Fmatch_data (Qnil, Qnil));
3119 Fset_match_data (tem);
3122 /* For speed, if a search happens within this code,
3123 save the match data in a special nonrecursive fashion. */
3124 running_asynch_code = 1;
3126 /* The multibyteness of a string given to the filter is decided
3127 by which coding system we used for decoding. */
3128 if (coding->type == coding_type_no_conversion
3129 || coding->type == coding_type_raw_text)
3130 text = make_unibyte_string (chars, nbytes);
3131 else
3132 text = make_multibyte_string (chars, nchars, nbytes);
3134 internal_condition_case_1 (read_process_output_call,
3135 Fcons (outstream,
3136 Fcons (proc, Fcons (text, Qnil))),
3137 !NILP (Vdebug_on_error) ? Qnil : Qerror,
3138 read_process_output_error_handler);
3140 /* If we saved the match data nonrecursively, restore it now. */
3141 restore_match_data ();
3142 running_asynch_code = outer_running_asynch_code;
3144 /* Handling the process output should not deactivate the mark. */
3145 Vdeactivate_mark = odeactivate;
3147 /* Restore waiting_for_user_input_p as it was
3148 when we were called, in case the filter clobbered it. */
3149 waiting_for_user_input_p = waiting;
3151 #if 0 /* Call record_asynch_buffer_change unconditionally,
3152 because we might have changed minor modes or other things
3153 that affect key bindings. */
3154 if (! EQ (Fcurrent_buffer (), obuffer)
3155 || ! EQ (current_buffer->keymap, okeymap))
3156 #endif
3157 /* But do it only if the caller is actually going to read events.
3158 Otherwise there's no need to make him wake up, and it could
3159 cause trouble (for example it would make Fsit_for return). */
3160 if (waiting_for_user_input_p == -1)
3161 record_asynch_buffer_change ();
3163 #ifdef VMS
3164 start_vms_process_read (vs);
3165 #endif
3166 unbind_to (count, Qnil);
3167 return nchars;
3170 /* If no filter, write into buffer if it isn't dead. */
3171 if (!NILP (p->buffer) && !NILP (XBUFFER (p->buffer)->name))
3173 Lisp_Object old_read_only;
3174 int old_begv, old_zv;
3175 int old_begv_byte, old_zv_byte;
3176 Lisp_Object odeactivate;
3177 int before, before_byte;
3178 int opoint_byte;
3180 odeactivate = Vdeactivate_mark;
3182 Fset_buffer (p->buffer);
3183 opoint = PT;
3184 opoint_byte = PT_BYTE;
3185 old_read_only = current_buffer->read_only;
3186 old_begv = BEGV;
3187 old_zv = ZV;
3188 old_begv_byte = BEGV_BYTE;
3189 old_zv_byte = ZV_BYTE;
3191 current_buffer->read_only = Qnil;
3193 /* Insert new output into buffer
3194 at the current end-of-output marker,
3195 thus preserving logical ordering of input and output. */
3196 if (XMARKER (p->mark)->buffer)
3197 SET_PT_BOTH (clip_to_bounds (BEGV, marker_position (p->mark), ZV),
3198 clip_to_bounds (BEGV_BYTE, marker_byte_position (p->mark),
3199 ZV_BYTE));
3200 else
3201 SET_PT_BOTH (ZV, ZV_BYTE);
3202 before = PT;
3203 before_byte = PT_BYTE;
3205 /* If the output marker is outside of the visible region, save
3206 the restriction and widen. */
3207 if (! (BEGV <= PT && PT <= ZV))
3208 Fwiden ();
3210 if (NILP (current_buffer->enable_multibyte_characters))
3211 nchars = nbytes;
3213 /* Insert before markers in case we are inserting where
3214 the buffer's mark is, and the user's next command is Meta-y. */
3215 if (chars_in_decoding_buf)
3217 /* Since multibyteness of p->docoding_buf is corrupted, we
3218 can't use insert_from_string_before_markers. */
3219 char *temp_buf;
3221 temp_buf = (char *) alloca (nbytes);
3222 bcopy (XSTRING (p->decoding_buf)->data, temp_buf, nbytes);
3223 insert_before_markers (temp_buf, nbytes);
3225 else
3227 insert_1_both (chars, nchars, nbytes, 0, 1, 1);
3228 signal_after_change (opoint, 0, PT - opoint);
3230 set_marker_both (p->mark, p->buffer, PT, PT_BYTE);
3232 update_mode_lines++;
3234 /* Make sure opoint and the old restrictions
3235 float ahead of any new text just as point would. */
3236 if (opoint >= before)
3238 opoint += PT - before;
3239 opoint_byte += PT_BYTE - before_byte;
3241 if (old_begv > before)
3243 old_begv += PT - before;
3244 old_begv_byte += PT_BYTE - before_byte;
3246 if (old_zv >= before)
3248 old_zv += PT - before;
3249 old_zv_byte += PT_BYTE - before_byte;
3252 /* If the restriction isn't what it should be, set it. */
3253 if (old_begv != BEGV || old_zv != ZV)
3254 Fnarrow_to_region (make_number (old_begv), make_number (old_zv));
3256 /* Handling the process output should not deactivate the mark. */
3257 Vdeactivate_mark = odeactivate;
3259 current_buffer->read_only = old_read_only;
3260 SET_PT_BOTH (opoint, opoint_byte);
3261 set_buffer_internal (old);
3263 #ifdef VMS
3264 start_vms_process_read (vs);
3265 #endif
3266 return nbytes;
3269 DEFUN ("waiting-for-user-input-p", Fwaiting_for_user_input_p, Swaiting_for_user_input_p,
3270 0, 0, 0,
3271 "Returns non-nil if emacs is waiting for input from the user.\n\
3272 This is intended for use by asynchronous process output filters and sentinels.")
3275 return (waiting_for_user_input_p ? Qt : Qnil);
3278 /* Sending data to subprocess */
3280 jmp_buf send_process_frame;
3282 SIGTYPE
3283 send_process_trap ()
3285 #ifdef BSD4_1
3286 sigrelse (SIGPIPE);
3287 sigrelse (SIGALRM);
3288 #endif /* BSD4_1 */
3289 longjmp (send_process_frame, 1);
3292 /* Send some data to process PROC.
3293 BUF is the beginning of the data; LEN is the number of characters.
3294 OBJECT is the Lisp object that the data comes from.
3296 The data is encoded by PROC's coding-system for encoding before it
3297 is sent. But if the data ends at the middle of multi-byte
3298 representation, that incomplete sequence of bytes are sent without
3299 being encoded. Should we store them in a buffer to prepend them to
3300 the data send later? */
3302 void
3303 send_process (proc, buf, len, object)
3304 volatile Lisp_Object proc;
3305 unsigned char *buf;
3306 int len;
3307 Lisp_Object object;
3309 /* Use volatile to protect variables from being clobbered by longjmp. */
3310 int rv;
3311 volatile unsigned char *procname = XSTRING (XPROCESS (proc)->name)->data;
3312 struct coding_system *coding;
3313 struct gcpro gcpro1;
3314 int carryover = XINT (XPROCESS (proc)->encoding_carryover);
3316 GCPRO1 (object);
3318 #ifdef VMS
3319 struct Lisp_Process *p = XPROCESS (proc);
3320 VMS_PROC_STUFF *vs, *get_vms_process_pointer();
3321 #endif /* VMS */
3323 if (! NILP (XPROCESS (proc)->raw_status_low))
3324 update_status (XPROCESS (proc));
3325 if (! EQ (XPROCESS (proc)->status, Qrun))
3326 error ("Process %s not running", procname);
3327 if (XINT (XPROCESS (proc)->outfd) < 0)
3328 error ("Output file descriptor of %s is closed", procname);
3330 coding = proc_encode_coding_system[XINT (XPROCESS (proc)->outfd)];
3331 Vlast_coding_system_used = coding->symbol;
3333 if (CODING_REQUIRE_ENCODING (coding))
3335 int require = encoding_buffer_size (coding, len);
3336 int offset;
3337 unsigned char *temp_buf = NULL;
3339 /* Remember the offset of data because a string or a buffer may
3340 be relocated. Setting OFFSET to -1 means we don't have to
3341 care about relocation. */
3342 offset = (BUFFERP (object)
3343 ? BUF_PTR_BYTE_POS (XBUFFER (object), buf)
3344 : (STRINGP (object)
3345 ? buf - XSTRING (object)->data
3346 : -1));
3348 if (carryover > 0)
3350 temp_buf = (unsigned char *) xmalloc (len + carryover);
3352 if (offset >= 0)
3354 if (BUFFERP (object))
3355 buf = BUF_BYTE_ADDRESS (XBUFFER (object), offset);
3356 else if (STRINGP (object))
3357 buf = offset + XSTRING (object)->data;
3358 /* Now we don't have to care about relocation. */
3359 offset = -1;
3361 bcopy ((XSTRING (XPROCESS (proc)->encoding_buf)->data
3362 + STRING_BYTES (XSTRING (XPROCESS (proc)->encoding_buf))
3363 - carryover),
3364 temp_buf,
3365 carryover);
3366 bcopy (buf, temp_buf + carryover, len);
3367 buf = temp_buf;
3370 if (STRING_BYTES (XSTRING (XPROCESS (proc)->encoding_buf)) < require)
3372 XPROCESS (proc)->encoding_buf = make_uninit_string (require);
3374 if (offset >= 0)
3376 if (BUFFERP (object))
3377 buf = BUF_BYTE_ADDRESS (XBUFFER (object), offset);
3378 else if (STRINGP (object))
3379 buf = offset + XSTRING (object)->data;
3382 object = XPROCESS (proc)->encoding_buf;
3383 encode_coding (coding, buf, XSTRING (object)->data,
3384 len, STRING_BYTES (XSTRING (object)));
3385 len = coding->produced;
3386 buf = XSTRING (object)->data;
3387 if (temp_buf)
3388 xfree (temp_buf);
3391 #ifdef VMS
3392 vs = get_vms_process_pointer (p->pid);
3393 if (vs == 0)
3394 error ("Could not find this process: %x", p->pid);
3395 else if (write_to_vms_process (vs, buf, len))
3397 #else
3399 if (pty_max_bytes == 0)
3401 #if defined (HAVE_FPATHCONF) && defined (_PC_MAX_CANON)
3402 pty_max_bytes = fpathconf (XFASTINT (XPROCESS (proc)->outfd),
3403 _PC_MAX_CANON);
3404 if (pty_max_bytes < 0)
3405 pty_max_bytes = 250;
3406 #else
3407 pty_max_bytes = 250;
3408 #endif
3409 /* Deduct one, to leave space for the eof. */
3410 pty_max_bytes--;
3413 if (!setjmp (send_process_frame))
3414 while (len > 0)
3416 int this = len;
3417 SIGTYPE (*old_sigpipe)();
3419 /* Decide how much data we can send in one batch.
3420 Long lines need to be split into multiple batches. */
3421 if (!NILP (XPROCESS (proc)->pty_flag))
3423 /* Starting this at zero is always correct when not the first iteration
3424 because the previous iteration ended by sending C-d.
3425 It may not be correct for the first iteration
3426 if a partial line was sent in a separate send_process call.
3427 If that proves worth handling, we need to save linepos
3428 in the process object. */
3429 int linepos = 0;
3430 unsigned char *ptr = buf;
3431 unsigned char *end = buf + len;
3433 /* Scan through this text for a line that is too long. */
3434 while (ptr != end && linepos < pty_max_bytes)
3436 if (*ptr == '\n')
3437 linepos = 0;
3438 else
3439 linepos++;
3440 ptr++;
3442 /* If we found one, break the line there
3443 and put in a C-d to force the buffer through. */
3444 this = ptr - buf;
3447 /* Send this batch, using one or more write calls. */
3448 while (this > 0)
3450 old_sigpipe = (SIGTYPE (*) ()) signal (SIGPIPE, send_process_trap);
3451 rv = write (XINT (XPROCESS (proc)->outfd), buf, this);
3452 signal (SIGPIPE, old_sigpipe);
3454 if (rv < 0)
3456 if (0
3457 #ifdef EWOULDBLOCK
3458 || errno == EWOULDBLOCK
3459 #endif
3460 #ifdef EAGAIN
3461 || errno == EAGAIN
3462 #endif
3464 /* Buffer is full. Wait, accepting input;
3465 that may allow the program
3466 to finish doing output and read more. */
3468 Lisp_Object zero;
3469 int offset;
3471 /* Running filters might relocate buffers or strings.
3472 Arrange to relocate BUF. */
3473 if (BUFFERP (object))
3474 offset = BUF_PTR_BYTE_POS (XBUFFER (object), buf);
3475 else if (STRINGP (object))
3476 offset = buf - XSTRING (object)->data;
3478 XSETFASTINT (zero, 0);
3479 #ifdef EMACS_HAS_USECS
3480 wait_reading_process_input (0, 20000, zero, 0);
3481 #else
3482 wait_reading_process_input (1, 0, zero, 0);
3483 #endif
3485 if (BUFFERP (object))
3486 buf = BUF_BYTE_ADDRESS (XBUFFER (object), offset);
3487 else if (STRINGP (object))
3488 buf = offset + XSTRING (object)->data;
3490 rv = 0;
3492 else
3493 /* This is a real error. */
3494 report_file_error ("writing to process", Fcons (proc, Qnil));
3496 buf += rv;
3497 len -= rv;
3498 this -= rv;
3501 /* If we sent just part of the string, put in an EOF
3502 to force it through, before we send the rest. */
3503 if (len > 0)
3504 Fprocess_send_eof (proc);
3506 #endif
3507 else
3509 XPROCESS (proc)->raw_status_low = Qnil;
3510 XPROCESS (proc)->raw_status_high = Qnil;
3511 XPROCESS (proc)->status = Fcons (Qexit, Fcons (make_number (256), Qnil));
3512 XSETINT (XPROCESS (proc)->tick, ++process_tick);
3513 deactivate_process (proc);
3514 #ifdef VMS
3515 error ("Error writing to process %s; closed it", procname);
3516 #else
3517 error ("SIGPIPE raised on process %s; closed it", procname);
3518 #endif
3521 UNGCPRO;
3524 DEFUN ("process-send-region", Fprocess_send_region, Sprocess_send_region,
3525 3, 3, 0,
3526 "Send current contents of region as input to PROCESS.\n\
3527 PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
3528 nil, indicating the current buffer's process.\n\
3529 Called from program, takes three arguments, PROCESS, START and END.\n\
3530 If the region is more than 500 characters long,\n\
3531 it is sent in several bunches. This may happen even for shorter regions.\n\
3532 Output from processes can arrive in between bunches.")
3533 (process, start, end)
3534 Lisp_Object process, start, end;
3536 Lisp_Object proc;
3537 int start1, end1;
3539 proc = get_process (process);
3540 validate_region (&start, &end);
3542 if (XINT (start) < GPT && XINT (end) > GPT)
3543 move_gap (XINT (start));
3545 start1 = CHAR_TO_BYTE (XINT (start));
3546 end1 = CHAR_TO_BYTE (XINT (end));
3547 send_process (proc, BYTE_POS_ADDR (start1), end1 - start1,
3548 Fcurrent_buffer ());
3550 return Qnil;
3553 DEFUN ("process-send-string", Fprocess_send_string, Sprocess_send_string,
3554 2, 2, 0,
3555 "Send PROCESS the contents of STRING as input.\n\
3556 PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
3557 nil, indicating the current buffer's process.\n\
3558 If STRING is more than 500 characters long,\n\
3559 it is sent in several bunches. This may happen even for shorter strings.\n\
3560 Output from processes can arrive in between bunches.")
3561 (process, string)
3562 Lisp_Object process, string;
3564 Lisp_Object proc;
3565 CHECK_STRING (string, 1);
3566 proc = get_process (process);
3567 send_process (proc, XSTRING (string)->data,
3568 STRING_BYTES (XSTRING (string)), string);
3569 return Qnil;
3572 DEFUN ("process-running-child-p", Fprocess_running_child_p,
3573 Sprocess_running_child_p, 0, 1, 0,
3574 "Return t if PROCESS has given the terminal to a child.\n\
3575 If the operating system does not make it possible to find out,\n\
3576 return t unconditionally.")
3577 (process)
3578 Lisp_Object process;
3580 /* Initialize in case ioctl doesn't exist or gives an error,
3581 in a way that will cause returning t. */
3582 int gid = 0;
3583 Lisp_Object proc;
3584 struct Lisp_Process *p;
3586 proc = get_process (process);
3587 p = XPROCESS (proc);
3589 if (!EQ (p->childp, Qt))
3590 error ("Process %s is not a subprocess",
3591 XSTRING (p->name)->data);
3592 if (XINT (p->infd) < 0)
3593 error ("Process %s is not active",
3594 XSTRING (p->name)->data);
3596 #ifdef TIOCGPGRP
3597 if (!NILP (p->subtty))
3598 ioctl (XFASTINT (p->subtty), TIOCGPGRP, &gid);
3599 else
3600 ioctl (XINT (p->infd), TIOCGPGRP, &gid);
3601 #endif /* defined (TIOCGPGRP ) */
3603 if (gid == XFASTINT (p->pid))
3604 return Qnil;
3605 return Qt;
3608 /* send a signal number SIGNO to PROCESS.
3609 If CURRENT_GROUP is t, that means send to the process group
3610 that currently owns the terminal being used to communicate with PROCESS.
3611 This is used for various commands in shell mode.
3612 If CURRENT_GROUP is lambda, that means send to the process group
3613 that currently owns the terminal, but only if it is NOT the shell itself.
3615 If NOMSG is zero, insert signal-announcements into process's buffers
3616 right away.
3618 If we can, we try to signal PROCESS by sending control characters
3619 down the pty. This allows us to signal inferiors who have changed
3620 their uid, for which killpg would return an EPERM error. */
3622 static void
3623 process_send_signal (process, signo, current_group, nomsg)
3624 Lisp_Object process;
3625 int signo;
3626 Lisp_Object current_group;
3627 int nomsg;
3629 Lisp_Object proc;
3630 register struct Lisp_Process *p;
3631 int gid;
3632 int no_pgrp = 0;
3634 proc = get_process (process);
3635 p = XPROCESS (proc);
3637 if (!EQ (p->childp, Qt))
3638 error ("Process %s is not a subprocess",
3639 XSTRING (p->name)->data);
3640 if (XINT (p->infd) < 0)
3641 error ("Process %s is not active",
3642 XSTRING (p->name)->data);
3644 if (NILP (p->pty_flag))
3645 current_group = Qnil;
3647 /* If we are using pgrps, get a pgrp number and make it negative. */
3648 if (!NILP (current_group))
3650 #ifdef SIGNALS_VIA_CHARACTERS
3651 /* If possible, send signals to the entire pgrp
3652 by sending an input character to it. */
3654 /* TERMIOS is the latest and bestest, and seems most likely to
3655 work. If the system has it, use it. */
3656 #ifdef HAVE_TERMIOS
3657 struct termios t;
3659 switch (signo)
3661 case SIGINT:
3662 tcgetattr (XINT (p->infd), &t);
3663 send_process (proc, &t.c_cc[VINTR], 1, Qnil);
3664 return;
3666 case SIGQUIT:
3667 tcgetattr (XINT (p->infd), &t);
3668 send_process (proc, &t.c_cc[VQUIT], 1, Qnil);
3669 return;
3671 case SIGTSTP:
3672 tcgetattr (XINT (p->infd), &t);
3673 #if defined (VSWTCH) && !defined (PREFER_VSUSP)
3674 send_process (proc, &t.c_cc[VSWTCH], 1, Qnil);
3675 #else
3676 send_process (proc, &t.c_cc[VSUSP], 1, Qnil);
3677 #endif
3678 return;
3681 #else /* ! HAVE_TERMIOS */
3683 /* On Berkeley descendants, the following IOCTL's retrieve the
3684 current control characters. */
3685 #if defined (TIOCGLTC) && defined (TIOCGETC)
3687 struct tchars c;
3688 struct ltchars lc;
3690 switch (signo)
3692 case SIGINT:
3693 ioctl (XINT (p->infd), TIOCGETC, &c);
3694 send_process (proc, &c.t_intrc, 1, Qnil);
3695 return;
3696 case SIGQUIT:
3697 ioctl (XINT (p->infd), TIOCGETC, &c);
3698 send_process (proc, &c.t_quitc, 1, Qnil);
3699 return;
3700 #ifdef SIGTSTP
3701 case SIGTSTP:
3702 ioctl (XINT (p->infd), TIOCGLTC, &lc);
3703 send_process (proc, &lc.t_suspc, 1, Qnil);
3704 return;
3705 #endif /* ! defined (SIGTSTP) */
3708 #else /* ! defined (TIOCGLTC) && defined (TIOCGETC) */
3710 /* On SYSV descendants, the TCGETA ioctl retrieves the current control
3711 characters. */
3712 #ifdef TCGETA
3713 struct termio t;
3714 switch (signo)
3716 case SIGINT:
3717 ioctl (XINT (p->infd), TCGETA, &t);
3718 send_process (proc, &t.c_cc[VINTR], 1, Qnil);
3719 return;
3720 case SIGQUIT:
3721 ioctl (XINT (p->infd), TCGETA, &t);
3722 send_process (proc, &t.c_cc[VQUIT], 1, Qnil);
3723 return;
3724 #ifdef SIGTSTP
3725 case SIGTSTP:
3726 ioctl (XINT (p->infd), TCGETA, &t);
3727 send_process (proc, &t.c_cc[VSWTCH], 1, Qnil);
3728 return;
3729 #endif /* ! defined (SIGTSTP) */
3731 #else /* ! defined (TCGETA) */
3732 Your configuration files are messed up.
3733 /* If your system configuration files define SIGNALS_VIA_CHARACTERS,
3734 you'd better be using one of the alternatives above! */
3735 #endif /* ! defined (TCGETA) */
3736 #endif /* ! defined (TIOCGLTC) && defined (TIOCGETC) */
3737 #endif /* ! defined HAVE_TERMIOS */
3738 #endif /* ! defined (SIGNALS_VIA_CHARACTERS) */
3740 #ifdef TIOCGPGRP
3741 /* Get the pgrp using the tty itself, if we have that.
3742 Otherwise, use the pty to get the pgrp.
3743 On pfa systems, saka@pfu.fujitsu.co.JP writes:
3744 "TIOCGPGRP symbol defined in sys/ioctl.h at E50.
3745 But, TIOCGPGRP does not work on E50 ;-P works fine on E60"
3746 His patch indicates that if TIOCGPGRP returns an error, then
3747 we should just assume that p->pid is also the process group id. */
3749 int err;
3751 if (!NILP (p->subtty))
3752 err = ioctl (XFASTINT (p->subtty), TIOCGPGRP, &gid);
3753 else
3754 err = ioctl (XINT (p->infd), TIOCGPGRP, &gid);
3756 #ifdef pfa
3757 if (err == -1)
3758 gid = - XFASTINT (p->pid);
3759 #endif /* ! defined (pfa) */
3761 if (gid == -1)
3762 no_pgrp = 1;
3763 else
3764 gid = - gid;
3765 #else /* ! defined (TIOCGPGRP ) */
3766 /* Can't select pgrps on this system, so we know that
3767 the child itself heads the pgrp. */
3768 gid = - XFASTINT (p->pid);
3769 #endif /* ! defined (TIOCGPGRP ) */
3771 /* If current_group is lambda, and the shell owns the terminal,
3772 don't send any signal. */
3773 if (EQ (current_group, Qlambda) && gid == - XFASTINT (p->pid))
3774 return;
3776 else
3777 gid = - XFASTINT (p->pid);
3779 switch (signo)
3781 #ifdef SIGCONT
3782 case SIGCONT:
3783 p->raw_status_low = Qnil;
3784 p->raw_status_high = Qnil;
3785 p->status = Qrun;
3786 XSETINT (p->tick, ++process_tick);
3787 if (!nomsg)
3788 status_notify ();
3789 break;
3790 #endif /* ! defined (SIGCONT) */
3791 case SIGINT:
3792 #ifdef VMS
3793 send_process (proc, "\003", 1, Qnil); /* ^C */
3794 goto whoosh;
3795 #endif
3796 case SIGQUIT:
3797 #ifdef VMS
3798 send_process (proc, "\031", 1, Qnil); /* ^Y */
3799 goto whoosh;
3800 #endif
3801 case SIGKILL:
3802 #ifdef VMS
3803 sys$forcex (&(XFASTINT (p->pid)), 0, 1);
3804 whoosh:
3805 #endif
3806 flush_pending_output (XINT (p->infd));
3807 break;
3810 /* If we don't have process groups, send the signal to the immediate
3811 subprocess. That isn't really right, but it's better than any
3812 obvious alternative. */
3813 if (no_pgrp)
3815 kill (XFASTINT (p->pid), signo);
3816 return;
3819 /* gid may be a pid, or minus a pgrp's number */
3820 #ifdef TIOCSIGSEND
3821 if (!NILP (current_group))
3822 ioctl (XINT (p->infd), TIOCSIGSEND, signo);
3823 else
3825 gid = - XFASTINT (p->pid);
3826 kill (gid, signo);
3828 #else /* ! defined (TIOCSIGSEND) */
3829 EMACS_KILLPG (-gid, signo);
3830 #endif /* ! defined (TIOCSIGSEND) */
3833 DEFUN ("interrupt-process", Finterrupt_process, Sinterrupt_process, 0, 2, 0,
3834 "Interrupt process PROCESS.\n\
3835 PROCESS may be a process, a buffer, or the name of a process or buffer.\n\
3836 nil or no arg means current buffer's process.\n\
3837 Second arg CURRENT-GROUP non-nil means send signal to\n\
3838 the current process-group of the process's controlling terminal\n\
3839 rather than to the process's own process group.\n\
3840 If the process is a shell, this means interrupt current subjob\n\
3841 rather than the shell.\n\
3843 If CURRENT-GROUP is `lambda', and if the shell owns the terminal,\n\
3844 don't send the signal.")
3845 (process, current_group)
3846 Lisp_Object process, current_group;
3848 process_send_signal (process, SIGINT, current_group, 0);
3849 return process;
3852 DEFUN ("kill-process", Fkill_process, Skill_process, 0, 2, 0,
3853 "Kill process PROCESS. May be process or name of one.\n\
3854 See function `interrupt-process' for more details on usage.")
3855 (process, current_group)
3856 Lisp_Object process, current_group;
3858 process_send_signal (process, SIGKILL, current_group, 0);
3859 return process;
3862 DEFUN ("quit-process", Fquit_process, Squit_process, 0, 2, 0,
3863 "Send QUIT signal to process PROCESS. May be process or name of one.\n\
3864 See function `interrupt-process' for more details on usage.")
3865 (process, current_group)
3866 Lisp_Object process, current_group;
3868 process_send_signal (process, SIGQUIT, current_group, 0);
3869 return process;
3872 DEFUN ("stop-process", Fstop_process, Sstop_process, 0, 2, 0,
3873 "Stop process PROCESS. May be process or name of one.\n\
3874 See function `interrupt-process' for more details on usage.")
3875 (process, current_group)
3876 Lisp_Object process, current_group;
3878 #ifndef SIGTSTP
3879 error ("no SIGTSTP support");
3880 #else
3881 process_send_signal (process, SIGTSTP, current_group, 0);
3882 #endif
3883 return process;
3886 DEFUN ("continue-process", Fcontinue_process, Scontinue_process, 0, 2, 0,
3887 "Continue process PROCESS. May be process or name of one.\n\
3888 See function `interrupt-process' for more details on usage.")
3889 (process, current_group)
3890 Lisp_Object process, current_group;
3892 #ifdef SIGCONT
3893 process_send_signal (process, SIGCONT, current_group, 0);
3894 #else
3895 error ("no SIGCONT support");
3896 #endif
3897 return process;
3900 DEFUN ("signal-process", Fsignal_process, Ssignal_process,
3901 2, 2, "nProcess number: \nnSignal code: ",
3902 "Send the process with process id PID the signal with code SIGCODE.\n\
3903 PID must be an integer. The process need not be a child of this Emacs.\n\
3904 SIGCODE may be an integer, or a symbol whose name is a signal name.")
3905 (pid, sigcode)
3906 Lisp_Object pid, sigcode;
3908 CHECK_NUMBER (pid, 0);
3910 #define handle_signal(NAME, VALUE) \
3911 else if (!strcmp (name, NAME)) \
3912 XSETINT (sigcode, VALUE)
3914 if (INTEGERP (sigcode))
3916 else
3918 unsigned char *name;
3920 CHECK_SYMBOL (sigcode, 1);
3921 name = XSYMBOL (sigcode)->name->data;
3923 if (0)
3925 #ifdef SIGHUP
3926 handle_signal ("SIGHUP", SIGHUP);
3927 #endif
3928 #ifdef SIGINT
3929 handle_signal ("SIGINT", SIGINT);
3930 #endif
3931 #ifdef SIGQUIT
3932 handle_signal ("SIGQUIT", SIGQUIT);
3933 #endif
3934 #ifdef SIGILL
3935 handle_signal ("SIGILL", SIGILL);
3936 #endif
3937 #ifdef SIGABRT
3938 handle_signal ("SIGABRT", SIGABRT);
3939 #endif
3940 #ifdef SIGEMT
3941 handle_signal ("SIGEMT", SIGEMT);
3942 #endif
3943 #ifdef SIGKILL
3944 handle_signal ("SIGKILL", SIGKILL);
3945 #endif
3946 #ifdef SIGFPE
3947 handle_signal ("SIGFPE", SIGFPE);
3948 #endif
3949 #ifdef SIGBUS
3950 handle_signal ("SIGBUS", SIGBUS);
3951 #endif
3952 #ifdef SIGSEGV
3953 handle_signal ("SIGSEGV", SIGSEGV);
3954 #endif
3955 #ifdef SIGSYS
3956 handle_signal ("SIGSYS", SIGSYS);
3957 #endif
3958 #ifdef SIGPIPE
3959 handle_signal ("SIGPIPE", SIGPIPE);
3960 #endif
3961 #ifdef SIGALRM
3962 handle_signal ("SIGALRM", SIGALRM);
3963 #endif
3964 #ifdef SIGTERM
3965 handle_signal ("SIGTERM", SIGTERM);
3966 #endif
3967 #ifdef SIGURG
3968 handle_signal ("SIGURG", SIGURG);
3969 #endif
3970 #ifdef SIGSTOP
3971 handle_signal ("SIGSTOP", SIGSTOP);
3972 #endif
3973 #ifdef SIGTSTP
3974 handle_signal ("SIGTSTP", SIGTSTP);
3975 #endif
3976 #ifdef SIGCONT
3977 handle_signal ("SIGCONT", SIGCONT);
3978 #endif
3979 #ifdef SIGCHLD
3980 handle_signal ("SIGCHLD", SIGCHLD);
3981 #endif
3982 #ifdef SIGTTIN
3983 handle_signal ("SIGTTIN", SIGTTIN);
3984 #endif
3985 #ifdef SIGTTOU
3986 handle_signal ("SIGTTOU", SIGTTOU);
3987 #endif
3988 #ifdef SIGIO
3989 handle_signal ("SIGIO", SIGIO);
3990 #endif
3991 #ifdef SIGXCPU
3992 handle_signal ("SIGXCPU", SIGXCPU);
3993 #endif
3994 #ifdef SIGXFSZ
3995 handle_signal ("SIGXFSZ", SIGXFSZ);
3996 #endif
3997 #ifdef SIGVTALRM
3998 handle_signal ("SIGVTALRM", SIGVTALRM);
3999 #endif
4000 #ifdef SIGPROF
4001 handle_signal ("SIGPROF", SIGPROF);
4002 #endif
4003 #ifdef SIGWINCH
4004 handle_signal ("SIGWINCH", SIGWINCH);
4005 #endif
4006 #ifdef SIGINFO
4007 handle_signal ("SIGINFO", SIGINFO);
4008 #endif
4009 #ifdef SIGUSR1
4010 handle_signal ("SIGUSR1", SIGUSR1);
4011 #endif
4012 #ifdef SIGUSR2
4013 handle_signal ("SIGUSR2", SIGUSR2);
4014 #endif
4015 else
4016 error ("Undefined signal name %s", name);
4019 #undef handle_signal
4021 return make_number (kill (XINT (pid), XINT (sigcode)));
4024 DEFUN ("process-send-eof", Fprocess_send_eof, Sprocess_send_eof, 0, 1, 0,
4025 "Make PROCESS see end-of-file in its input.\n\
4026 EOF comes after any text already sent to it.\n\
4027 PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
4028 nil, indicating the current buffer's process.\n\
4029 If PROCESS is a network connection, or is a process communicating\n\
4030 through a pipe (as opposed to a pty), then you cannot send any more\n\
4031 text to PROCESS after you call this function.")
4032 (process)
4033 Lisp_Object process;
4035 Lisp_Object proc;
4036 struct coding_system *coding;
4038 proc = get_process (process);
4039 coding = proc_encode_coding_system[XINT (XPROCESS (proc)->outfd)];
4041 /* Make sure the process is really alive. */
4042 if (! NILP (XPROCESS (proc)->raw_status_low))
4043 update_status (XPROCESS (proc));
4044 if (! EQ (XPROCESS (proc)->status, Qrun))
4045 error ("Process %s not running", XSTRING (XPROCESS (proc)->name)->data);
4047 if (CODING_REQUIRE_FLUSHING (coding))
4049 coding->mode |= CODING_MODE_LAST_BLOCK;
4050 send_process (proc, "", 0, Qnil);
4053 #ifdef VMS
4054 send_process (proc, "\032", 1, Qnil); /* ^z */
4055 #else
4056 if (!NILP (XPROCESS (proc)->pty_flag))
4057 send_process (proc, "\004", 1, Qnil);
4058 else
4060 int old_outfd, new_outfd;
4062 #ifdef HAVE_SHUTDOWN
4063 /* If this is a network connection, or socketpair is used
4064 for communication with the subprocess, call shutdown to cause EOF.
4065 (In some old system, shutdown to socketpair doesn't work.
4066 Then we just can't win.) */
4067 if (NILP (XPROCESS (proc)->pid)
4068 || XINT (XPROCESS (proc)->outfd) == XINT (XPROCESS (proc)->infd))
4069 shutdown (XINT (XPROCESS (proc)->outfd), 1);
4070 /* In case of socketpair, outfd == infd, so don't close it. */
4071 if (XINT (XPROCESS (proc)->outfd) != XINT (XPROCESS (proc)->infd))
4072 close (XINT (XPROCESS (proc)->outfd));
4073 #else /* not HAVE_SHUTDOWN */
4074 close (XINT (XPROCESS (proc)->outfd));
4075 #endif /* not HAVE_SHUTDOWN */
4076 new_outfd = open (NULL_DEVICE, O_WRONLY);
4077 old_outfd = XINT (XPROCESS (proc)->outfd);
4079 if (!proc_encode_coding_system[new_outfd])
4080 proc_encode_coding_system[new_outfd]
4081 = (struct coding_system *) xmalloc (sizeof (struct coding_system));
4082 bcopy (proc_encode_coding_system[old_outfd],
4083 proc_encode_coding_system[new_outfd],
4084 sizeof (struct coding_system));
4085 bzero (proc_encode_coding_system[old_outfd],
4086 sizeof (struct coding_system));
4088 XSETINT (XPROCESS (proc)->outfd, new_outfd);
4090 #endif /* VMS */
4091 return process;
4094 /* Kill all processes associated with `buffer'.
4095 If `buffer' is nil, kill all processes */
4097 void
4098 kill_buffer_processes (buffer)
4099 Lisp_Object buffer;
4101 Lisp_Object tail, proc;
4103 for (tail = Vprocess_alist; GC_CONSP (tail); tail = XCDR (tail))
4105 proc = XCDR (XCAR (tail));
4106 if (GC_PROCESSP (proc)
4107 && (NILP (buffer) || EQ (XPROCESS (proc)->buffer, buffer)))
4109 if (NETCONN_P (proc))
4110 Fdelete_process (proc);
4111 else if (XINT (XPROCESS (proc)->infd) >= 0)
4112 process_send_signal (proc, SIGHUP, Qnil, 1);
4117 /* On receipt of a signal that a child status has changed,
4118 loop asking about children with changed statuses until
4119 the system says there are no more.
4120 All we do is change the status;
4121 we do not run sentinels or print notifications.
4122 That is saved for the next time keyboard input is done,
4123 in order to avoid timing errors. */
4125 /** WARNING: this can be called during garbage collection.
4126 Therefore, it must not be fooled by the presence of mark bits in
4127 Lisp objects. */
4129 /** USG WARNING: Although it is not obvious from the documentation
4130 in signal(2), on a USG system the SIGCLD handler MUST NOT call
4131 signal() before executing at least one wait(), otherwise the handler
4132 will be called again, resulting in an infinite loop. The relevant
4133 portion of the documentation reads "SIGCLD signals will be queued
4134 and the signal-catching function will be continually reentered until
4135 the queue is empty". Invoking signal() causes the kernel to reexamine
4136 the SIGCLD queue. Fred Fish, UniSoft Systems Inc. */
4138 SIGTYPE
4139 sigchld_handler (signo)
4140 int signo;
4142 int old_errno = errno;
4143 Lisp_Object proc;
4144 register struct Lisp_Process *p;
4145 extern EMACS_TIME *input_available_clear_time;
4147 #ifdef BSD4_1
4148 extern int sigheld;
4149 sigheld |= sigbit (SIGCHLD);
4150 #endif
4152 while (1)
4154 register int pid;
4155 WAITTYPE w;
4156 Lisp_Object tail;
4158 #ifdef WNOHANG
4159 #ifndef WUNTRACED
4160 #define WUNTRACED 0
4161 #endif /* no WUNTRACED */
4162 /* Keep trying to get a status until we get a definitive result. */
4165 errno = 0;
4166 pid = wait3 (&w, WNOHANG | WUNTRACED, 0);
4168 while (pid <= 0 && errno == EINTR);
4170 if (pid <= 0)
4172 /* A real failure. We have done all our job, so return. */
4174 /* USG systems forget handlers when they are used;
4175 must reestablish each time */
4176 #if defined (USG) && !defined (POSIX_SIGNALS)
4177 signal (signo, sigchld_handler); /* WARNING - must come after wait3() */
4178 #endif
4179 #ifdef BSD4_1
4180 sigheld &= ~sigbit (SIGCHLD);
4181 sigrelse (SIGCHLD);
4182 #endif
4183 errno = old_errno;
4184 return;
4186 #else
4187 pid = wait (&w);
4188 #endif /* no WNOHANG */
4190 /* Find the process that signaled us, and record its status. */
4192 p = 0;
4193 for (tail = Vprocess_alist; CONSP (tail); tail = XCDR (tail))
4195 proc = XCDR (XCAR (tail));
4196 p = XPROCESS (proc);
4197 if (EQ (p->childp, Qt) && XFASTINT (p->pid) == pid)
4198 break;
4199 p = 0;
4202 /* Look for an asynchronous process whose pid hasn't been filled
4203 in yet. */
4204 if (p == 0)
4205 for (tail = Vprocess_alist; CONSP (tail); tail = XCDR (tail))
4207 proc = XCDR (XCAR (tail));
4208 p = XPROCESS (proc);
4209 if (INTEGERP (p->pid) && XINT (p->pid) == -1)
4210 break;
4211 p = 0;
4214 /* Change the status of the process that was found. */
4215 if (p != 0)
4217 union { int i; WAITTYPE wt; } u;
4218 int clear_desc_flag = 0;
4220 XSETINT (p->tick, ++process_tick);
4221 u.wt = w;
4222 XSETINT (p->raw_status_low, u.i & 0xffff);
4223 XSETINT (p->raw_status_high, u.i >> 16);
4225 /* If process has terminated, stop waiting for its output. */
4226 if ((WIFSIGNALED (w) || WIFEXITED (w))
4227 && XINT (p->infd) >= 0)
4228 clear_desc_flag = 1;
4230 /* We use clear_desc_flag to avoid a compiler bug in Microsoft C. */
4231 if (clear_desc_flag)
4233 FD_CLR (XINT (p->infd), &input_wait_mask);
4234 FD_CLR (XINT (p->infd), &non_keyboard_wait_mask);
4237 /* Tell wait_reading_process_input that it needs to wake up and
4238 look around. */
4239 if (input_available_clear_time)
4240 EMACS_SET_SECS_USECS (*input_available_clear_time, 0, 0);
4243 /* There was no asynchronous process found for that id. Check
4244 if we have a synchronous process. */
4245 else
4247 synch_process_alive = 0;
4249 /* Report the status of the synchronous process. */
4250 if (WIFEXITED (w))
4251 synch_process_retcode = WRETCODE (w);
4252 else if (WIFSIGNALED (w))
4254 int code = WTERMSIG (w);
4255 char *signame = 0;
4257 if (code < NSIG)
4259 #ifndef VMS
4260 /* Suppress warning if the table has const char *. */
4261 signame = (char *) sys_siglist[code];
4262 #else
4263 signame = sys_errlist[code];
4264 #endif
4266 if (signame == 0)
4267 signame = "unknown";
4269 synch_process_death = signame;
4272 /* Tell wait_reading_process_input that it needs to wake up and
4273 look around. */
4274 if (input_available_clear_time)
4275 EMACS_SET_SECS_USECS (*input_available_clear_time, 0, 0);
4278 /* On some systems, we must return right away.
4279 If any more processes want to signal us, we will
4280 get another signal.
4281 Otherwise (on systems that have WNOHANG), loop around
4282 to use up all the processes that have something to tell us. */
4283 #if defined (USG) && ! (defined (HPUX) && defined (WNOHANG)) || defined (WINDOWSNT)
4284 #if defined (USG) && ! defined (POSIX_SIGNALS)
4285 signal (signo, sigchld_handler);
4286 #endif
4287 errno = old_errno;
4288 return;
4289 #endif /* USG, but not HPUX with WNOHANG */
4294 static Lisp_Object
4295 exec_sentinel_unwind (data)
4296 Lisp_Object data;
4298 XPROCESS (XCAR (data))->sentinel = XCDR (data);
4299 return Qnil;
4302 static Lisp_Object
4303 exec_sentinel_error_handler (error)
4304 Lisp_Object error;
4306 cmd_error_internal (error, "error in process sentinel: ");
4307 Vinhibit_quit = Qt;
4308 update_echo_area ();
4309 Fsleep_for (make_number (2), Qnil);
4312 static void
4313 exec_sentinel (proc, reason)
4314 Lisp_Object proc, reason;
4316 Lisp_Object sentinel, obuffer, odeactivate, okeymap;
4317 register struct Lisp_Process *p = XPROCESS (proc);
4318 int count = specpdl_ptr - specpdl;
4319 int outer_running_asynch_code = running_asynch_code;
4320 int waiting = waiting_for_user_input_p;
4322 /* No need to gcpro these, because all we do with them later
4323 is test them for EQness, and none of them should be a string. */
4324 odeactivate = Vdeactivate_mark;
4325 XSETBUFFER (obuffer, current_buffer);
4326 okeymap = current_buffer->keymap;
4328 sentinel = p->sentinel;
4329 if (NILP (sentinel))
4330 return;
4332 /* Zilch the sentinel while it's running, to avoid recursive invocations;
4333 assure that it gets restored no matter how the sentinel exits. */
4334 p->sentinel = Qnil;
4335 record_unwind_protect (exec_sentinel_unwind, Fcons (proc, sentinel));
4336 /* Inhibit quit so that random quits don't screw up a running filter. */
4337 specbind (Qinhibit_quit, Qt);
4338 specbind (Qlast_nonmenu_event, Qt);
4340 /* In case we get recursively called,
4341 and we already saved the match data nonrecursively,
4342 save the same match data in safely recursive fashion. */
4343 if (outer_running_asynch_code)
4345 Lisp_Object tem;
4346 tem = Fmatch_data (Qnil, Qnil);
4347 restore_match_data ();
4348 record_unwind_protect (Fset_match_data, Fmatch_data (Qnil, Qnil));
4349 Fset_match_data (tem);
4352 /* For speed, if a search happens within this code,
4353 save the match data in a special nonrecursive fashion. */
4354 running_asynch_code = 1;
4356 internal_condition_case_1 (read_process_output_call,
4357 Fcons (sentinel,
4358 Fcons (proc, Fcons (reason, Qnil))),
4359 !NILP (Vdebug_on_error) ? Qnil : Qerror,
4360 exec_sentinel_error_handler);
4362 /* If we saved the match data nonrecursively, restore it now. */
4363 restore_match_data ();
4364 running_asynch_code = outer_running_asynch_code;
4366 Vdeactivate_mark = odeactivate;
4368 /* Restore waiting_for_user_input_p as it was
4369 when we were called, in case the filter clobbered it. */
4370 waiting_for_user_input_p = waiting;
4372 #if 0
4373 if (! EQ (Fcurrent_buffer (), obuffer)
4374 || ! EQ (current_buffer->keymap, okeymap))
4375 #endif
4376 /* But do it only if the caller is actually going to read events.
4377 Otherwise there's no need to make him wake up, and it could
4378 cause trouble (for example it would make Fsit_for return). */
4379 if (waiting_for_user_input_p == -1)
4380 record_asynch_buffer_change ();
4382 unbind_to (count, Qnil);
4385 /* Report all recent events of a change in process status
4386 (either run the sentinel or output a message).
4387 This is done while Emacs is waiting for keyboard input. */
4389 void
4390 status_notify ()
4392 register Lisp_Object proc, buffer;
4393 Lisp_Object tail, msg;
4394 struct gcpro gcpro1, gcpro2;
4396 tail = Qnil;
4397 msg = Qnil;
4398 /* We need to gcpro tail; if read_process_output calls a filter
4399 which deletes a process and removes the cons to which tail points
4400 from Vprocess_alist, and then causes a GC, tail is an unprotected
4401 reference. */
4402 GCPRO2 (tail, msg);
4404 /* Set this now, so that if new processes are created by sentinels
4405 that we run, we get called again to handle their status changes. */
4406 update_tick = process_tick;
4408 for (tail = Vprocess_alist; !NILP (tail); tail = Fcdr (tail))
4410 Lisp_Object symbol;
4411 register struct Lisp_Process *p;
4413 proc = Fcdr (Fcar (tail));
4414 p = XPROCESS (proc);
4416 if (XINT (p->tick) != XINT (p->update_tick))
4418 XSETINT (p->update_tick, XINT (p->tick));
4420 /* If process is still active, read any output that remains. */
4421 while (! EQ (p->filter, Qt)
4422 && XINT (p->infd) >= 0
4423 && read_process_output (proc, XINT (p->infd)) > 0);
4425 buffer = p->buffer;
4427 /* Get the text to use for the message. */
4428 if (!NILP (p->raw_status_low))
4429 update_status (p);
4430 msg = status_message (p->status);
4432 /* If process is terminated, deactivate it or delete it. */
4433 symbol = p->status;
4434 if (CONSP (p->status))
4435 symbol = XCAR (p->status);
4437 if (EQ (symbol, Qsignal) || EQ (symbol, Qexit)
4438 || EQ (symbol, Qclosed))
4440 if (delete_exited_processes)
4441 remove_process (proc);
4442 else
4443 deactivate_process (proc);
4446 /* The actions above may have further incremented p->tick.
4447 So set p->update_tick again
4448 so that an error in the sentinel will not cause
4449 this code to be run again. */
4450 XSETINT (p->update_tick, XINT (p->tick));
4451 /* Now output the message suitably. */
4452 if (!NILP (p->sentinel))
4453 exec_sentinel (proc, msg);
4454 /* Don't bother with a message in the buffer
4455 when a process becomes runnable. */
4456 else if (!EQ (symbol, Qrun) && !NILP (buffer))
4458 Lisp_Object ro, tem;
4459 struct buffer *old = current_buffer;
4460 int opoint, opoint_byte;
4461 int before, before_byte;
4463 ro = XBUFFER (buffer)->read_only;
4465 /* Avoid error if buffer is deleted
4466 (probably that's why the process is dead, too) */
4467 if (NILP (XBUFFER (buffer)->name))
4468 continue;
4469 Fset_buffer (buffer);
4471 opoint = PT;
4472 opoint_byte = PT_BYTE;
4473 /* Insert new output into buffer
4474 at the current end-of-output marker,
4475 thus preserving logical ordering of input and output. */
4476 if (XMARKER (p->mark)->buffer)
4477 Fgoto_char (p->mark);
4478 else
4479 SET_PT_BOTH (ZV, ZV_BYTE);
4481 before = PT;
4482 before_byte = PT_BYTE;
4484 tem = current_buffer->read_only;
4485 current_buffer->read_only = Qnil;
4486 insert_string ("\nProcess ");
4487 Finsert (1, &p->name);
4488 insert_string (" ");
4489 Finsert (1, &msg);
4490 current_buffer->read_only = tem;
4491 set_marker_both (p->mark, p->buffer, PT, PT_BYTE);
4493 if (opoint >= before)
4494 SET_PT_BOTH (opoint + (PT - before),
4495 opoint_byte + (PT_BYTE - before_byte));
4496 else
4497 SET_PT_BOTH (opoint, opoint_byte);
4499 set_buffer_internal (old);
4502 } /* end for */
4504 update_mode_lines++; /* in case buffers use %s in mode-line-format */
4505 redisplay_preserve_echo_area ();
4507 UNGCPRO;
4511 DEFUN ("set-process-coding-system", Fset_process_coding_system,
4512 Sset_process_coding_system, 1, 3, 0,
4513 "Set coding systems of PROCESS to DECODING and ENCODING.\n\
4514 DECODING will be used to decode subprocess output and ENCODING to\n\
4515 encode subprocess input.")
4516 (proc, decoding, encoding)
4517 register Lisp_Object proc, decoding, encoding;
4519 register struct Lisp_Process *p;
4521 CHECK_PROCESS (proc, 0);
4522 p = XPROCESS (proc);
4523 if (XINT (p->infd) < 0)
4524 error ("Input file descriptor of %s closed", XSTRING (p->name)->data);
4525 if (XINT (p->outfd) < 0)
4526 error ("Output file descriptor of %s closed", XSTRING (p->name)->data);
4528 p->decode_coding_system = Fcheck_coding_system (decoding);
4529 p->encode_coding_system = Fcheck_coding_system (encoding);
4530 setup_coding_system (decoding,
4531 proc_decode_coding_system[XINT (p->infd)]);
4532 setup_coding_system (encoding,
4533 proc_encode_coding_system[XINT (p->outfd)]);
4535 return Qnil;
4538 DEFUN ("process-coding-system",
4539 Fprocess_coding_system, Sprocess_coding_system, 1, 1, 0,
4540 "Return a cons of coding systems for decoding and encoding of PROCESS.")
4541 (proc)
4542 register Lisp_Object proc;
4544 CHECK_PROCESS (proc, 0);
4545 return Fcons (XPROCESS (proc)->decode_coding_system,
4546 XPROCESS (proc)->encode_coding_system);
4549 /* The first time this is called, assume keyboard input comes from DESC
4550 instead of from where we used to expect it.
4551 Subsequent calls mean assume input keyboard can come from DESC
4552 in addition to other places. */
4554 static int add_keyboard_wait_descriptor_called_flag;
4556 void
4557 add_keyboard_wait_descriptor (desc)
4558 int desc;
4560 if (! add_keyboard_wait_descriptor_called_flag)
4561 FD_CLR (0, &input_wait_mask);
4562 add_keyboard_wait_descriptor_called_flag = 1;
4563 FD_SET (desc, &input_wait_mask);
4564 FD_SET (desc, &non_process_wait_mask);
4565 if (desc > max_keyboard_desc)
4566 max_keyboard_desc = desc;
4569 /* From now on, do not expect DESC to give keyboard input. */
4571 void
4572 delete_keyboard_wait_descriptor (desc)
4573 int desc;
4575 int fd;
4576 int lim = max_keyboard_desc;
4578 FD_CLR (desc, &input_wait_mask);
4579 FD_CLR (desc, &non_process_wait_mask);
4581 if (desc == max_keyboard_desc)
4582 for (fd = 0; fd < lim; fd++)
4583 if (FD_ISSET (fd, &input_wait_mask)
4584 && !FD_ISSET (fd, &non_keyboard_wait_mask))
4585 max_keyboard_desc = fd;
4588 /* Return nonzero if *MASK has a bit set
4589 that corresponds to one of the keyboard input descriptors. */
4592 keyboard_bit_set (mask)
4593 SELECT_TYPE *mask;
4595 int fd;
4597 for (fd = 0; fd <= max_keyboard_desc; fd++)
4598 if (FD_ISSET (fd, mask) && FD_ISSET (fd, &input_wait_mask)
4599 && !FD_ISSET (fd, &non_keyboard_wait_mask))
4600 return 1;
4602 return 0;
4605 void
4606 init_process ()
4608 register int i;
4610 #ifdef SIGCHLD
4611 #ifndef CANNOT_DUMP
4612 if (! noninteractive || initialized)
4613 #endif
4614 signal (SIGCHLD, sigchld_handler);
4615 #endif
4617 FD_ZERO (&input_wait_mask);
4618 FD_ZERO (&non_keyboard_wait_mask);
4619 FD_ZERO (&non_process_wait_mask);
4620 max_process_desc = 0;
4622 FD_SET (0, &input_wait_mask);
4624 Vprocess_alist = Qnil;
4625 for (i = 0; i < MAXDESC; i++)
4627 chan_process[i] = Qnil;
4628 proc_buffered_char[i] = -1;
4630 bzero (proc_decode_coding_system, sizeof proc_decode_coding_system);
4631 bzero (proc_encode_coding_system, sizeof proc_encode_coding_system);
4633 Vdefault_process_coding_system
4634 = (NILP (buffer_defaults.enable_multibyte_characters)
4635 ? Fcons (Qraw_text, Qnil)
4636 : Fcons (Qemacs_mule, Qnil));
4639 void
4640 syms_of_process ()
4642 Qprocessp = intern ("processp");
4643 staticpro (&Qprocessp);
4644 Qrun = intern ("run");
4645 staticpro (&Qrun);
4646 Qstop = intern ("stop");
4647 staticpro (&Qstop);
4648 Qsignal = intern ("signal");
4649 staticpro (&Qsignal);
4651 /* Qexit is already staticpro'd by syms_of_eval; don't staticpro it
4652 here again.
4654 Qexit = intern ("exit");
4655 staticpro (&Qexit); */
4657 Qopen = intern ("open");
4658 staticpro (&Qopen);
4659 Qclosed = intern ("closed");
4660 staticpro (&Qclosed);
4662 Qlast_nonmenu_event = intern ("last-nonmenu-event");
4663 staticpro (&Qlast_nonmenu_event);
4665 staticpro (&Vprocess_alist);
4667 DEFVAR_BOOL ("delete-exited-processes", &delete_exited_processes,
4668 "*Non-nil means delete processes immediately when they exit.\n\
4669 nil means don't delete them until `list-processes' is run.");
4671 delete_exited_processes = 1;
4673 DEFVAR_LISP ("process-connection-type", &Vprocess_connection_type,
4674 "Control type of device used to communicate with subprocesses.\n\
4675 Values are nil to use a pipe, or t or `pty' to use a pty.\n\
4676 The value has no effect if the system has no ptys or if all ptys are busy:\n\
4677 then a pipe is used in any case.\n\
4678 The value takes effect when `start-process' is called.");
4679 Vprocess_connection_type = Qt;
4681 defsubr (&Sprocessp);
4682 defsubr (&Sget_process);
4683 defsubr (&Sget_buffer_process);
4684 defsubr (&Sdelete_process);
4685 defsubr (&Sprocess_status);
4686 defsubr (&Sprocess_exit_status);
4687 defsubr (&Sprocess_id);
4688 defsubr (&Sprocess_name);
4689 defsubr (&Sprocess_tty_name);
4690 defsubr (&Sprocess_command);
4691 defsubr (&Sset_process_buffer);
4692 defsubr (&Sprocess_buffer);
4693 defsubr (&Sprocess_mark);
4694 defsubr (&Sset_process_filter);
4695 defsubr (&Sprocess_filter);
4696 defsubr (&Sset_process_sentinel);
4697 defsubr (&Sprocess_sentinel);
4698 defsubr (&Sset_process_window_size);
4699 defsubr (&Sset_process_inherit_coding_system_flag);
4700 defsubr (&Sprocess_inherit_coding_system_flag);
4701 defsubr (&Sprocess_kill_without_query);
4702 defsubr (&Sprocess_contact);
4703 defsubr (&Slist_processes);
4704 defsubr (&Sprocess_list);
4705 defsubr (&Sstart_process);
4706 #ifdef HAVE_SOCKETS
4707 defsubr (&Sopen_network_stream);
4708 #endif /* HAVE_SOCKETS */
4709 defsubr (&Saccept_process_output);
4710 defsubr (&Sprocess_send_region);
4711 defsubr (&Sprocess_send_string);
4712 defsubr (&Sinterrupt_process);
4713 defsubr (&Skill_process);
4714 defsubr (&Squit_process);
4715 defsubr (&Sstop_process);
4716 defsubr (&Scontinue_process);
4717 defsubr (&Sprocess_running_child_p);
4718 defsubr (&Sprocess_send_eof);
4719 defsubr (&Ssignal_process);
4720 defsubr (&Swaiting_for_user_input_p);
4721 /* defsubr (&Sprocess_connection); */
4722 defsubr (&Sset_process_coding_system);
4723 defsubr (&Sprocess_coding_system);
4727 #else /* not subprocesses */
4729 #include <sys/types.h>
4730 #include <errno.h>
4732 #include "lisp.h"
4733 #include "systime.h"
4734 #include "charset.h"
4735 #include "coding.h"
4736 #include "termopts.h"
4737 #include "sysselect.h"
4739 extern int frame_garbaged;
4741 extern EMACS_TIME timer_check ();
4742 extern int timers_run;
4744 /* As described above, except assuming that there are no subprocesses:
4746 Wait for timeout to elapse and/or keyboard input to be available.
4748 time_limit is:
4749 timeout in seconds, or
4750 zero for no limit, or
4751 -1 means gobble data immediately available but don't wait for any.
4753 read_kbd is a Lisp_Object:
4754 0 to ignore keyboard input, or
4755 1 to return when input is available, or
4756 -1 means caller will actually read the input, so don't throw to
4757 the quit handler.
4758 a cons cell, meaning wait until its car is non-nil
4759 (and gobble terminal input into the buffer if any arrives), or
4760 We know that read_kbd will never be a Lisp_Process, since
4761 `subprocesses' isn't defined.
4763 do_display != 0 means redisplay should be done to show subprocess
4764 output that arrives.
4766 Return true iff we received input from any process. */
4769 wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
4770 int time_limit, microsecs;
4771 Lisp_Object read_kbd;
4772 int do_display;
4774 register int nfds;
4775 EMACS_TIME end_time, timeout;
4776 SELECT_TYPE waitchannels;
4777 int xerrno;
4778 Lisp_Object *wait_for_cell = 0;
4780 /* If waiting for non-nil in a cell, record where. */
4781 if (CONSP (read_kbd))
4783 wait_for_cell = &XCAR (read_kbd);
4784 XSETFASTINT (read_kbd, 0);
4787 /* What does time_limit really mean? */
4788 if (time_limit || microsecs)
4790 EMACS_GET_TIME (end_time);
4791 EMACS_SET_SECS_USECS (timeout, time_limit, microsecs);
4792 EMACS_ADD_TIME (end_time, end_time, timeout);
4795 /* Turn off periodic alarms (in case they are in use)
4796 because the select emulator uses alarms. */
4797 stop_polling ();
4799 while (1)
4801 int timeout_reduced_for_timers = 0;
4803 /* If calling from keyboard input, do not quit
4804 since we want to return C-g as an input character.
4805 Otherwise, do pending quit if requested. */
4806 if (XINT (read_kbd) >= 0)
4807 QUIT;
4809 /* Exit now if the cell we're waiting for became non-nil. */
4810 if (wait_for_cell && ! NILP (*wait_for_cell))
4811 break;
4813 /* Compute time from now till when time limit is up */
4814 /* Exit if already run out */
4815 if (time_limit == -1)
4817 /* -1 specified for timeout means
4818 gobble output available now
4819 but don't wait at all. */
4821 EMACS_SET_SECS_USECS (timeout, 0, 0);
4823 else if (time_limit || microsecs)
4825 EMACS_GET_TIME (timeout);
4826 EMACS_SUB_TIME (timeout, end_time, timeout);
4827 if (EMACS_TIME_NEG_P (timeout))
4828 break;
4830 else
4832 EMACS_SET_SECS_USECS (timeout, 100000, 0);
4835 /* If our caller will not immediately handle keyboard events,
4836 run timer events directly.
4837 (Callers that will immediately read keyboard events
4838 call timer_delay on their own.) */
4839 if (! wait_for_cell)
4841 EMACS_TIME timer_delay;
4842 int old_timers_run;
4844 retry:
4845 old_timers_run = timers_run;
4846 timer_delay = timer_check (1);
4847 if (timers_run != old_timers_run && do_display)
4849 redisplay_preserve_echo_area ();
4850 /* We must retry, since a timer may have requeued itself
4851 and that could alter the time delay. */
4852 goto retry;
4855 /* If there is unread keyboard input, also return. */
4856 if (XINT (read_kbd) != 0
4857 && requeued_events_pending_p ())
4858 break;
4860 if (! EMACS_TIME_NEG_P (timer_delay) && time_limit != -1)
4862 EMACS_TIME difference;
4863 EMACS_SUB_TIME (difference, timer_delay, timeout);
4864 if (EMACS_TIME_NEG_P (difference))
4866 timeout = timer_delay;
4867 timeout_reduced_for_timers = 1;
4872 /* Cause C-g and alarm signals to take immediate action,
4873 and cause input available signals to zero out timeout. */
4874 if (XINT (read_kbd) < 0)
4875 set_waiting_for_input (&timeout);
4877 /* Wait till there is something to do. */
4879 if (! XINT (read_kbd) && wait_for_cell == 0)
4880 FD_ZERO (&waitchannels);
4881 else
4882 FD_SET (0, &waitchannels);
4884 /* If a frame has been newly mapped and needs updating,
4885 reprocess its display stuff. */
4886 if (frame_garbaged && do_display)
4888 clear_waiting_for_input ();
4889 redisplay_preserve_echo_area ();
4890 if (XINT (read_kbd) < 0)
4891 set_waiting_for_input (&timeout);
4894 if (XINT (read_kbd) && detect_input_pending ())
4896 nfds = 0;
4897 FD_ZERO (&waitchannels);
4899 else
4900 nfds = select (1, &waitchannels, (SELECT_TYPE *)0, (SELECT_TYPE *)0,
4901 &timeout);
4903 xerrno = errno;
4905 /* Make C-g and alarm signals set flags again */
4906 clear_waiting_for_input ();
4908 /* If we woke up due to SIGWINCH, actually change size now. */
4909 do_pending_window_change (0);
4911 if (time_limit && nfds == 0 && ! timeout_reduced_for_timers)
4912 /* We waited the full specified time, so return now. */
4913 break;
4915 if (nfds == -1)
4917 /* If the system call was interrupted, then go around the
4918 loop again. */
4919 if (xerrno == EINTR)
4920 FD_ZERO (&waitchannels);
4921 else
4922 error ("select error: %s", strerror (xerrno));
4924 #ifdef sun
4925 else if (nfds > 0 && (waitchannels & 1) && interrupt_input)
4926 /* System sometimes fails to deliver SIGIO. */
4927 kill (getpid (), SIGIO);
4928 #endif
4929 #ifdef SIGIO
4930 if (XINT (read_kbd) && interrupt_input && (waitchannels & 1))
4931 kill (getpid (), SIGIO);
4932 #endif
4934 /* Check for keyboard input */
4936 if ((XINT (read_kbd) != 0)
4937 && detect_input_pending_run_timers (do_display))
4939 swallow_events (do_display);
4940 if (detect_input_pending_run_timers (do_display))
4941 break;
4944 /* If there is unread keyboard input, also return. */
4945 if (XINT (read_kbd) != 0
4946 && requeued_events_pending_p ())
4947 break;
4949 /* If wait_for_cell. check for keyboard input
4950 but don't run any timers.
4951 ??? (It seems wrong to me to check for keyboard
4952 input at all when wait_for_cell, but the code
4953 has been this way since July 1994.
4954 Try changing this after version 19.31.) */
4955 if (wait_for_cell
4956 && detect_input_pending ())
4958 swallow_events (do_display);
4959 if (detect_input_pending ())
4960 break;
4963 /* Exit now if the cell we're waiting for became non-nil. */
4964 if (wait_for_cell && ! NILP (*wait_for_cell))
4965 break;
4968 start_polling ();
4970 return 0;
4974 DEFUN ("get-buffer-process", Fget_buffer_process, Sget_buffer_process, 1, 1, 0,
4975 /* Don't confuse make-docfile by having two doc strings for this function.
4976 make-docfile does not pay attention to #if, for good reason! */
4978 (name)
4979 register Lisp_Object name;
4981 return Qnil;
4984 DEFUN ("process-inherit-coding-system-flag",
4985 Fprocess_inherit_coding_system_flag, Sprocess_inherit_coding_system_flag,
4986 1, 1, 0,
4987 /* Don't confuse make-docfile by having two doc strings for this function.
4988 make-docfile does not pay attention to #if, for good reason! */
4990 (process)
4991 register Lisp_Object process;
4993 /* Ignore the argument and return the value of
4994 inherit-process-coding-system. */
4995 return inherit_process_coding_system ? Qt : Qnil;
4998 /* Kill all processes associated with `buffer'.
4999 If `buffer' is nil, kill all processes.
5000 Since we have no subprocesses, this does nothing. */
5002 void
5003 kill_buffer_processes (buffer)
5004 Lisp_Object buffer;
5008 void
5009 init_process ()
5013 void
5014 syms_of_process ()
5016 defsubr (&Sget_buffer_process);
5017 defsubr (&Sprocess_inherit_coding_system_flag);
5021 #endif /* not subprocesses */