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)
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. */
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. */
40 #include <sys/types.h> /* some typedefs are used in sys/file.h */
50 #endif /* not WINDOWSNT */
52 #ifdef HAVE_SOCKETS /* TCP connection support, if kernel can do it */
53 #include <sys/socket.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. */
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)
72 #define IN_ADDR unsigned long
73 #define NUMERIC_ADDR_ERROR (numeric_addr == -1)
76 #if defined(BSD_SYSTEM) || defined(STRIDE)
77 #include <sys/ioctl.h>
78 #if !defined (O_NDELAY) && defined (HAVE_PTYS) && !defined(USG5)
80 #endif /* HAVE_PTYS and no O_NDELAY */
81 #endif /* BSD_SYSTEM || STRIDE */
83 #ifdef BROKEN_O_NONBLOCK
85 #endif /* BROKEN_O_NONBLOCK */
92 #include <sys/sysmacros.h> /* for "minor" */
104 #include "termhooks.h"
105 #include "termopts.h"
106 #include "commands.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). */
123 #define NETCONN_P(p) (GC_CONSP (XPROCESS (p)->childp))
125 #define NETCONN_P(p) 0
126 #endif /* HAVE_SOCKETS */
128 /* Define first descriptor number available for subprocesses. */
130 #define FIRST_PROC_DESC 1
132 #define FIRST_PROC_DESC 3
135 /* Define SIGCHLD as an alias for SIGCLD. There are many conditionals
138 #if !defined (SIGCHLD) && defined (SIGCLD)
139 #define SIGCHLD SIGCLD
142 #include "syssignal.h"
147 extern char *strerror ();
149 extern char *sys_errlist
[];
156 #ifndef SYS_SIGLIST_DECLARED
161 extern char *sys_siglist
[];
162 #endif /* not LINUX */
164 char *sys_siglist
[] =
170 "illegal instruction",
174 "floating point exception",
177 "segmentation violation",
178 "bad argument to system call",
179 "write on a pipe with no one to read it",
181 "software termination signal from kill",
183 "sendable stop signal not from tty",
184 "stop signal from tty",
185 "continue a stopped process",
186 "child status has changed",
187 "background read attempted from control tty",
188 "background write attempted from control tty",
189 "input record available at control tty",
190 "exceeded CPU time limit",
191 "exceeded file size limit"
193 #endif /* not WINDOWSNT */
196 #endif /* ! SYS_SIGLIST_DECLARED */
198 /* t means use pty, nil means use a pipe,
199 maybe other values to come. */
200 static Lisp_Object Vprocess_connection_type
;
204 #include <sys/socket.h>
208 /* These next two vars are non-static since sysdep.c uses them in the
209 emulation of `select'. */
210 /* Number of events of change of status of a process. */
212 /* Number of events for which the user or sentinel has been notified. */
215 #include "sysselect.h"
217 /* If we support a window system, turn on the code to poll periodically
218 to detect C-g. It isn't actually used when doing interrupt input. */
219 #ifdef HAVE_WINDOW_SYSTEM
220 #define POLL_FOR_INPUT
223 /* Mask of bits indicating the descriptors that we wait for input on. */
225 static SELECT_TYPE input_wait_mask
;
227 /* Mask that excludes keyboard input descriptor (s). */
229 static SELECT_TYPE non_keyboard_wait_mask
;
231 /* Mask that excludes process input descriptor (s). */
233 static SELECT_TYPE non_process_wait_mask
;
235 /* The largest descriptor currently in use for a process object. */
236 static int max_process_desc
;
238 /* The largest descriptor currently in use for keyboard input. */
239 static int max_keyboard_desc
;
241 /* Nonzero means delete a process right away if it exits. */
242 static int delete_exited_processes
;
244 /* Indexed by descriptor, gives the process (if any) for that descriptor */
245 Lisp_Object chan_process
[MAXDESC
];
247 /* Alist of elements (NAME . PROCESS) */
248 Lisp_Object Vprocess_alist
;
250 /* Buffered-ahead input char from process, indexed by channel.
251 -1 means empty (no char is buffered).
252 Used on sys V where the only way to tell if there is any
253 output from the process is to read at least one char.
254 Always -1 on systems that support FIONREAD. */
256 /* Don't make static; need to access externally. */
257 int proc_buffered_char
[MAXDESC
];
259 /* Table of `struct coding-system' for each process. */
260 static struct coding_system
*proc_decode_coding_system
[MAXDESC
];
261 static struct coding_system
*proc_encode_coding_system
[MAXDESC
];
263 static Lisp_Object
get_process ();
265 extern EMACS_TIME
timer_check ();
266 extern int timers_run
;
268 /* Maximum number of bytes to send to a pty without an eof. */
269 static int pty_max_bytes
;
271 extern Lisp_Object Vfile_name_coding_system
, Vdefault_file_name_coding_system
;
274 /* The file name of the pty opened by allocate_pty. */
276 static char pty_name
[24];
279 /* Compute the Lisp form of the process status, p->status, from
280 the numeric status that was returned by `wait'. */
282 Lisp_Object
status_convert ();
286 struct Lisp_Process
*p
;
288 union { int i
; WAITTYPE wt
; } u
;
289 u
.i
= XFASTINT (p
->raw_status_low
) + (XFASTINT (p
->raw_status_high
) << 16);
290 p
->status
= status_convert (u
.wt
);
291 p
->raw_status_low
= Qnil
;
292 p
->raw_status_high
= Qnil
;
295 /* Convert a process status word in Unix format to
296 the list that we use internally. */
303 return Fcons (Qstop
, Fcons (make_number (WSTOPSIG (w
)), Qnil
));
304 else if (WIFEXITED (w
))
305 return Fcons (Qexit
, Fcons (make_number (WRETCODE (w
)),
306 WCOREDUMP (w
) ? Qt
: Qnil
));
307 else if (WIFSIGNALED (w
))
308 return Fcons (Qsignal
, Fcons (make_number (WTERMSIG (w
)),
309 WCOREDUMP (w
) ? Qt
: Qnil
));
314 /* Given a status-list, extract the three pieces of information
315 and store them individually through the three pointers. */
318 decode_status (l
, symbol
, code
, coredump
)
334 *symbol
= XCONS (l
)->car
;
335 tem
= XCONS (l
)->cdr
;
336 *code
= XFASTINT (XCONS (tem
)->car
);
337 tem
= XCONS (tem
)->cdr
;
338 *coredump
= !NILP (tem
);
342 /* Return a string describing a process status list. */
345 status_message (status
)
350 Lisp_Object string
, string2
;
352 decode_status (status
, &symbol
, &code
, &coredump
);
354 if (EQ (symbol
, Qsignal
) || EQ (symbol
, Qstop
))
360 /* Cast to suppress warning if the table has const char *. */
361 signame
= (char *) sys_siglist
[code
];
363 signame
= sys_errlist
[code
];
368 string
= build_string (signame
);
369 string2
= build_string (coredump
? " (core dumped)\n" : "\n");
370 XSTRING (string
)->data
[0] = DOWNCASE (XSTRING (string
)->data
[0]);
371 return concat2 (string
, string2
);
373 else if (EQ (symbol
, Qexit
))
376 return build_string ("finished\n");
377 string
= Fnumber_to_string (make_number (code
));
378 string2
= build_string (coredump
? " (core dumped)\n" : "\n");
379 return concat2 (build_string ("exited abnormally with code "),
380 concat2 (string
, string2
));
383 return Fcopy_sequence (Fsymbol_name (symbol
));
388 /* Open an available pty, returning a file descriptor.
389 Return -1 on failure.
390 The file name of the terminal corresponding to the pty
391 is left in the variable pty_name. */
400 /* Some systems name their pseudoterminals so that there are gaps in
401 the usual sequence - for example, on HP9000/S700 systems, there
402 are no pseudoterminals with names ending in 'f'. So we wait for
403 three failures in a row before deciding that we've reached the
405 int failed_count
= 0;
410 for (c
= FIRST_PTY_LETTER
; c
<= 'z'; c
++)
411 for (i
= 0; i
< 16; i
++)
414 #ifdef PTY_NAME_SPRINTF
417 sprintf (pty_name
, "/dev/pty%c%x", c
, i
);
418 #endif /* no PTY_NAME_SPRINTF */
422 #else /* no PTY_OPEN */
424 /* Unusual IRIS code */
425 *ptyv
= open ("/dev/ptc", O_RDWR
| O_NDELAY
, 0);
428 if (fstat (fd
, &stb
) < 0)
431 if (stat (pty_name
, &stb
) < 0)
434 if (failed_count
>= 3)
440 fd
= open (pty_name
, O_RDWR
| O_NONBLOCK
, 0);
442 fd
= open (pty_name
, O_RDWR
| O_NDELAY
, 0);
444 #endif /* not IRIS */
445 #endif /* no PTY_OPEN */
449 /* check to make certain that both sides are available
450 this avoids a nasty yet stupid bug in rlogins */
451 #ifdef PTY_TTY_NAME_SPRINTF
454 sprintf (pty_name
, "/dev/tty%c%x", c
, i
);
455 #endif /* no PTY_TTY_NAME_SPRINTF */
457 if (access (pty_name
, 6) != 0)
460 #if !defined(IRIS) && !defined(__sgi)
466 #endif /* not UNIPLUS */
473 #endif /* HAVE_PTYS */
479 struct Lisp_Vector
*vec
;
480 register Lisp_Object val
, tem
, name1
;
481 register struct Lisp_Process
*p
;
485 vec
= allocate_vectorlike ((EMACS_INT
) VECSIZE (struct Lisp_Process
));
486 for (i
= 0; i
< VECSIZE (struct Lisp_Process
); i
++)
487 vec
->contents
[i
] = Qnil
;
488 vec
->size
= VECSIZE (struct Lisp_Process
);
489 p
= (struct Lisp_Process
*)vec
;
491 XSETINT (p
->infd
, -1);
492 XSETINT (p
->outfd
, -1);
493 XSETFASTINT (p
->pid
, 0);
494 XSETFASTINT (p
->tick
, 0);
495 XSETFASTINT (p
->update_tick
, 0);
496 p
->raw_status_low
= Qnil
;
497 p
->raw_status_high
= Qnil
;
499 p
->mark
= Fmake_marker ();
501 /* If name is already in use, modify it until it is unused. */
506 tem
= Fget_process (name1
);
507 if (NILP (tem
)) break;
508 sprintf (suffix
, "<%d>", i
);
509 name1
= concat2 (name
, build_string (suffix
));
513 XSETPROCESS (val
, p
);
514 Vprocess_alist
= Fcons (Fcons (name
, val
), Vprocess_alist
);
519 remove_process (proc
)
520 register Lisp_Object proc
;
522 register Lisp_Object pair
;
524 pair
= Frassq (proc
, Vprocess_alist
);
525 Vprocess_alist
= Fdelq (pair
, Vprocess_alist
);
527 deactivate_process (proc
);
530 DEFUN ("processp", Fprocessp
, Sprocessp
, 1, 1, 0,
531 "Return t if OBJECT is a process.")
535 return PROCESSP (object
) ? Qt
: Qnil
;
538 DEFUN ("get-process", Fget_process
, Sget_process
, 1, 1, 0,
539 "Return the process named NAME, or nil if there is none.")
541 register Lisp_Object name
;
545 CHECK_STRING (name
, 0);
546 return Fcdr (Fassoc (name
, Vprocess_alist
));
549 DEFUN ("get-buffer-process", Fget_buffer_process
, Sget_buffer_process
, 1, 1, 0,
550 "Return the (or a) process associated with BUFFER.\n\
551 BUFFER may be a buffer or the name of one.")
553 register Lisp_Object buffer
;
555 register Lisp_Object buf
, tail
, proc
;
557 if (NILP (buffer
)) return Qnil
;
558 buf
= Fget_buffer (buffer
);
559 if (NILP (buf
)) return Qnil
;
561 for (tail
= Vprocess_alist
; !NILP (tail
); tail
= Fcdr (tail
))
563 proc
= Fcdr (Fcar (tail
));
564 if (PROCESSP (proc
) && EQ (XPROCESS (proc
)->buffer
, buf
))
570 /* This is how commands for the user decode process arguments. It
571 accepts a process, a process name, a buffer, a buffer name, or nil.
572 Buffers denote the first process in the buffer, and nil denotes the
577 register Lisp_Object name
;
579 register Lisp_Object proc
, obj
;
582 obj
= Fget_process (name
);
584 obj
= Fget_buffer (name
);
586 error ("Process %s does not exist", XSTRING (name
)->data
);
588 else if (NILP (name
))
589 obj
= Fcurrent_buffer ();
593 /* Now obj should be either a buffer object or a process object.
597 proc
= Fget_buffer_process (obj
);
599 error ("Buffer %s has no process", XSTRING (XBUFFER (obj
)->name
)->data
);
603 CHECK_PROCESS (obj
, 0);
609 DEFUN ("delete-process", Fdelete_process
, Sdelete_process
, 1, 1, 0,
610 "Delete PROCESS: kill it and forget about it immediately.\n\
611 PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
612 nil, indicating the current buffer's process.")
614 register Lisp_Object process
;
616 process
= get_process (process
);
617 XPROCESS (process
)->raw_status_low
= Qnil
;
618 XPROCESS (process
)->raw_status_high
= Qnil
;
619 if (NETCONN_P (process
))
621 XPROCESS (process
)->status
= Fcons (Qexit
, Fcons (make_number (0), Qnil
));
622 XSETINT (XPROCESS (process
)->tick
, ++process_tick
);
624 else if (XINT (XPROCESS (process
)->infd
) >= 0)
626 Fkill_process (process
, Qnil
);
627 /* Do this now, since remove_process will make sigchld_handler do nothing. */
628 XPROCESS (process
)->status
629 = Fcons (Qsignal
, Fcons (make_number (SIGKILL
), Qnil
));
630 XSETINT (XPROCESS (process
)->tick
, ++process_tick
);
633 remove_process (process
);
637 DEFUN ("process-status", Fprocess_status
, Sprocess_status
, 1, 1, 0,
638 "Return the status of PROCESS.\n\
639 The returned value is one of the following symbols:\n\
640 run -- for a process that is running.\n\
641 stop -- for a process stopped but continuable.\n\
642 exit -- for a process that has exited.\n\
643 signal -- for a process that has got a fatal signal.\n\
644 open -- for a network stream connection that is open.\n\
645 closed -- for a network stream connection that is closed.\n\
646 nil -- if arg is a process name and no such process exists.\n\
647 PROCESS may be a process, a buffer, the name of a process, or\n\
648 nil, indicating the current buffer's process.")
650 register Lisp_Object process
;
652 register struct Lisp_Process
*p
;
653 register Lisp_Object status
;
655 if (STRINGP (process
))
656 process
= Fget_process (process
);
658 process
= get_process (process
);
663 p
= XPROCESS (process
);
664 if (!NILP (p
->raw_status_low
))
668 status
= XCONS (status
)->car
;
669 if (NETCONN_P (process
))
671 if (EQ (status
, Qrun
))
673 else if (EQ (status
, Qexit
))
679 DEFUN ("process-exit-status", Fprocess_exit_status
, Sprocess_exit_status
,
681 "Return the exit status of PROCESS or the signal number that killed it.\n\
682 If PROCESS has not yet exited or died, return 0.")
684 register Lisp_Object process
;
686 CHECK_PROCESS (process
, 0);
687 if (!NILP (XPROCESS (process
)->raw_status_low
))
688 update_status (XPROCESS (process
));
689 if (CONSP (XPROCESS (process
)->status
))
690 return XCONS (XCONS (XPROCESS (process
)->status
)->cdr
)->car
;
691 return make_number (0);
694 DEFUN ("process-id", Fprocess_id
, Sprocess_id
, 1, 1, 0,
695 "Return the process id of PROCESS.\n\
696 This is the pid of the Unix process which PROCESS uses or talks to.\n\
697 For a network connection, this value is nil.")
699 register Lisp_Object process
;
701 CHECK_PROCESS (process
, 0);
702 return XPROCESS (process
)->pid
;
705 DEFUN ("process-name", Fprocess_name
, Sprocess_name
, 1, 1, 0,
706 "Return the name of PROCESS, as a string.\n\
707 This is the name of the program invoked in PROCESS,\n\
708 possibly modified to make it unique among process names.")
710 register Lisp_Object process
;
712 CHECK_PROCESS (process
, 0);
713 return XPROCESS (process
)->name
;
716 DEFUN ("process-command", Fprocess_command
, Sprocess_command
, 1, 1, 0,
717 "Return the command that was executed to start PROCESS.\n\
718 This is a list of strings, the first string being the program executed\n\
719 and the rest of the strings being the arguments given to it.\n\
720 For a non-child channel, this is nil.")
722 register Lisp_Object process
;
724 CHECK_PROCESS (process
, 0);
725 return XPROCESS (process
)->command
;
728 DEFUN ("process-tty-name", Fprocess_tty_name
, Sprocess_tty_name
, 1, 1, 0,
729 "Return the name of the terminal PROCESS uses, or nil if none.\n\
730 This is the terminal that the process itself reads and writes on,\n\
731 not the name of the pty that Emacs uses to talk with that terminal.")
733 register Lisp_Object process
;
735 CHECK_PROCESS (process
, 0);
736 return XPROCESS (process
)->tty_name
;
739 DEFUN ("set-process-buffer", Fset_process_buffer
, Sset_process_buffer
,
741 "Set buffer associated with PROCESS to BUFFER (a buffer, or nil).")
743 register Lisp_Object process
, buffer
;
745 CHECK_PROCESS (process
, 0);
747 CHECK_BUFFER (buffer
, 1);
748 XPROCESS (process
)->buffer
= buffer
;
752 DEFUN ("process-buffer", Fprocess_buffer
, Sprocess_buffer
,
754 "Return the buffer PROCESS is associated with.\n\
755 Output from PROCESS is inserted in this buffer unless PROCESS has a filter.")
757 register Lisp_Object process
;
759 CHECK_PROCESS (process
, 0);
760 return XPROCESS (process
)->buffer
;
763 DEFUN ("process-mark", Fprocess_mark
, Sprocess_mark
,
765 "Return the marker for the end of the last output from PROCESS.")
767 register Lisp_Object process
;
769 CHECK_PROCESS (process
, 0);
770 return XPROCESS (process
)->mark
;
773 DEFUN ("set-process-filter", Fset_process_filter
, Sset_process_filter
,
775 "Give PROCESS the filter function FILTER; nil means no filter.\n\
776 t means stop accepting output from the process.\n\
777 When a process has a filter, each time it does output\n\
778 the entire string of output is passed to the filter.\n\
779 The filter gets two arguments: the process and the string of output.\n\
780 If the process has a filter, its buffer is not used for output.")
782 register Lisp_Object process
, filter
;
784 CHECK_PROCESS (process
, 0);
787 FD_CLR (XINT (XPROCESS (process
)->infd
), &input_wait_mask
);
788 FD_CLR (XINT (XPROCESS (process
)->infd
), &non_keyboard_wait_mask
);
790 else if (EQ (XPROCESS (process
)->filter
, Qt
))
792 FD_SET (XINT (XPROCESS (process
)->infd
), &input_wait_mask
);
793 FD_SET (XINT (XPROCESS (process
)->infd
), &non_keyboard_wait_mask
);
795 XPROCESS (process
)->filter
= filter
;
799 DEFUN ("process-filter", Fprocess_filter
, Sprocess_filter
,
801 "Returns the filter function of PROCESS; nil if none.\n\
802 See `set-process-filter' for more info on filter functions.")
804 register Lisp_Object process
;
806 CHECK_PROCESS (process
, 0);
807 return XPROCESS (process
)->filter
;
810 DEFUN ("set-process-sentinel", Fset_process_sentinel
, Sset_process_sentinel
,
812 "Give PROCESS the sentinel SENTINEL; nil for none.\n\
813 The sentinel is called as a function when the process changes state.\n\
814 It gets two arguments: the process, and a string describing the change.")
816 register Lisp_Object process
, sentinel
;
818 CHECK_PROCESS (process
, 0);
819 XPROCESS (process
)->sentinel
= sentinel
;
823 DEFUN ("process-sentinel", Fprocess_sentinel
, Sprocess_sentinel
,
825 "Return the sentinel of PROCESS; nil if none.\n\
826 See `set-process-sentinel' for more info on sentinels.")
828 register Lisp_Object process
;
830 CHECK_PROCESS (process
, 0);
831 return XPROCESS (process
)->sentinel
;
834 DEFUN ("set-process-window-size", Fset_process_window_size
,
835 Sset_process_window_size
, 3, 3, 0,
836 "Tell PROCESS that it has logical window size HEIGHT and WIDTH.")
837 (process
, height
, width
)
838 register Lisp_Object process
, height
, width
;
840 CHECK_PROCESS (process
, 0);
841 CHECK_NATNUM (height
, 0);
842 CHECK_NATNUM (width
, 0);
843 if (set_window_size (XINT (XPROCESS (process
)->infd
),
844 XINT (height
), XINT(width
)) <= 0)
850 DEFUN ("set-process-inherit-coding-system-flag",
851 Fset_process_inherit_coding_system_flag
,
852 Sset_process_inherit_coding_system_flag
, 2, 2, 0,
853 "Determine whether buffer of PROCESS will inherit coding-system.\n\
854 If the second argument FLAG is non-nil, then the variable\n\
855 `buffer-file-coding-system' of the buffer associated with PROCESS\n\
856 will be bound to the value of the coding system used to decode\n\
857 the process output.\n\
859 This is useful when the coding system specified for the process buffer\n\
860 leaves either the character code conversion or the end-of-line conversion\n\
861 unspecified, or if the coding system used to decode the process output\n\
862 is more appropriate for saving the process buffer.\n\
864 Binding the variable `inherit-process-coding-system' to non-nil before\n\
865 starting the process is an alternative way of setting the inherit flag\n\
866 for the process which will run.")
868 register Lisp_Object process
, flag
;
870 CHECK_PROCESS (process
, 0);
871 XPROCESS (process
)->inherit_coding_system_flag
= flag
;
875 DEFUN ("process-inherit-coding-system-flag",
876 Fprocess_inherit_coding_system_flag
, Sprocess_inherit_coding_system_flag
,
878 "Return the value of inherit-coding-system flag for PROCESS.\n\
879 If this flag is t, `buffer-file-coding-system' of the buffer\n\
880 associated with PROCESS will inherit the coding system used to decode\n\
881 the process output.")
883 register Lisp_Object process
;
885 CHECK_PROCESS (process
, 0);
886 return XPROCESS (process
)->inherit_coding_system_flag
;
889 DEFUN ("process-kill-without-query", Fprocess_kill_without_query
,
890 Sprocess_kill_without_query
, 1, 2, 0,
891 "Say no query needed if PROCESS is running when Emacs is exited.\n\
892 Optional second argument if non-nil says to require a query.\n\
893 Value is t if a query was formerly required.")
895 register Lisp_Object process
, value
;
899 CHECK_PROCESS (process
, 0);
900 tem
= XPROCESS (process
)->kill_without_query
;
901 XPROCESS (process
)->kill_without_query
= Fnull (value
);
906 DEFUN ("process-contact", Fprocess_contact
, Sprocess_contact
,
908 "Return the contact info of PROCESS; t for a real child.\n\
909 For a net connection, the value is a cons cell of the form (HOST SERVICE).")
911 register Lisp_Object process
;
913 CHECK_PROCESS (process
, 0);
914 return XPROCESS (process
)->childp
;
917 #if 0 /* Turned off because we don't currently record this info
918 in the process. Perhaps add it. */
919 DEFUN ("process-connection", Fprocess_connection
, Sprocess_connection
, 1, 1, 0,
920 "Return the connection type of PROCESS.\n\
921 The value is nil for a pipe, t or `pty' for a pty, or `stream' for\n\
922 a socket connection.")
926 return XPROCESS (process
)->type
;
933 register Lisp_Object tail
, tem
;
934 Lisp_Object proc
, minspace
, tem1
;
935 register struct buffer
*old
= current_buffer
;
936 register struct Lisp_Process
*p
;
940 XSETFASTINT (minspace
, 1);
942 set_buffer_internal (XBUFFER (Vstandard_output
));
943 Fbuffer_disable_undo (Vstandard_output
);
945 current_buffer
->truncate_lines
= Qt
;
948 Proc Status Buffer Tty Command\n\
949 ---- ------ ------ --- -------\n", -1);
951 for (tail
= Vprocess_alist
; !NILP (tail
); tail
= Fcdr (tail
))
955 proc
= Fcdr (Fcar (tail
));
957 if (NILP (p
->childp
))
960 Finsert (1, &p
->name
);
961 Findent_to (make_number (13), minspace
);
963 if (!NILP (p
->raw_status_low
))
966 if (CONSP (p
->status
))
967 symbol
= XCONS (p
->status
)->car
;
970 if (EQ (symbol
, Qsignal
))
973 tem
= Fcar (Fcdr (p
->status
));
975 if (XINT (tem
) < NSIG
)
976 write_string (sys_errlist
[XINT (tem
)], -1);
979 Fprinc (symbol
, Qnil
);
981 else if (NETCONN_P (proc
))
983 if (EQ (symbol
, Qrun
))
984 write_string ("open", -1);
985 else if (EQ (symbol
, Qexit
))
986 write_string ("closed", -1);
988 Fprinc (symbol
, Qnil
);
991 Fprinc (symbol
, Qnil
);
993 if (EQ (symbol
, Qexit
))
996 tem
= Fcar (Fcdr (p
->status
));
999 sprintf (tembuf
, " %d", (int) XFASTINT (tem
));
1000 write_string (tembuf
, -1);
1004 if (EQ (symbol
, Qsignal
) || EQ (symbol
, Qexit
))
1005 remove_process (proc
);
1007 Findent_to (make_number (22), minspace
);
1008 if (NILP (p
->buffer
))
1009 insert_string ("(none)");
1010 else if (NILP (XBUFFER (p
->buffer
)->name
))
1011 insert_string ("(Killed)");
1013 Finsert (1, &XBUFFER (p
->buffer
)->name
);
1015 Findent_to (make_number (37), minspace
);
1017 if (STRINGP (p
->tty_name
))
1018 Finsert (1, &p
->tty_name
);
1020 insert_string ("(none)");
1022 Findent_to (make_number (49), minspace
);
1024 if (NETCONN_P (proc
))
1026 sprintf (tembuf
, "(network stream connection to %s)\n",
1027 XSTRING (XCONS (p
->childp
)->car
)->data
);
1028 insert_string (tembuf
);
1040 insert_string (" ");
1042 insert_string ("\n");
1048 DEFUN ("list-processes", Flist_processes
, Slist_processes
, 0, 0, "",
1049 "Display a list of all processes.\n\
1050 Any process listed as exited or signaled is actually eliminated\n\
1051 after the listing is made.")
1054 internal_with_output_to_temp_buffer ("*Process List*",
1055 list_processes_1
, Qnil
);
1059 DEFUN ("process-list", Fprocess_list
, Sprocess_list
, 0, 0, 0,
1060 "Return a list of all processes.")
1063 return Fmapcar (Qcdr
, Vprocess_alist
);
1066 /* Starting asynchronous inferior processes. */
1068 static Lisp_Object
start_process_unwind ();
1070 DEFUN ("start-process", Fstart_process
, Sstart_process
, 3, MANY
, 0,
1071 "Start a program in a subprocess. Return the process object for it.\n\
1072 Args are NAME BUFFER PROGRAM &rest PROGRAM-ARGS\n\
1073 NAME is name for process. It is modified if necessary to make it unique.\n\
1074 BUFFER is the buffer or (buffer-name) to associate with the process.\n\
1075 Process output goes at end of that buffer, unless you specify\n\
1076 an output stream or filter function to handle the output.\n\
1077 BUFFER may be also nil, meaning that this process is not associated\n\
1079 Third arg is program file name. It is searched for in PATH.\n\
1080 Remaining arguments are strings to give program as arguments.")
1083 register Lisp_Object
*args
;
1085 Lisp_Object buffer
, name
, program
, proc
, current_dir
, tem
;
1087 register unsigned char *new_argv
;
1090 register unsigned char **new_argv
;
1093 int count
= specpdl_ptr
- specpdl
;
1097 buffer
= Fget_buffer_create (buffer
);
1099 /* Make sure that the child will be able to chdir to the current
1100 buffer's current directory, or its unhandled equivalent. We
1101 can't just have the child check for an error when it does the
1102 chdir, since it's in a vfork.
1104 We have to GCPRO around this because Fexpand_file_name and
1105 Funhandled_file_name_directory might call a file name handling
1106 function. The argument list is protected by the caller, so all
1107 we really have to worry about is buffer. */
1109 struct gcpro gcpro1
, gcpro2
;
1111 current_dir
= current_buffer
->directory
;
1113 GCPRO2 (buffer
, current_dir
);
1116 = expand_and_dir_to_file (Funhandled_file_name_directory (current_dir
),
1118 if (NILP (Ffile_accessible_directory_p (current_dir
)))
1119 report_file_error ("Setting current directory",
1120 Fcons (current_buffer
->directory
, Qnil
));
1126 CHECK_STRING (name
, 0);
1130 CHECK_STRING (program
, 2);
1133 /* Make a one member argv with all args concatenated
1134 together separated by a blank. */
1135 len
= STRING_BYTES (XSTRING (program
)) + 2;
1136 for (i
= 3; i
< nargs
; i
++)
1139 CHECK_STRING (tem
, i
);
1140 len
+= STRING_BYTES (XSTRING (tem
)) + 1; /* count the blank */
1142 new_argv
= (unsigned char *) alloca (len
);
1143 strcpy (new_argv
, XSTRING (program
)->data
);
1144 for (i
= 3; i
< nargs
; i
++)
1147 CHECK_STRING (tem
, i
);
1148 strcat (new_argv
, " ");
1149 strcat (new_argv
, XSTRING (tem
)->data
);
1151 /* Need to add code here to check for program existence on VMS */
1154 new_argv
= (unsigned char **) alloca ((nargs
- 1) * sizeof (char *));
1156 /* If program file name is not absolute, search our path for it */
1157 if (!IS_DIRECTORY_SEP (XSTRING (program
)->data
[0])
1158 && !(XSTRING (program
)->size
> 1
1159 && IS_DEVICE_SEP (XSTRING (program
)->data
[1])))
1161 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1164 GCPRO4 (name
, program
, buffer
, current_dir
);
1165 openp (Vexec_path
, program
, EXEC_SUFFIXES
, &tem
, 1);
1168 report_file_error ("Searching for program", Fcons (program
, Qnil
));
1169 tem
= Fexpand_file_name (tem
, Qnil
);
1170 new_argv
[0] = XSTRING (tem
)->data
;
1174 if (!NILP (Ffile_directory_p (program
)))
1175 error ("Specified program for new process is a directory");
1177 new_argv
[0] = XSTRING (program
)->data
;
1180 for (i
= 3; i
< nargs
; i
++)
1183 CHECK_STRING (tem
, i
);
1184 new_argv
[i
- 2] = XSTRING (tem
)->data
;
1186 new_argv
[i
- 2] = 0;
1187 #endif /* not VMS */
1189 proc
= make_process (name
);
1190 /* If an error occurs and we can't start the process, we want to
1191 remove it from the process list. This means that each error
1192 check in create_process doesn't need to call remove_process
1193 itself; it's all taken care of here. */
1194 record_unwind_protect (start_process_unwind
, proc
);
1196 XPROCESS (proc
)->childp
= Qt
;
1197 XPROCESS (proc
)->command_channel_p
= Qnil
;
1198 XPROCESS (proc
)->buffer
= buffer
;
1199 XPROCESS (proc
)->sentinel
= Qnil
;
1200 XPROCESS (proc
)->filter
= Qnil
;
1201 XPROCESS (proc
)->command
= Flist (nargs
- 2, args
+ 2);
1203 /* Make the process marker point into the process buffer (if any). */
1205 set_marker_both (XPROCESS (proc
)->mark
, buffer
,
1206 BUF_ZV (XBUFFER (buffer
)),
1207 BUF_ZV_BYTE (XBUFFER (buffer
)));
1210 /* Decide coding systems for communicating with the process. Here
1211 we don't setup the structure coding_system nor pay attention to
1212 unibyte mode. They are done in create_process. */
1214 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
1215 Lisp_Object coding_systems
= Qt
;
1216 Lisp_Object val
, *args2
;
1217 struct gcpro gcpro1
;
1219 val
= Vcoding_system_for_read
;
1222 args2
= (Lisp_Object
*) alloca ((nargs
+ 1) * sizeof *args2
);
1223 args2
[0] = Qstart_process
;
1224 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
1226 coding_systems
= Ffind_operation_coding_system (nargs
+ 1, args2
);
1228 if (CONSP (coding_systems
))
1229 val
= XCONS (coding_systems
)->car
;
1230 else if (CONSP (Vdefault_process_coding_system
))
1231 val
= XCONS (Vdefault_process_coding_system
)->car
;
1233 XPROCESS (proc
)->decode_coding_system
= val
;
1235 val
= Vcoding_system_for_write
;
1238 if (EQ (coding_systems
, Qt
))
1240 args2
= (Lisp_Object
*) alloca ((nargs
+ 1) * sizeof args2
);
1241 args2
[0] = Qstart_process
;
1242 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
1244 coding_systems
= Ffind_operation_coding_system (nargs
+ 1, args2
);
1247 if (CONSP (coding_systems
))
1248 val
= XCONS (coding_systems
)->cdr
;
1249 else if (CONSP (Vdefault_process_coding_system
))
1250 val
= XCONS (Vdefault_process_coding_system
)->cdr
;
1252 XPROCESS (proc
)->encode_coding_system
= val
;
1255 XPROCESS (proc
)->decoding_buf
= make_uninit_string (0);
1256 XPROCESS (proc
)->decoding_carryover
= make_number (0);
1257 XPROCESS (proc
)->encoding_buf
= make_uninit_string (0);
1258 XPROCESS (proc
)->encoding_carryover
= make_number (0);
1260 XPROCESS (proc
)->inherit_coding_system_flag
1261 = (NILP (buffer
) || !inherit_process_coding_system
1264 create_process (proc
, (char **) new_argv
, current_dir
);
1266 return unbind_to (count
, proc
);
1269 /* This function is the unwind_protect form for Fstart_process. If
1270 PROC doesn't have its pid set, then we know someone has signaled
1271 an error and the process wasn't started successfully, so we should
1272 remove it from the process list. */
1274 start_process_unwind (proc
)
1277 if (!PROCESSP (proc
))
1280 /* Was PROC started successfully? */
1281 if (XINT (XPROCESS (proc
)->pid
) <= 0)
1282 remove_process (proc
);
1289 create_process_1 (signo
)
1292 #if defined (USG) && !defined (POSIX_SIGNALS)
1293 /* USG systems forget handlers when they are used;
1294 must reestablish each time */
1295 signal (signo
, create_process_1
);
1299 #if 0 /* This doesn't work; see the note before sigchld_handler. */
1302 /* Mimic blocking of signals on system V, which doesn't really have it. */
1304 /* Nonzero means we got a SIGCHLD when it was supposed to be blocked. */
1305 int sigchld_deferred
;
1308 create_process_sigchld ()
1310 signal (SIGCHLD
, create_process_sigchld
);
1312 sigchld_deferred
= 1;
1318 #ifndef VMS /* VMS version of this function is in vmsproc.c. */
1320 create_process (process
, new_argv
, current_dir
)
1321 Lisp_Object process
;
1323 Lisp_Object current_dir
;
1325 int pid
, inchannel
, outchannel
;
1327 #ifdef POSIX_SIGNALS
1330 struct sigaction sigint_action
;
1331 struct sigaction sigquit_action
;
1333 struct sigaction sighup_action
;
1335 #else /* !POSIX_SIGNALS */
1337 SIGTYPE (*sigchld
)();
1339 #endif /* !POSIX_SIGNALS */
1340 /* Use volatile to protect variables from being clobbered by longjmp. */
1341 volatile int forkin
, forkout
;
1342 volatile int pty_flag
= 0;
1343 extern char **environ
;
1344 Lisp_Object buffer
= XPROCESS (process
)->buffer
;
1346 inchannel
= outchannel
= -1;
1349 if (!NILP (Vprocess_connection_type
))
1350 outchannel
= inchannel
= allocate_pty ();
1355 /* On USG systems it does not work to open the pty's tty here
1356 and then close and reopen it in the child. */
1358 /* Don't let this terminal become our controlling terminal
1359 (in case we don't have one). */
1360 forkout
= forkin
= open (pty_name
, O_RDWR
| O_NOCTTY
, 0);
1362 forkout
= forkin
= open (pty_name
, O_RDWR
, 0);
1365 report_file_error ("Opening pty", Qnil
);
1367 forkin
= forkout
= -1;
1368 #endif /* not USG */
1372 #endif /* HAVE_PTYS */
1375 if (socketpair (AF_UNIX
, SOCK_STREAM
, 0, sv
) < 0)
1376 report_file_error ("Opening socketpair", Qnil
);
1377 outchannel
= inchannel
= sv
[0];
1378 forkout
= forkin
= sv
[1];
1380 #else /* not SKTPAIR */
1389 #endif /* not SKTPAIR */
1392 /* Replaced by close_process_descs */
1393 set_exclusive_use (inchannel
);
1394 set_exclusive_use (outchannel
);
1397 /* Stride people say it's a mystery why this is needed
1398 as well as the O_NDELAY, but that it fails without this. */
1399 #if defined (STRIDE) || (defined (pfa) && defined (HAVE_PTYS))
1402 ioctl (inchannel
, FIONBIO
, &one
);
1407 fcntl (inchannel
, F_SETFL
, O_NONBLOCK
);
1408 fcntl (outchannel
, F_SETFL
, O_NONBLOCK
);
1411 fcntl (inchannel
, F_SETFL
, O_NDELAY
);
1412 fcntl (outchannel
, F_SETFL
, O_NDELAY
);
1416 /* Record this as an active process, with its channels.
1417 As a result, child_setup will close Emacs's side of the pipes. */
1418 chan_process
[inchannel
] = process
;
1419 XSETINT (XPROCESS (process
)->infd
, inchannel
);
1420 XSETINT (XPROCESS (process
)->outfd
, outchannel
);
1421 /* Record the tty descriptor used in the subprocess. */
1423 XPROCESS (process
)->subtty
= Qnil
;
1425 XSETFASTINT (XPROCESS (process
)->subtty
, forkin
);
1426 XPROCESS (process
)->pty_flag
= (pty_flag
? Qt
: Qnil
);
1427 XPROCESS (process
)->status
= Qrun
;
1428 if (!proc_decode_coding_system
[inchannel
])
1429 proc_decode_coding_system
[inchannel
]
1430 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
1431 setup_coding_system (XPROCESS (process
)->decode_coding_system
,
1432 proc_decode_coding_system
[inchannel
]);
1433 if (!proc_encode_coding_system
[outchannel
])
1434 proc_encode_coding_system
[outchannel
]
1435 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
1436 setup_coding_system (XPROCESS (process
)->encode_coding_system
,
1437 proc_encode_coding_system
[outchannel
]);
1439 if (!NILP (buffer
) && NILP (XBUFFER (buffer
)->enable_multibyte_characters
)
1440 || (NILP (buffer
) && NILP (buffer_defaults
.enable_multibyte_characters
)))
1442 /* In unibyte mode, character code conversion should not take
1443 place but EOL conversion should. So, setup raw-text or one
1444 of the subsidiary according to the information just setup. */
1445 if (NILP (Vcoding_system_for_read
)
1446 && !NILP (XPROCESS (process
)->decode_coding_system
))
1447 setup_raw_text_coding_system (proc_decode_coding_system
[inchannel
]);
1448 if (NILP (Vcoding_system_for_write
)
1449 && !NILP (XPROCESS (process
)->encode_coding_system
))
1450 setup_raw_text_coding_system (proc_encode_coding_system
[outchannel
]);
1453 if (CODING_REQUIRE_ENCODING (proc_encode_coding_system
[outchannel
]))
1455 /* Here we encode arguments by the coding system used for
1456 sending data to the process. We don't support using
1457 different coding systems for encoding arguments and for
1458 encoding data sent to the process. */
1459 struct gcpro gcpro1
;
1461 struct coding_system
*coding
= proc_encode_coding_system
[outchannel
];
1463 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
1465 while (new_argv
[i
] != 0)
1467 int len
= strlen (new_argv
[i
]);
1468 int size
= encoding_buffer_size (coding
, len
);
1469 unsigned char *buf
= (unsigned char *) alloca (size
);
1471 encode_coding (coding
, (unsigned char *)new_argv
[i
], buf
, len
, size
);
1472 buf
[coding
->produced
] = 0;
1473 /* We don't have to free new_argv[i] because it points to a
1474 Lisp string given as an argument to `start-process'. */
1475 new_argv
[i
++] = (char *) buf
;
1478 coding
->mode
&= ~CODING_MODE_LAST_BLOCK
;
1481 /* Delay interrupts until we have a chance to store
1482 the new fork's pid in its process structure */
1483 #ifdef POSIX_SIGNALS
1484 sigemptyset (&blocked
);
1486 sigaddset (&blocked
, SIGCHLD
);
1489 /* On many hosts (e.g. Solaris 2.4), if a vforked child calls `signal',
1490 this sets the parent's signal handlers as well as the child's.
1491 So delay all interrupts whose handlers the child might munge,
1492 and record the current handlers so they can be restored later. */
1493 sigaddset (&blocked
, SIGINT
); sigaction (SIGINT
, 0, &sigint_action
);
1494 sigaddset (&blocked
, SIGQUIT
); sigaction (SIGQUIT
, 0, &sigquit_action
);
1496 sigaddset (&blocked
, SIGHUP
); sigaction (SIGHUP
, 0, &sighup_action
);
1498 #endif /* HAVE_VFORK */
1499 sigprocmask (SIG_BLOCK
, &blocked
, &procmask
);
1500 #else /* !POSIX_SIGNALS */
1504 #else /* not BSD4_1 */
1505 #if defined (BSD_SYSTEM) || defined (UNIPLUS) || defined (HPUX)
1506 sigsetmask (sigmask (SIGCHLD
));
1507 #else /* ordinary USG */
1509 sigchld_deferred
= 0;
1510 sigchld
= signal (SIGCHLD
, create_process_sigchld
);
1512 #endif /* ordinary USG */
1513 #endif /* not BSD4_1 */
1514 #endif /* SIGCHLD */
1515 #endif /* !POSIX_SIGNALS */
1517 FD_SET (inchannel
, &input_wait_mask
);
1518 FD_SET (inchannel
, &non_keyboard_wait_mask
);
1519 if (inchannel
> max_process_desc
)
1520 max_process_desc
= inchannel
;
1522 /* Until we store the proper pid, enable sigchld_handler
1523 to recognize an unknown pid as standing for this process.
1524 It is very important not to let this `marker' value stay
1525 in the table after this function has returned; if it does
1526 it might cause call-process to hang and subsequent asynchronous
1527 processes to get their return values scrambled. */
1528 XSETINT (XPROCESS (process
)->pid
, -1);
1533 /* child_setup must clobber environ on systems with true vfork.
1534 Protect it from permanent change. */
1535 char **save_environ
= environ
;
1537 current_dir
= ENCODE_FILE (current_dir
);
1542 #endif /* not WINDOWSNT */
1544 int xforkin
= forkin
;
1545 int xforkout
= forkout
;
1547 #if 0 /* This was probably a mistake--it duplicates code later on,
1548 but fails to handle all the cases. */
1549 /* Make sure SIGCHLD is not blocked in the child. */
1550 sigsetmask (SIGEMPTYMASK
);
1553 /* Make the pty be the controlling terminal of the process. */
1555 /* First, disconnect its current controlling terminal. */
1557 /* We tried doing setsid only if pty_flag, but it caused
1558 process_set_signal to fail on SGI when using a pipe. */
1560 /* Make the pty's terminal the controlling terminal. */
1564 /* We ignore the return value
1565 because faith@cs.unc.edu says that is necessary on Linux. */
1566 ioctl (xforkin
, TIOCSCTTY
, 0);
1569 #else /* not HAVE_SETSID */
1571 /* It's very important to call setpgrp here and no time
1572 afterwards. Otherwise, we lose our controlling tty which
1573 is set when we open the pty. */
1576 #endif /* not HAVE_SETSID */
1577 #if defined (HAVE_TERMIOS) && defined (LDISC1)
1578 if (pty_flag
&& xforkin
>= 0)
1581 tcgetattr (xforkin
, &t
);
1583 if (tcsetattr (xforkin
, TCSANOW
, &t
) < 0)
1584 write (1, "create_process/tcsetattr LDISC1 failed\n", 39);
1587 #if defined (NTTYDISC) && defined (TIOCSETD)
1588 if (pty_flag
&& xforkin
>= 0)
1590 /* Use new line discipline. */
1591 int ldisc
= NTTYDISC
;
1592 ioctl (xforkin
, TIOCSETD
, &ldisc
);
1597 /* In 4.3BSD, the TIOCSPGRP bug has been fixed, and now you
1598 can do TIOCSPGRP only to the process's controlling tty. */
1601 /* I wonder: would just ioctl (0, TIOCNOTTY, 0) work here?
1602 I can't test it since I don't have 4.3. */
1603 int j
= open ("/dev/tty", O_RDWR
, 0);
1604 ioctl (j
, TIOCNOTTY
, 0);
1607 /* In order to get a controlling terminal on some versions
1608 of BSD, it is necessary to put the process in pgrp 0
1609 before it opens the terminal. */
1617 #endif /* TIOCNOTTY */
1619 #if !defined (RTU) && !defined (UNIPLUS) && !defined (DONT_REOPEN_PTY)
1620 /*** There is a suggestion that this ought to be a
1621 conditional on TIOCSPGRP,
1622 or !(defined (HAVE_SETSID) && defined (TIOCSCTTY)).
1623 Trying the latter gave the wrong results on Debian GNU/Linux 1.1;
1624 that system does seem to need this code, even though
1625 both HAVE_SETSID and TIOCSCTTY are defined. */
1626 /* Now close the pty (if we had it open) and reopen it.
1627 This makes the pty the controlling terminal of the subprocess. */
1630 #ifdef SET_CHILD_PTY_PGRP
1631 int pgrp
= getpid ();
1634 /* I wonder if close (open (pty_name, ...)) would work? */
1637 xforkout
= xforkin
= open (pty_name
, O_RDWR
, 0);
1641 write (1, "Couldn't open the pty terminal ", 31);
1642 write (1, pty_name
, strlen (pty_name
));
1647 #ifdef SET_CHILD_PTY_PGRP
1648 ioctl (xforkin
, TIOCSPGRP
, &pgrp
);
1649 ioctl (xforkout
, TIOCSPGRP
, &pgrp
);
1652 #endif /* not UNIPLUS and not RTU and not DONT_REOPEN_PTY */
1654 #ifdef SETUP_SLAVE_PTY
1659 #endif /* SETUP_SLAVE_PTY */
1661 /* On AIX, we've disabled SIGHUP above once we start a child on a pty.
1662 Now reenable it in the child, so it will die when we want it to. */
1664 signal (SIGHUP
, SIG_DFL
);
1666 #endif /* HAVE_PTYS */
1668 signal (SIGINT
, SIG_DFL
);
1669 signal (SIGQUIT
, SIG_DFL
);
1671 /* Stop blocking signals in the child. */
1672 #ifdef POSIX_SIGNALS
1673 sigprocmask (SIG_SETMASK
, &procmask
, 0);
1674 #else /* !POSIX_SIGNALS */
1678 #else /* not BSD4_1 */
1679 #if defined (BSD_SYSTEM) || defined (UNIPLUS) || defined (HPUX)
1680 sigsetmask (SIGEMPTYMASK
);
1681 #else /* ordinary USG */
1683 signal (SIGCHLD
, sigchld
);
1685 #endif /* ordinary USG */
1686 #endif /* not BSD4_1 */
1687 #endif /* SIGCHLD */
1688 #endif /* !POSIX_SIGNALS */
1691 child_setup_tty (xforkout
);
1693 pid
= child_setup (xforkin
, xforkout
, xforkout
,
1694 new_argv
, 1, current_dir
);
1695 #else /* not WINDOWSNT */
1696 child_setup (xforkin
, xforkout
, xforkout
,
1697 new_argv
, 1, current_dir
);
1698 #endif /* not WINDOWSNT */
1700 environ
= save_environ
;
1705 /* This runs in the Emacs process. */
1710 if (forkin
!= forkout
&& forkout
>= 0)
1715 /* vfork succeeded. */
1716 XSETFASTINT (XPROCESS (process
)->pid
, pid
);
1719 register_child (pid
, inchannel
);
1720 #endif /* WINDOWSNT */
1722 /* If the subfork execv fails, and it exits,
1723 this close hangs. I don't know why.
1724 So have an interrupt jar it loose. */
1726 signal (SIGALRM
, create_process_1
);
1728 XPROCESS (process
)->subtty
= Qnil
;
1733 if (forkin
!= forkout
&& forkout
>= 0)
1738 XPROCESS (process
)->tty_name
= build_string (pty_name
);
1741 XPROCESS (process
)->tty_name
= Qnil
;
1744 /* Restore the signal state whether vfork succeeded or not.
1745 (We will signal an error, below, if it failed.) */
1746 #ifdef POSIX_SIGNALS
1748 /* Restore the parent's signal handlers. */
1749 sigaction (SIGINT
, &sigint_action
, 0);
1750 sigaction (SIGQUIT
, &sigquit_action
, 0);
1752 sigaction (SIGHUP
, &sighup_action
, 0);
1754 #endif /* HAVE_VFORK */
1755 /* Stop blocking signals in the parent. */
1756 sigprocmask (SIG_SETMASK
, &procmask
, 0);
1757 #else /* !POSIX_SIGNALS */
1761 #else /* not BSD4_1 */
1762 #if defined (BSD_SYSTEM) || defined (UNIPLUS) || defined (HPUX)
1763 sigsetmask (SIGEMPTYMASK
);
1764 #else /* ordinary USG */
1766 signal (SIGCHLD
, sigchld
);
1767 /* Now really handle any of these signals
1768 that came in during this function. */
1769 if (sigchld_deferred
)
1770 kill (getpid (), SIGCHLD
);
1772 #endif /* ordinary USG */
1773 #endif /* not BSD4_1 */
1774 #endif /* SIGCHLD */
1775 #endif /* !POSIX_SIGNALS */
1777 /* Now generate the error if vfork failed. */
1779 report_file_error ("Doing vfork", Qnil
);
1781 #endif /* not VMS */
1785 /* open a TCP network connection to a given HOST/SERVICE. Treated
1786 exactly like a normal process when reading and writing. Only
1787 differences are in status display and process deletion. A network
1788 connection has no PID; you cannot signal it. All you can do is
1789 deactivate and close it via delete-process */
1791 DEFUN ("open-network-stream", Fopen_network_stream
, Sopen_network_stream
,
1793 "Open a TCP connection for a service to a host.\n\
1794 Returns a subprocess-object to represent the connection.\n\
1795 Input and output work as for subprocesses; `delete-process' closes it.\n\
1796 Args are NAME BUFFER HOST SERVICE.\n\
1797 NAME is name for process. It is modified if necessary to make it unique.\n\
1798 BUFFER is the buffer (or buffer-name) to associate with the process.\n\
1799 Process output goes at end of that buffer, unless you specify\n\
1800 an output stream or filter function to handle the output.\n\
1801 BUFFER may be also nil, meaning that this process is not associated\n\
1803 Third arg is name of the host to connect to, or its IP address.\n\
1804 Fourth arg SERVICE is name of the service desired, or an integer\n\
1805 specifying a port number to connect to.")
1806 (name
, buffer
, host
, service
)
1807 Lisp_Object name
, buffer
, host
, service
;
1811 struct sockaddr_in address
;
1812 struct servent
*svc_info
;
1813 struct hostent
*host_info_ptr
, host_info
;
1814 char *(addr_list
[2]);
1815 IN_ADDR numeric_addr
;
1819 struct hostent host_info_fixed
;
1820 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1822 int count
= specpdl_ptr
- specpdl
;
1825 /* Ensure socket support is loaded if available. */
1826 init_winsock (TRUE
);
1829 GCPRO4 (name
, buffer
, host
, service
);
1830 CHECK_STRING (name
, 0);
1831 CHECK_STRING (host
, 0);
1832 if (INTEGERP (service
))
1833 port
= htons ((unsigned short) XINT (service
));
1836 CHECK_STRING (service
, 0);
1837 svc_info
= getservbyname (XSTRING (service
)->data
, "tcp");
1839 error ("Unknown service \"%s\"", XSTRING (service
)->data
);
1840 port
= svc_info
->s_port
;
1843 /* Slow down polling to every ten seconds.
1844 Some kernels have a bug which causes retrying connect to fail
1845 after a connect. Polling can interfere with gethostbyname too. */
1846 #ifdef POLL_FOR_INPUT
1847 bind_polling_period (10);
1858 host_info_ptr
= gethostbyname (XSTRING (host
)->data
);
1861 if (! (host_info_ptr
== 0 && h_errno
== TRY_AGAIN
))
1864 Fsleep_for (make_number (1), Qnil
);
1866 if (host_info_ptr
== 0)
1867 /* Attempt to interpret host as numeric inet address */
1869 numeric_addr
= inet_addr ((char *) XSTRING (host
)->data
);
1870 if (NUMERIC_ADDR_ERROR
)
1871 error ("Unknown host \"%s\"", XSTRING (host
)->data
);
1873 host_info_ptr
= &host_info
;
1874 host_info
.h_name
= 0;
1875 host_info
.h_aliases
= 0;
1876 host_info
.h_addrtype
= AF_INET
;
1878 /* Older machines have only one address slot called h_addr.
1879 Newer machines have h_addr_list, but #define h_addr to
1880 be its first element. */
1881 host_info
.h_addr_list
= &(addr_list
[0]);
1883 host_info
.h_addr
= (char*)(&numeric_addr
);
1885 /* numeric_addr isn't null-terminated; it has fixed length. */
1886 host_info
.h_length
= sizeof (numeric_addr
);
1889 bzero (&address
, sizeof address
);
1890 bcopy (host_info_ptr
->h_addr
, (char *) &address
.sin_addr
,
1891 host_info_ptr
->h_length
);
1892 address
.sin_family
= host_info_ptr
->h_addrtype
;
1893 address
.sin_port
= port
;
1895 s
= socket (host_info_ptr
->h_addrtype
, SOCK_STREAM
, 0);
1897 report_file_error ("error creating socket", Fcons (name
, Qnil
));
1899 /* Kernel bugs (on Ultrix at least) cause lossage (not just EINTR)
1900 when connect is interrupted. So let's not let it get interrupted.
1901 Note we do not turn off polling, because polling is only used
1902 when not interrupt_input, and thus not normally used on the systems
1903 which have this bug. On systems which use polling, there's no way
1904 to quit if polling is turned off. */
1905 if (interrupt_input
)
1913 if (connect (s
, (struct sockaddr
*) &address
, sizeof address
) == -1
1914 && errno
!= EISCONN
)
1922 if (errno
== EADDRINUSE
&& retry
< 20)
1924 /* A delay here is needed on some FreeBSD systems,
1925 and it is harmless, since this retrying takes time anyway
1926 and should be infrequent. */
1927 Fsleep_for (make_number (1), Qnil
);
1934 if (interrupt_input
)
1938 report_file_error ("connection failed",
1939 Fcons (host
, Fcons (name
, Qnil
)));
1944 #ifdef POLL_FOR_INPUT
1945 unbind_to (count
, Qnil
);
1948 if (interrupt_input
)
1952 s
= connect_server (0);
1954 report_file_error ("error creating socket", Fcons (name
, Qnil
));
1955 send_command (s
, C_PORT
, 0, "%s:%d", XSTRING (host
)->data
, ntohs (port
));
1956 send_command (s
, C_DUMB
, 1, 0);
1963 buffer
= Fget_buffer_create (buffer
);
1964 proc
= make_process (name
);
1966 chan_process
[inch
] = proc
;
1969 fcntl (inch
, F_SETFL
, O_NONBLOCK
);
1972 fcntl (inch
, F_SETFL
, O_NDELAY
);
1976 XPROCESS (proc
)->childp
= Fcons (host
, Fcons (service
, Qnil
));
1977 XPROCESS (proc
)->command_channel_p
= Qnil
;
1978 XPROCESS (proc
)->buffer
= buffer
;
1979 XPROCESS (proc
)->sentinel
= Qnil
;
1980 XPROCESS (proc
)->filter
= Qnil
;
1981 XPROCESS (proc
)->command
= Qnil
;
1982 XPROCESS (proc
)->pid
= Qnil
;
1983 XSETINT (XPROCESS (proc
)->infd
, inch
);
1984 XSETINT (XPROCESS (proc
)->outfd
, outch
);
1985 XPROCESS (proc
)->status
= Qrun
;
1986 FD_SET (inch
, &input_wait_mask
);
1987 FD_SET (inch
, &non_keyboard_wait_mask
);
1988 if (inch
> max_process_desc
)
1989 max_process_desc
= inch
;
1992 /* Setup coding systems for communicating with the network stream. */
1993 struct gcpro gcpro1
;
1994 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
1995 Lisp_Object coding_systems
= Qt
;
1996 Lisp_Object args
[5], val
;
1998 if (!NILP (Vcoding_system_for_read
))
1999 val
= Vcoding_system_for_read
;
2000 else if (!NILP (buffer
) && NILP (XBUFFER (buffer
)->enable_multibyte_characters
)
2001 || NILP (buffer
) && NILP (buffer_defaults
.enable_multibyte_characters
))
2002 /* We dare not decode end-of-line format by setting VAL to
2003 Qraw_text, because the existing Emacs Lisp libraries
2004 assume that they receive bare code including a sequene of
2009 args
[0] = Qopen_network_stream
, args
[1] = name
,
2010 args
[2] = buffer
, args
[3] = host
, args
[4] = service
;
2012 coding_systems
= Ffind_operation_coding_system (5, args
);
2014 if (CONSP (coding_systems
))
2015 val
= XCONS (coding_systems
)->car
;
2016 else if (CONSP (Vdefault_process_coding_system
))
2017 val
= XCONS (Vdefault_process_coding_system
)->car
;
2021 XPROCESS (proc
)->decode_coding_system
= val
;
2023 if (!NILP (Vcoding_system_for_write
))
2024 val
= Vcoding_system_for_write
;
2025 else if (NILP (current_buffer
->enable_multibyte_characters
))
2029 if (EQ (coding_systems
, Qt
))
2031 args
[0] = Qopen_network_stream
, args
[1] = name
,
2032 args
[2] = buffer
, args
[3] = host
, args
[4] = service
;
2034 coding_systems
= Ffind_operation_coding_system (5, args
);
2037 if (CONSP (coding_systems
))
2038 val
= XCONS (coding_systems
)->cdr
;
2039 else if (CONSP (Vdefault_process_coding_system
))
2040 val
= XCONS (Vdefault_process_coding_system
)->cdr
;
2044 XPROCESS (proc
)->encode_coding_system
= val
;
2047 if (!proc_decode_coding_system
[inch
])
2048 proc_decode_coding_system
[inch
]
2049 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
2050 setup_coding_system (XPROCESS (proc
)->decode_coding_system
,
2051 proc_decode_coding_system
[inch
]);
2052 if (!proc_encode_coding_system
[outch
])
2053 proc_encode_coding_system
[outch
]
2054 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
2055 setup_coding_system (XPROCESS (proc
)->encode_coding_system
,
2056 proc_encode_coding_system
[outch
]);
2058 XPROCESS (proc
)->decoding_buf
= make_uninit_string (0);
2059 XPROCESS (proc
)->decoding_carryover
= make_number (0);
2060 XPROCESS (proc
)->encoding_buf
= make_uninit_string (0);
2061 XPROCESS (proc
)->encoding_carryover
= make_number (0);
2063 XPROCESS (proc
)->inherit_coding_system_flag
2064 = (NILP (buffer
) || !inherit_process_coding_system
2070 #endif /* HAVE_SOCKETS */
2073 deactivate_process (proc
)
2076 register int inchannel
, outchannel
;
2077 register struct Lisp_Process
*p
= XPROCESS (proc
);
2079 inchannel
= XINT (p
->infd
);
2080 outchannel
= XINT (p
->outfd
);
2084 /* Beware SIGCHLD hereabouts. */
2085 flush_pending_output (inchannel
);
2088 VMS_PROC_STUFF
*get_vms_process_pointer (), *vs
;
2089 sys$
dassgn (outchannel
);
2090 vs
= get_vms_process_pointer (p
->pid
);
2092 give_back_vms_process_stuff (vs
);
2096 if (outchannel
>= 0 && outchannel
!= inchannel
)
2100 XSETINT (p
->infd
, -1);
2101 XSETINT (p
->outfd
, -1);
2102 chan_process
[inchannel
] = Qnil
;
2103 FD_CLR (inchannel
, &input_wait_mask
);
2104 FD_CLR (inchannel
, &non_keyboard_wait_mask
);
2105 if (inchannel
== max_process_desc
)
2108 /* We just closed the highest-numbered process input descriptor,
2109 so recompute the highest-numbered one now. */
2110 max_process_desc
= 0;
2111 for (i
= 0; i
< MAXDESC
; i
++)
2112 if (!NILP (chan_process
[i
]))
2113 max_process_desc
= i
;
2118 /* Close all descriptors currently in use for communication
2119 with subprocess. This is used in a newly-forked subprocess
2120 to get rid of irrelevant descriptors. */
2123 close_process_descs ()
2127 for (i
= 0; i
< MAXDESC
; i
++)
2129 Lisp_Object process
;
2130 process
= chan_process
[i
];
2131 if (!NILP (process
))
2133 int in
= XINT (XPROCESS (process
)->infd
);
2134 int out
= XINT (XPROCESS (process
)->outfd
);
2137 if (out
>= 0 && in
!= out
)
2144 DEFUN ("accept-process-output", Faccept_process_output
, Saccept_process_output
,
2146 "Allow any pending output from subprocesses to be read by Emacs.\n\
2147 It is read into the process' buffers or given to their filter functions.\n\
2148 Non-nil arg PROCESS means do not return until some output has been received\n\
2150 Non-nil second arg TIMEOUT and third arg TIMEOUT-MSECS are number of\n\
2151 seconds and microseconds to wait; return after that much time whether\n\
2152 or not there is input.\n\
2153 Return non-nil iff we received any output before the timeout expired.")
2154 (process
, timeout
, timeout_msecs
)
2155 register Lisp_Object process
, timeout
, timeout_msecs
;
2160 if (! NILP (process
))
2161 CHECK_PROCESS (process
, 0);
2163 if (! NILP (timeout_msecs
))
2165 CHECK_NUMBER (timeout_msecs
, 2);
2166 useconds
= XINT (timeout_msecs
);
2167 if (!INTEGERP (timeout
))
2168 XSETINT (timeout
, 0);
2171 int carry
= useconds
/ 1000000;
2173 XSETINT (timeout
, XINT (timeout
) + carry
);
2174 useconds
-= carry
* 1000000;
2176 /* I think this clause is necessary because C doesn't
2177 guarantee a particular rounding direction for negative
2181 XSETINT (timeout
, XINT (timeout
) - 1);
2182 useconds
+= 1000000;
2189 if (! NILP (timeout
))
2191 CHECK_NUMBER (timeout
, 1);
2192 seconds
= XINT (timeout
);
2193 if (seconds
< 0 || (seconds
== 0 && useconds
== 0))
2205 XSETFASTINT (process
, 0);
2208 (wait_reading_process_input (seconds
, useconds
, process
, 0)
2212 /* This variable is different from waiting_for_input in keyboard.c.
2213 It is used to communicate to a lisp process-filter/sentinel (via the
2214 function Fwaiting_for_user_input_p below) whether emacs was waiting
2215 for user-input when that process-filter was called.
2216 waiting_for_input cannot be used as that is by definition 0 when
2217 lisp code is being evalled.
2218 This is also used in record_asynch_buffer_change.
2219 For that purpose, this must be 0
2220 when not inside wait_reading_process_input. */
2221 static int waiting_for_user_input_p
;
2223 /* This is here so breakpoints can be put on it. */
2225 wait_reading_process_input_1 ()
2229 /* Read and dispose of subprocess output while waiting for timeout to
2230 elapse and/or keyboard input to be available.
2233 timeout in seconds, or
2234 zero for no limit, or
2235 -1 means gobble data immediately available but don't wait for any.
2238 an additional duration to wait, measured in microseconds.
2239 If this is nonzero and time_limit is 0, then the timeout
2240 consists of MICROSECS only.
2242 READ_KBD is a lisp value:
2243 0 to ignore keyboard input, or
2244 1 to return when input is available, or
2245 -1 meaning caller will actually read the input, so don't throw to
2246 the quit handler, or
2247 a cons cell, meaning wait until its car is non-nil
2248 (and gobble terminal input into the buffer if any arrives), or
2249 a process object, meaning wait until something arrives from that
2250 process. The return value is true iff we read some input from
2253 DO_DISPLAY != 0 means redisplay should be done to show subprocess
2254 output that arrives.
2256 If READ_KBD is a pointer to a struct Lisp_Process, then the
2257 function returns true iff we received input from that process
2258 before the timeout elapsed.
2259 Otherwise, return true iff we received input from any process. */
2262 wait_reading_process_input (time_limit
, microsecs
, read_kbd
, do_display
)
2263 int time_limit
, microsecs
;
2264 Lisp_Object read_kbd
;
2267 register int channel
, nfds
, m
;
2268 static SELECT_TYPE Available
;
2271 EMACS_TIME timeout
, end_time
, garbage
;
2273 int wait_channel
= -1;
2274 struct Lisp_Process
*wait_proc
= 0;
2275 int got_some_input
= 0;
2276 Lisp_Object
*wait_for_cell
= 0;
2278 FD_ZERO (&Available
);
2280 /* If read_kbd is a process to watch, set wait_proc and wait_channel
2282 if (PROCESSP (read_kbd
))
2284 wait_proc
= XPROCESS (read_kbd
);
2285 wait_channel
= XINT (wait_proc
->infd
);
2286 XSETFASTINT (read_kbd
, 0);
2289 /* If waiting for non-nil in a cell, record where. */
2290 if (CONSP (read_kbd
))
2292 wait_for_cell
= &XCONS (read_kbd
)->car
;
2293 XSETFASTINT (read_kbd
, 0);
2296 waiting_for_user_input_p
= XINT (read_kbd
);
2298 /* Since we may need to wait several times,
2299 compute the absolute time to return at. */
2300 if (time_limit
|| microsecs
)
2302 EMACS_GET_TIME (end_time
);
2303 EMACS_SET_SECS_USECS (timeout
, time_limit
, microsecs
);
2304 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
2307 /* AlainF 5-Jul-1996
2308 HP-UX 10.10 seem to have problems with signals coming in
2309 Causes "poll: interrupted system call" messages when Emacs is run
2311 Turn off periodic alarms (in case they are in use) */
2317 int timeout_reduced_for_timers
= 0;
2319 /* If calling from keyboard input, do not quit
2320 since we want to return C-g as an input character.
2321 Otherwise, do pending quit if requested. */
2322 if (XINT (read_kbd
) >= 0)
2325 /* Exit now if the cell we're waiting for became non-nil. */
2326 if (wait_for_cell
&& ! NILP (*wait_for_cell
))
2329 /* Compute time from now till when time limit is up */
2330 /* Exit if already run out */
2331 if (time_limit
== -1)
2333 /* -1 specified for timeout means
2334 gobble output available now
2335 but don't wait at all. */
2337 EMACS_SET_SECS_USECS (timeout
, 0, 0);
2339 else if (time_limit
|| microsecs
)
2341 EMACS_GET_TIME (timeout
);
2342 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
2343 if (EMACS_TIME_NEG_P (timeout
))
2348 EMACS_SET_SECS_USECS (timeout
, 100000, 0);
2351 /* Normally we run timers here.
2352 But not if wait_for_cell; in those cases,
2353 the wait is supposed to be short,
2354 and those callers cannot handle running arbitrary Lisp code here. */
2355 if (! wait_for_cell
)
2357 EMACS_TIME timer_delay
;
2361 old_timers_run
= timers_run
;
2362 timer_delay
= timer_check (1);
2363 if (timers_run
!= old_timers_run
&& do_display
)
2365 redisplay_preserve_echo_area ();
2366 /* We must retry, since a timer may have requeued itself
2367 and that could alter the time_delay. */
2371 /* If there is unread keyboard input, also return. */
2372 if (XINT (read_kbd
) != 0
2373 && requeued_events_pending_p ())
2376 if (! EMACS_TIME_NEG_P (timer_delay
) && time_limit
!= -1)
2378 EMACS_TIME difference
;
2379 EMACS_SUB_TIME (difference
, timer_delay
, timeout
);
2380 if (EMACS_TIME_NEG_P (difference
))
2382 timeout
= timer_delay
;
2383 timeout_reduced_for_timers
= 1;
2386 /* If time_limit is -1, we are not going to wait at all. */
2387 else if (time_limit
!= -1)
2389 /* This is so a breakpoint can be put here. */
2390 wait_reading_process_input_1 ();
2394 /* Cause C-g and alarm signals to take immediate action,
2395 and cause input available signals to zero out timeout.
2397 It is important that we do this before checking for process
2398 activity. If we get a SIGCHLD after the explicit checks for
2399 process activity, timeout is the only way we will know. */
2400 if (XINT (read_kbd
) < 0)
2401 set_waiting_for_input (&timeout
);
2403 /* If status of something has changed, and no input is
2404 available, notify the user of the change right away. After
2405 this explicit check, we'll let the SIGCHLD handler zap
2406 timeout to get our attention. */
2407 if (update_tick
!= process_tick
&& do_display
)
2409 Atemp
= input_wait_mask
;
2410 EMACS_SET_SECS_USECS (timeout
, 0, 0);
2411 if ((select (max (max_process_desc
, max_keyboard_desc
) + 1,
2412 &Atemp
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0,
2416 /* It's okay for us to do this and then continue with
2417 the loop, since timeout has already been zeroed out. */
2418 clear_waiting_for_input ();
2423 /* Don't wait for output from a non-running process. */
2424 if (wait_proc
!= 0 && !NILP (wait_proc
->raw_status_low
))
2425 update_status (wait_proc
);
2427 && ! EQ (wait_proc
->status
, Qrun
))
2429 int nread
, total_nread
= 0;
2431 clear_waiting_for_input ();
2432 XSETPROCESS (proc
, wait_proc
);
2434 /* Read data from the process, until we exhaust it. */
2435 while (XINT (wait_proc
->infd
) >= 0
2437 = read_process_output (proc
, XINT (wait_proc
->infd
))))
2440 total_nread
+= nread
;
2442 else if (nread
== -1 && EIO
== errno
)
2446 if (total_nread
> 0 && do_display
)
2447 redisplay_preserve_echo_area ();
2452 /* Wait till there is something to do */
2455 Available
= non_process_wait_mask
;
2456 else if (! XINT (read_kbd
))
2457 Available
= non_keyboard_wait_mask
;
2459 Available
= input_wait_mask
;
2461 /* If frame size has changed or the window is newly mapped,
2462 redisplay now, before we start to wait. There is a race
2463 condition here; if a SIGIO arrives between now and the select
2464 and indicates that a frame is trashed, the select may block
2465 displaying a trashed screen. */
2466 if (frame_garbaged
&& do_display
)
2468 clear_waiting_for_input ();
2469 redisplay_preserve_echo_area ();
2470 if (XINT (read_kbd
) < 0)
2471 set_waiting_for_input (&timeout
);
2474 if (XINT (read_kbd
) && detect_input_pending ())
2477 FD_ZERO (&Available
);
2480 nfds
= select (max (max_process_desc
, max_keyboard_desc
) + 1,
2481 &Available
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0,
2486 /* Make C-g and alarm signals set flags again */
2487 clear_waiting_for_input ();
2489 /* If we woke up due to SIGWINCH, actually change size now. */
2490 do_pending_window_change ();
2492 if (time_limit
&& nfds
== 0 && ! timeout_reduced_for_timers
)
2493 /* We wanted the full specified time, so return now. */
2497 if (xerrno
== EINTR
)
2498 FD_ZERO (&Available
);
2500 /* Ultrix select seems to return ENOMEM when it is
2501 interrupted. Treat it just like EINTR. Bleah. Note
2502 that we want to test for the "ultrix" CPP symbol, not
2503 "__ultrix__"; the latter is only defined under GCC, but
2504 not by DEC's bundled CC. -JimB */
2505 else if (xerrno
== ENOMEM
)
2506 FD_ZERO (&Available
);
2509 /* This happens for no known reason on ALLIANT.
2510 I am guessing that this is the right response. -- RMS. */
2511 else if (xerrno
== EFAULT
)
2512 FD_ZERO (&Available
);
2514 else if (xerrno
== EBADF
)
2517 /* AIX doesn't handle PTY closure the same way BSD does. On AIX,
2518 the child's closure of the pts gives the parent a SIGHUP, and
2519 the ptc file descriptor is automatically closed,
2520 yielding EBADF here or at select() call above.
2521 So, SIGHUP is ignored (see def of PTY_TTY_NAME_SPRINTF
2522 in m/ibmrt-aix.h), and here we just ignore the select error.
2523 Cleanup occurs c/o status_notify after SIGCLD. */
2524 FD_ZERO (&Available
); /* Cannot depend on values returned */
2530 error ("select error: %s", strerror (xerrno
));
2532 #if defined(sun) && !defined(USG5_4)
2533 else if (nfds
> 0 && keyboard_bit_set (&Available
)
2535 /* System sometimes fails to deliver SIGIO.
2537 David J. Mackenzie says that Emacs doesn't compile under
2538 Solaris if this code is enabled, thus the USG5_4 in the CPP
2539 conditional. "I haven't noticed any ill effects so far.
2540 If you find a Solaris expert somewhere, they might know
2542 kill (getpid (), SIGIO
);
2545 #if 0 /* When polling is used, interrupt_input is 0,
2546 so get_input_pending should read the input.
2547 So this should not be needed. */
2548 /* If we are using polling for input,
2549 and we see input available, make it get read now.
2550 Otherwise it might not actually get read for a second.
2551 And on hpux, since we turn off polling in wait_reading_process_input,
2552 it might never get read at all if we don't spend much time
2553 outside of wait_reading_process_input. */
2554 if (XINT (read_kbd
) && interrupt_input
2555 && keyboard_bit_set (&Available
)
2556 && input_polling_used ())
2557 kill (getpid (), SIGALRM
);
2560 /* Check for keyboard input */
2561 /* If there is any, return immediately
2562 to give it higher priority than subprocesses */
2564 if (XINT (read_kbd
) != 0
2565 && detect_input_pending_run_timers (do_display
))
2567 swallow_events (do_display
);
2568 if (detect_input_pending_run_timers (do_display
))
2572 /* If there is unread keyboard input, also return. */
2573 if (XINT (read_kbd
) != 0
2574 && requeued_events_pending_p ())
2577 /* If we are not checking for keyboard input now,
2578 do process events (but don't run any timers).
2579 This is so that X events will be processed.
2580 Otherwise they may have to wait until polling takes place.
2581 That would causes delays in pasting selections, for example.
2583 (We used to do this only if wait_for_cell.) */
2584 if (XINT (read_kbd
) == 0 && detect_input_pending ())
2586 swallow_events (do_display
);
2587 #if 0 /* Exiting when read_kbd doesn't request that seems wrong, though. */
2588 if (detect_input_pending ())
2593 /* Exit now if the cell we're waiting for became non-nil. */
2594 if (wait_for_cell
&& ! NILP (*wait_for_cell
))
2598 /* If we think we have keyboard input waiting, but didn't get SIGIO,
2599 go read it. This can happen with X on BSD after logging out.
2600 In that case, there really is no input and no SIGIO,
2601 but select says there is input. */
2603 if (XINT (read_kbd
) && interrupt_input
2604 && keyboard_bit_set (&Available
))
2605 kill (getpid (), SIGIO
);
2609 got_some_input
|= nfds
> 0;
2611 /* If checking input just got us a size-change event from X,
2612 obey it now if we should. */
2613 if (XINT (read_kbd
) || wait_for_cell
)
2614 do_pending_window_change ();
2616 /* Check for data from a process. */
2617 /* Really FIRST_PROC_DESC should be 0 on Unix,
2618 but this is safer in the short run. */
2619 for (channel
= 0; channel
<= max_process_desc
; channel
++)
2621 if (FD_ISSET (channel
, &Available
)
2622 && FD_ISSET (channel
, &non_keyboard_wait_mask
))
2626 /* If waiting for this channel, arrange to return as
2627 soon as no more input to be processed. No more
2629 if (wait_channel
== channel
)
2635 proc
= chan_process
[channel
];
2639 /* Read data from the process, starting with our
2640 buffered-ahead character if we have one. */
2642 nread
= read_process_output (proc
, channel
);
2645 /* Since read_process_output can run a filter,
2646 which can call accept-process-output,
2647 don't try to read from any other processes
2648 before doing the select again. */
2649 FD_ZERO (&Available
);
2652 redisplay_preserve_echo_area ();
2655 else if (nread
== -1 && errno
== EWOULDBLOCK
)
2658 /* ISC 4.1 defines both EWOULDBLOCK and O_NONBLOCK,
2659 and Emacs uses O_NONBLOCK, so what we get is EAGAIN. */
2661 else if (nread
== -1 && errno
== EAGAIN
)
2665 else if (nread
== -1 && errno
== EAGAIN
)
2667 /* Note that we cannot distinguish between no input
2668 available now and a closed pipe.
2669 With luck, a closed pipe will be accompanied by
2670 subprocess termination and SIGCHLD. */
2671 else if (nread
== 0 && !NETCONN_P (proc
))
2673 #endif /* O_NDELAY */
2674 #endif /* O_NONBLOCK */
2676 /* On some OSs with ptys, when the process on one end of
2677 a pty exits, the other end gets an error reading with
2678 errno = EIO instead of getting an EOF (0 bytes read).
2679 Therefore, if we get an error reading and errno =
2680 EIO, just continue, because the child process has
2681 exited and should clean itself up soon (e.g. when we
2684 However, it has been known to happen that the SIGCHLD
2685 got lost. So raise the signl again just in case.
2687 else if (nread
== -1 && errno
== EIO
)
2688 kill (getpid (), SIGCHLD
);
2689 #endif /* HAVE_PTYS */
2690 /* If we can detect process termination, don't consider the process
2691 gone just because its pipe is closed. */
2693 else if (nread
== 0 && !NETCONN_P (proc
))
2698 /* Preserve status of processes already terminated. */
2699 XSETINT (XPROCESS (proc
)->tick
, ++process_tick
);
2700 deactivate_process (proc
);
2701 if (!NILP (XPROCESS (proc
)->raw_status_low
))
2702 update_status (XPROCESS (proc
));
2703 if (EQ (XPROCESS (proc
)->status
, Qrun
))
2704 XPROCESS (proc
)->status
2705 = Fcons (Qexit
, Fcons (make_number (256), Qnil
));
2708 } /* end for each file descriptor */
2709 } /* end while exit conditions not met */
2711 waiting_for_user_input_p
= 0;
2713 /* If calling from keyboard input, do not quit
2714 since we want to return C-g as an input character.
2715 Otherwise, do pending quit if requested. */
2716 if (XINT (read_kbd
) >= 0)
2718 /* Prevent input_pending from remaining set if we quit. */
2719 clear_input_pending ();
2723 /* AlainF 5-Jul-1996
2724 HP-UX 10.10 seems to have problems with signals coming in
2725 Causes "poll: interrupted system call" messages when Emacs is run
2727 Turn periodic alarms back on */
2731 return got_some_input
;
2734 /* Given a list (FUNCTION ARGS...), apply FUNCTION to the ARGS. */
2737 read_process_output_call (fun_and_args
)
2738 Lisp_Object fun_and_args
;
2740 return apply1 (XCONS (fun_and_args
)->car
, XCONS (fun_and_args
)->cdr
);
2744 read_process_output_error_handler (error
)
2747 cmd_error_internal (error
, "error in process filter: ");
2749 update_echo_area ();
2750 Fsleep_for (make_number (2), Qnil
);
2753 /* Read pending output from the process channel,
2754 starting with our buffered-ahead character if we have one.
2755 Yield number of decoded characters read.
2757 This function reads at most 1024 characters.
2758 If you want to read all available subprocess output,
2759 you must call it repeatedly until it returns zero.
2761 The characters read are decoded according to PROC's coding-system
2765 read_process_output (proc
, channel
)
2767 register int channel
;
2769 register int nchars
, nbytes
;
2772 int chars_allocated
= 0; /* If 1, `chars' should be freed later. */
2776 register Lisp_Object outstream
;
2777 register struct buffer
*old
= current_buffer
;
2778 register struct Lisp_Process
*p
= XPROCESS (proc
);
2779 register int opoint
;
2780 struct coding_system
*coding
= proc_decode_coding_system
[channel
];
2781 int chars_in_decoding_buf
= 0; /* If 1, `chars' points
2782 XSTRING (p->decoding_buf)->data. */
2783 int carryover
= XINT (p
->decoding_carryover
);
2786 VMS_PROC_STUFF
*vs
, *get_vms_process_pointer();
2788 vs
= get_vms_process_pointer (p
->pid
);
2792 return(0); /* Really weird if it does this */
2793 if (!(vs
->iosb
[0] & 1))
2794 return -1; /* I/O error */
2797 error ("Could not get VMS process pointer");
2798 chars
= vs
->inputBuffer
;
2799 nbytes
= clean_vms_buffer (chars
, vs
->iosb
[1]);
2802 start_vms_process_read (vs
); /* Crank up the next read on the process */
2803 return 1; /* Nothing worth printing, say we got 1 */
2807 /* The data carried over in the previous decoding (which are at
2808 the tail of decoding buffer) should be prepended to the new
2809 data read to decode all together. */
2810 char *buf
= (char *) xmalloc (nbytes
+ carryover
);
2812 bcopy (XSTRING (p
->decoding_buf
)->data
2813 + STRING_BYTES (XSTRING (p
->decoding_buf
)) - carryover
,
2815 bcopy (chars
, buf
+ carryover
, nbytes
);
2817 chars_allocated
= 1;
2822 /* See the comment above. */
2823 bcopy (XSTRING (p
->decoding_buf
)->data
2824 + STRING_BYTES (XSTRING (p
->decoding_buf
)) - carryover
,
2827 if (proc_buffered_char
[channel
] < 0)
2828 nbytes
= read (channel
, buf
+ carryover
, (sizeof buf
) - carryover
);
2831 buf
[carryover
] = proc_buffered_char
[channel
];
2832 proc_buffered_char
[channel
] = -1;
2833 nbytes
= read (channel
, buf
+ carryover
+ 1,
2834 (sizeof buf
) - carryover
- 1);
2838 nbytes
= nbytes
+ 1;
2841 #endif /* not VMS */
2843 XSETINT (p
->decoding_carryover
, 0);
2845 /* At this point, NBYTES holds number of characters just received
2846 (including the one in proc_buffered_char[channel]). */
2849 if (nbytes
< 0 || coding
->mode
& CODING_MODE_LAST_BLOCK
)
2851 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
2854 /* Now set NBYTES how many bytes we must decode. */
2855 nbytes
+= carryover
;
2858 if (CODING_MAY_REQUIRE_DECODING (coding
))
2860 int require
= decoding_buffer_size (coding
, nbytes
);
2863 if (STRING_BYTES (XSTRING (p
->decoding_buf
)) < require
)
2864 p
->decoding_buf
= make_uninit_string (require
);
2865 result
= decode_coding (coding
, chars
, XSTRING (p
->decoding_buf
)->data
,
2866 nbytes
, STRING_BYTES (XSTRING (p
->decoding_buf
)));
2867 carryover
= nbytes
- coding
->consumed
;
2870 /* Copy the carryover bytes to the end of p->decoding_buf, to
2871 be processed on the next read. Since decoding_buffer_size
2872 asks for an extra amount of space beyond the maximum
2873 expected for the output, there should always be sufficient
2874 space for the carryover (which is by definition a sequence
2875 of bytes that was not long enough to be decoded, and thus
2876 has a bounded length). */
2877 if (STRING_BYTES (XSTRING (p
->decoding_buf
))
2878 < coding
->produced
+ carryover
)
2880 bcopy (chars
+ coding
->consumed
,
2881 XSTRING (p
->decoding_buf
)->data
2882 + STRING_BYTES (XSTRING (p
->decoding_buf
)) - carryover
,
2884 XSETINT (p
->decoding_carryover
, carryover
);
2887 /* A new coding system might be found by `decode_coding'. */
2888 if (!EQ (p
->decode_coding_system
, coding
->symbol
))
2890 p
->decode_coding_system
= coding
->symbol
;
2892 /* Don't call setup_coding_system for
2893 proc_decode_coding_system[channel] here. It is done in
2894 detect_coding called via decode_coding above. */
2896 /* If a coding system for encoding is not yet decided, we set
2897 it as the same as coding-system for decoding.
2899 But, before doing that we must check if
2900 proc_encode_coding_system[p->outfd] surely points to a
2901 valid memory because p->outfd will be changed once EOF is
2902 sent to the process. */
2903 if (NILP (p
->encode_coding_system
)
2904 && proc_encode_coding_system
[XINT (p
->outfd
)])
2906 p
->encode_coding_system
= coding
->symbol
;
2907 setup_coding_system (coding
->symbol
,
2908 proc_encode_coding_system
[XINT (p
->outfd
)]);
2913 /* Now we don't need the contents of `chars'. */
2914 if (chars_allocated
)
2917 if (coding
->produced
== 0)
2919 chars
= (char *) XSTRING (p
->decoding_buf
)->data
;
2920 nbytes
= coding
->produced
;
2921 nchars
= (coding
->fake_multibyte
2922 ? multibyte_chars_in_text (chars
, nbytes
)
2923 : coding
->produced_char
);
2924 chars_in_decoding_buf
= 1;
2929 if (chars_allocated
)
2931 /* Although we don't have to decode the received data, we
2932 must move it to an area which we don't have to free. */
2933 if (! STRINGP (p
->decoding_buf
)
2934 || STRING_BYTES (XSTRING (p
->decoding_buf
)) < nbytes
)
2935 p
->decoding_buf
= make_uninit_string (nbytes
);
2936 bcopy (chars
, XSTRING (p
->decoding_buf
)->data
, nbytes
);
2938 chars
= XSTRING (p
->decoding_buf
)->data
;
2939 chars_in_decoding_buf
= 1;
2942 nchars
= multibyte_chars_in_text (chars
, nbytes
);
2945 Vlast_coding_system_used
= coding
->symbol
;
2947 /* If the caller required, let the process associated buffer
2948 inherit the coding-system used to decode the process output. */
2949 if (! NILP (p
->inherit_coding_system_flag
)
2950 && !NILP (p
->buffer
) && !NILP (XBUFFER (p
->buffer
)->name
))
2952 struct buffer
*prev_buf
= current_buffer
;
2954 Fset_buffer (p
->buffer
);
2955 call1 (intern ("after-insert-file-set-buffer-file-coding-system"),
2956 make_number (nbytes
));
2957 set_buffer_internal (prev_buf
);
2960 /* Read and dispose of the process output. */
2961 outstream
= p
->filter
;
2962 if (!NILP (outstream
))
2964 /* We inhibit quit here instead of just catching it so that
2965 hitting ^G when a filter happens to be running won't screw
2967 int count
= specpdl_ptr
- specpdl
;
2968 Lisp_Object odeactivate
;
2969 Lisp_Object obuffer
, okeymap
;
2971 int outer_running_asynch_code
= running_asynch_code
;
2972 int waiting
= waiting_for_user_input_p
;
2974 /* No need to gcpro these, because all we do with them later
2975 is test them for EQness, and none of them should be a string. */
2976 odeactivate
= Vdeactivate_mark
;
2977 XSETBUFFER (obuffer
, current_buffer
);
2978 okeymap
= current_buffer
->keymap
;
2980 specbind (Qinhibit_quit
, Qt
);
2981 specbind (Qlast_nonmenu_event
, Qt
);
2983 /* In case we get recursively called,
2984 and we already saved the match data nonrecursively,
2985 save the same match data in safely recursive fashion. */
2986 if (outer_running_asynch_code
)
2989 /* Don't clobber the CURRENT match data, either! */
2990 tem
= Fmatch_data (Qnil
, Qnil
);
2991 restore_match_data ();
2992 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
2993 Fset_match_data (tem
);
2996 /* For speed, if a search happens within this code,
2997 save the match data in a special nonrecursive fashion. */
2998 running_asynch_code
= 1;
3000 /* The multibyteness of a string given to the filter is decided
3001 by which coding system we used for decoding. */
3002 if (coding
->type
== coding_type_no_conversion
3003 || coding
->type
== coding_type_raw_text
)
3004 text
= make_unibyte_string (chars
, nbytes
);
3006 text
= make_multibyte_string (chars
, nchars
, nbytes
);
3008 internal_condition_case_1 (read_process_output_call
,
3010 Fcons (proc
, Fcons (text
, Qnil
))),
3011 !NILP (Vdebug_on_error
) ? Qnil
: Qerror
,
3012 read_process_output_error_handler
);
3014 /* If we saved the match data nonrecursively, restore it now. */
3015 restore_match_data ();
3016 running_asynch_code
= outer_running_asynch_code
;
3018 /* Handling the process output should not deactivate the mark. */
3019 Vdeactivate_mark
= odeactivate
;
3021 /* Restore waiting_for_user_input_p as it was
3022 when we were called, in case the filter clobbered it. */
3023 waiting_for_user_input_p
= waiting
;
3025 #if 0 /* Call record_asynch_buffer_change unconditionally,
3026 because we might have changed minor modes or other things
3027 that affect key bindings. */
3028 if (! EQ (Fcurrent_buffer (), obuffer
)
3029 || ! EQ (current_buffer
->keymap
, okeymap
))
3031 /* But do it only if the caller is actually going to read events.
3032 Otherwise there's no need to make him wake up, and it could
3033 cause trouble (for example it would make Fsit_for return). */
3034 if (waiting_for_user_input_p
== -1)
3035 record_asynch_buffer_change ();
3038 start_vms_process_read (vs
);
3040 unbind_to (count
, Qnil
);
3044 /* If no filter, write into buffer if it isn't dead. */
3045 if (!NILP (p
->buffer
) && !NILP (XBUFFER (p
->buffer
)->name
))
3047 Lisp_Object old_read_only
;
3048 int old_begv
, old_zv
;
3049 int old_begv_byte
, old_zv_byte
;
3050 Lisp_Object odeactivate
;
3051 int before
, before_byte
;
3054 odeactivate
= Vdeactivate_mark
;
3056 Fset_buffer (p
->buffer
);
3058 opoint_byte
= PT_BYTE
;
3059 old_read_only
= current_buffer
->read_only
;
3062 old_begv_byte
= BEGV_BYTE
;
3063 old_zv_byte
= ZV_BYTE
;
3065 current_buffer
->read_only
= Qnil
;
3067 /* Insert new output into buffer
3068 at the current end-of-output marker,
3069 thus preserving logical ordering of input and output. */
3070 if (XMARKER (p
->mark
)->buffer
)
3071 SET_PT_BOTH (clip_to_bounds (BEGV
, marker_position (p
->mark
), ZV
),
3072 clip_to_bounds (BEGV_BYTE
, marker_byte_position (p
->mark
),
3075 SET_PT_BOTH (ZV
, ZV_BYTE
);
3077 before_byte
= PT_BYTE
;
3079 /* If the output marker is outside of the visible region, save
3080 the restriction and widen. */
3081 if (! (BEGV
<= PT
&& PT
<= ZV
))
3084 if (NILP (current_buffer
->enable_multibyte_characters
))
3087 /* Insert before markers in case we are inserting where
3088 the buffer's mark is, and the user's next command is Meta-y. */
3089 if (chars_in_decoding_buf
)
3091 /* Since multibyteness of p->docoding_buf is corrupted, we
3092 can't use insert_from_string_before_markers. */
3095 temp_buf
= (char *) alloca (nbytes
);
3096 bcopy (XSTRING (p
->decoding_buf
)->data
, temp_buf
, nbytes
);
3097 insert_before_markers (temp_buf
, nbytes
);
3101 insert_1_both (chars
, nchars
, nbytes
, 0, 1, 1);
3102 signal_after_change (opoint
, 0, PT
- opoint
);
3104 set_marker_both (p
->mark
, p
->buffer
, PT
, PT_BYTE
);
3106 update_mode_lines
++;
3108 /* Make sure opoint and the old restrictions
3109 float ahead of any new text just as point would. */
3110 if (opoint
>= before
)
3112 opoint
+= PT
- before
;
3113 opoint_byte
+= PT_BYTE
- before_byte
;
3115 if (old_begv
> before
)
3117 old_begv
+= PT
- before
;
3118 old_begv_byte
+= PT_BYTE
- before_byte
;
3120 if (old_zv
>= before
)
3122 old_zv
+= PT
- before
;
3123 old_zv_byte
+= PT_BYTE
- before_byte
;
3126 /* If the restriction isn't what it should be, set it. */
3127 if (old_begv
!= BEGV
|| old_zv
!= ZV
)
3128 Fnarrow_to_region (make_number (old_begv
), make_number (old_zv
));
3130 /* Handling the process output should not deactivate the mark. */
3131 Vdeactivate_mark
= odeactivate
;
3133 current_buffer
->read_only
= old_read_only
;
3134 SET_PT_BOTH (opoint
, opoint_byte
);
3135 set_buffer_internal (old
);
3138 start_vms_process_read (vs
);
3143 DEFUN ("waiting-for-user-input-p", Fwaiting_for_user_input_p
, Swaiting_for_user_input_p
,
3145 "Returns non-nil if emacs is waiting for input from the user.\n\
3146 This is intended for use by asynchronous process output filters and sentinels.")
3149 return (waiting_for_user_input_p
? Qt
: Qnil
);
3152 /* Sending data to subprocess */
3154 jmp_buf send_process_frame
;
3157 send_process_trap ()
3163 longjmp (send_process_frame
, 1);
3166 /* Send some data to process PROC.
3167 BUF is the beginning of the data; LEN is the number of characters.
3168 OBJECT is the Lisp object that the data comes from.
3170 The data is encoded by PROC's coding-system for encoding before it
3171 is sent. But if the data ends at the middle of multi-byte
3172 representation, that incomplete sequence of bytes are sent without
3173 being encoded. Should we store them in a buffer to prepend them to
3174 the data send later? */
3177 send_process (proc
, buf
, len
, object
)
3178 volatile Lisp_Object proc
;
3183 /* Use volatile to protect variables from being clobbered by longjmp. */
3185 volatile unsigned char *procname
= XSTRING (XPROCESS (proc
)->name
)->data
;
3186 struct coding_system
*coding
;
3187 struct gcpro gcpro1
;
3188 int carryover
= XINT (XPROCESS (proc
)->encoding_carryover
);
3193 struct Lisp_Process
*p
= XPROCESS (proc
);
3194 VMS_PROC_STUFF
*vs
, *get_vms_process_pointer();
3197 if (! NILP (XPROCESS (proc
)->raw_status_low
))
3198 update_status (XPROCESS (proc
));
3199 if (! EQ (XPROCESS (proc
)->status
, Qrun
))
3200 error ("Process %s not running", procname
);
3201 if (XINT (XPROCESS (proc
)->outfd
) < 0)
3202 error ("Output file descriptor of %s is closed", procname
);
3204 coding
= proc_encode_coding_system
[XINT (XPROCESS (proc
)->outfd
)];
3205 Vlast_coding_system_used
= coding
->symbol
;
3207 if (CODING_REQUIRE_ENCODING (coding
))
3209 int require
= encoding_buffer_size (coding
, len
);
3211 unsigned char *temp_buf
= NULL
;
3213 /* Remember the offset of data because a string or a buffer may
3214 be relocated. Setting OFFSET to -1 means we don't have to
3216 offset
= (BUFFERP (object
)
3217 ? BUF_PTR_BYTE_POS (XBUFFER (object
), buf
)
3219 ? offset
= buf
- XSTRING (object
)->data
3224 temp_buf
= (unsigned char *) xmalloc (len
+ carryover
);
3228 if (BUFFERP (object
))
3229 buf
= BUF_BYTE_ADDRESS (XBUFFER (object
), offset
);
3230 else if (STRINGP (object
))
3231 buf
= offset
+ XSTRING (object
)->data
;
3232 /* Now we don't have to care relocation. */
3235 bcopy ((XSTRING (XPROCESS (proc
)->encoding_buf
)->data
3236 + STRING_BYTES (XSTRING (XPROCESS (proc
)->encoding_buf
))
3240 bcopy (buf
, temp_buf
+ carryover
, len
);
3244 if (STRING_BYTES (XSTRING (XPROCESS (proc
)->encoding_buf
)) < require
)
3246 XPROCESS (proc
)->encoding_buf
= make_uninit_string (require
);
3250 if (BUFFERP (object
))
3251 buf
= BUF_BYTE_ADDRESS (XBUFFER (object
), offset
);
3252 else if (STRINGP (object
))
3253 buf
= offset
+ XSTRING (object
)->data
;
3256 object
= XPROCESS (proc
)->encoding_buf
;
3257 encode_coding (coding
, buf
, XSTRING (object
)->data
,
3258 len
, STRING_BYTES (XSTRING (object
)));
3259 len
= coding
->produced
;
3260 buf
= XSTRING (object
)->data
;
3266 vs
= get_vms_process_pointer (p
->pid
);
3268 error ("Could not find this process: %x", p
->pid
);
3269 else if (write_to_vms_process (vs
, buf
, len
))
3273 if (pty_max_bytes
== 0)
3275 #if defined (HAVE_FPATHCONF) && defined (_PC_MAX_CANON)
3276 pty_max_bytes
= fpathconf (XFASTINT (XPROCESS (proc
)->outfd
),
3278 if (pty_max_bytes
< 0)
3279 pty_max_bytes
= 250;
3281 pty_max_bytes
= 250;
3283 /* Deduct one, to leave space for the eof. */
3287 if (!setjmp (send_process_frame
))
3291 SIGTYPE (*old_sigpipe
)();
3294 /* Decide how much data we can send in one batch.
3295 Long lines need to be split into multiple batches. */
3296 if (!NILP (XPROCESS (proc
)->pty_flag
))
3298 /* Starting this at zero is always correct when not the first iteration
3299 because the previous iteration ended by sending C-d.
3300 It may not be correct for the first iteration
3301 if a partial line was sent in a separate send_process call.
3302 If that proves worth handling, we need to save linepos
3303 in the process object. */
3305 unsigned char *ptr
= buf
;
3306 unsigned char *end
= buf
+ len
;
3308 /* Scan through this text for a line that is too long. */
3309 while (ptr
!= end
&& linepos
< pty_max_bytes
)
3317 /* If we found one, break the line there
3318 and put in a C-d to force the buffer through. */
3322 /* Send this batch, using one or more write calls. */
3325 old_sigpipe
= (SIGTYPE (*) ()) signal (SIGPIPE
, send_process_trap
);
3326 rv
= write (XINT (XPROCESS (proc
)->outfd
), buf
, this);
3327 signal (SIGPIPE
, old_sigpipe
);
3333 || errno
== EWOULDBLOCK
3339 /* Buffer is full. Wait, accepting input;
3340 that may allow the program
3341 to finish doing output and read more. */
3346 /* Running filters might relocate buffers or strings.
3347 Arrange to relocate BUF. */
3348 if (BUFFERP (object
))
3349 offset
= BUF_PTR_BYTE_POS (XBUFFER (object
), buf
);
3350 else if (STRINGP (object
))
3351 offset
= buf
- XSTRING (object
)->data
;
3353 XSETFASTINT (zero
, 0);
3354 #ifdef EMACS_HAS_USECS
3355 wait_reading_process_input (0, 20000, zero
, 0);
3357 wait_reading_process_input (1, 0, zero
, 0);
3360 if (BUFFERP (object
))
3361 buf
= BUF_BYTE_ADDRESS (XBUFFER (object
), offset
);
3362 else if (STRINGP (object
))
3363 buf
= offset
+ XSTRING (object
)->data
;
3368 /* This is a real error. */
3369 report_file_error ("writing to process", Fcons (proc
, Qnil
));
3376 /* If we sent just part of the string, put in an EOF
3377 to force it through, before we send the rest. */
3379 Fprocess_send_eof (proc
);
3384 XPROCESS (proc
)->raw_status_low
= Qnil
;
3385 XPROCESS (proc
)->raw_status_high
= Qnil
;
3386 XPROCESS (proc
)->status
= Fcons (Qexit
, Fcons (make_number (256), Qnil
));
3387 XSETINT (XPROCESS (proc
)->tick
, ++process_tick
);
3388 deactivate_process (proc
);
3390 error ("Error writing to process %s; closed it", procname
);
3392 error ("SIGPIPE raised on process %s; closed it", procname
);
3399 DEFUN ("process-send-region", Fprocess_send_region
, Sprocess_send_region
,
3401 "Send current contents of region as input to PROCESS.\n\
3402 PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
3403 nil, indicating the current buffer's process.\n\
3404 Called from program, takes three arguments, PROCESS, START and END.\n\
3405 If the region is more than 500 characters long,\n\
3406 it is sent in several bunches. This may happen even for shorter regions.\n\
3407 Output from processes can arrive in between bunches.")
3408 (process
, start
, end
)
3409 Lisp_Object process
, start
, end
;
3414 proc
= get_process (process
);
3415 validate_region (&start
, &end
);
3417 if (XINT (start
) < GPT
&& XINT (end
) > GPT
)
3418 move_gap (XINT (start
));
3420 start1
= CHAR_TO_BYTE (XINT (start
));
3421 end1
= CHAR_TO_BYTE (XINT (end
));
3422 send_process (proc
, BYTE_POS_ADDR (start1
), end1
- start1
,
3423 Fcurrent_buffer ());
3428 DEFUN ("process-send-string", Fprocess_send_string
, Sprocess_send_string
,
3430 "Send PROCESS the contents of STRING as input.\n\
3431 PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
3432 nil, indicating the current buffer's process.\n\
3433 If STRING is more than 500 characters long,\n\
3434 it is sent in several bunches. This may happen even for shorter strings.\n\
3435 Output from processes can arrive in between bunches.")
3437 Lisp_Object process
, string
;
3440 CHECK_STRING (string
, 1);
3441 proc
= get_process (process
);
3442 send_process (proc
, XSTRING (string
)->data
,
3443 STRING_BYTES (XSTRING (string
)), string
);
3447 DEFUN ("process-running-child-p", Fprocess_running_child_p
,
3448 Sprocess_running_child_p
, 0, 1, 0,
3449 "Return t if PROCESS has given the terminal to a child.\n\
3450 If the operating system does not make it possible to find out,\n\
3451 return t unconditionally.")
3453 Lisp_Object process
;
3455 /* Initialize in case ioctl doesn't exist or gives an error,
3456 in a way that will cause returning t. */
3459 struct Lisp_Process
*p
;
3461 proc
= get_process (process
);
3462 p
= XPROCESS (proc
);
3464 if (!EQ (p
->childp
, Qt
))
3465 error ("Process %s is not a subprocess",
3466 XSTRING (p
->name
)->data
);
3467 if (XINT (p
->infd
) < 0)
3468 error ("Process %s is not active",
3469 XSTRING (p
->name
)->data
);
3472 if (!NILP (p
->subtty
))
3473 ioctl (XFASTINT (p
->subtty
), TIOCGPGRP
, &gid
);
3475 ioctl (XINT (p
->infd
), TIOCGPGRP
, &gid
);
3476 #endif /* defined (TIOCGPGRP ) */
3478 if (gid
== XFASTINT (p
->pid
))
3483 /* send a signal number SIGNO to PROCESS.
3484 If CURRENT_GROUP is t, that means send to the process group
3485 that currently owns the terminal being used to communicate with PROCESS.
3486 This is used for various commands in shell mode.
3487 If CURRENT_GROUP is lambda, that means send to the process group
3488 that currently owns the terminal, but only if it is NOT the shell itself.
3490 If NOMSG is zero, insert signal-announcements into process's buffers
3493 If we can, we try to signal PROCESS by sending control characters
3494 down the pty. This allows us to signal inferiors who have changed
3495 their uid, for which killpg would return an EPERM error. */
3498 process_send_signal (process
, signo
, current_group
, nomsg
)
3499 Lisp_Object process
;
3501 Lisp_Object current_group
;
3505 register struct Lisp_Process
*p
;
3509 proc
= get_process (process
);
3510 p
= XPROCESS (proc
);
3512 if (!EQ (p
->childp
, Qt
))
3513 error ("Process %s is not a subprocess",
3514 XSTRING (p
->name
)->data
);
3515 if (XINT (p
->infd
) < 0)
3516 error ("Process %s is not active",
3517 XSTRING (p
->name
)->data
);
3519 if (NILP (p
->pty_flag
))
3520 current_group
= Qnil
;
3522 /* If we are using pgrps, get a pgrp number and make it negative. */
3523 if (!NILP (current_group
))
3525 #ifdef SIGNALS_VIA_CHARACTERS
3526 /* If possible, send signals to the entire pgrp
3527 by sending an input character to it. */
3529 /* TERMIOS is the latest and bestest, and seems most likely to
3530 work. If the system has it, use it. */
3537 tcgetattr (XINT (p
->infd
), &t
);
3538 send_process (proc
, &t
.c_cc
[VINTR
], 1, Qnil
);
3542 tcgetattr (XINT (p
->infd
), &t
);
3543 send_process (proc
, &t
.c_cc
[VQUIT
], 1, Qnil
);
3547 tcgetattr (XINT (p
->infd
), &t
);
3548 #if defined (VSWTCH) && !defined (PREFER_VSUSP)
3549 send_process (proc
, &t
.c_cc
[VSWTCH
], 1, Qnil
);
3551 send_process (proc
, &t
.c_cc
[VSUSP
], 1, Qnil
);
3556 #else /* ! HAVE_TERMIOS */
3558 /* On Berkeley descendants, the following IOCTL's retrieve the
3559 current control characters. */
3560 #if defined (TIOCGLTC) && defined (TIOCGETC)
3568 ioctl (XINT (p
->infd
), TIOCGETC
, &c
);
3569 send_process (proc
, &c
.t_intrc
, 1, Qnil
);
3572 ioctl (XINT (p
->infd
), TIOCGETC
, &c
);
3573 send_process (proc
, &c
.t_quitc
, 1, Qnil
);
3577 ioctl (XINT (p
->infd
), TIOCGLTC
, &lc
);
3578 send_process (proc
, &lc
.t_suspc
, 1, Qnil
);
3580 #endif /* ! defined (SIGTSTP) */
3583 #else /* ! defined (TIOCGLTC) && defined (TIOCGETC) */
3585 /* On SYSV descendants, the TCGETA ioctl retrieves the current control
3592 ioctl (XINT (p
->infd
), TCGETA
, &t
);
3593 send_process (proc
, &t
.c_cc
[VINTR
], 1, Qnil
);
3596 ioctl (XINT (p
->infd
), TCGETA
, &t
);
3597 send_process (proc
, &t
.c_cc
[VQUIT
], 1, Qnil
);
3601 ioctl (XINT (p
->infd
), TCGETA
, &t
);
3602 send_process (proc
, &t
.c_cc
[VSWTCH
], 1, Qnil
);
3604 #endif /* ! defined (SIGTSTP) */
3606 #else /* ! defined (TCGETA) */
3607 Your configuration files are messed up
.
3608 /* If your system configuration files define SIGNALS_VIA_CHARACTERS,
3609 you'd better be using one of the alternatives above! */
3610 #endif /* ! defined (TCGETA) */
3611 #endif /* ! defined (TIOCGLTC) && defined (TIOCGETC) */
3612 #endif /* ! defined HAVE_TERMIOS */
3613 #endif /* ! defined (SIGNALS_VIA_CHARACTERS) */
3616 /* Get the pgrp using the tty itself, if we have that.
3617 Otherwise, use the pty to get the pgrp.
3618 On pfa systems, saka@pfu.fujitsu.co.JP writes:
3619 "TIOCGPGRP symbol defined in sys/ioctl.h at E50.
3620 But, TIOCGPGRP does not work on E50 ;-P works fine on E60"
3621 His patch indicates that if TIOCGPGRP returns an error, then
3622 we should just assume that p->pid is also the process group id. */
3626 if (!NILP (p
->subtty
))
3627 err
= ioctl (XFASTINT (p
->subtty
), TIOCGPGRP
, &gid
);
3629 err
= ioctl (XINT (p
->infd
), TIOCGPGRP
, &gid
);
3633 gid
= - XFASTINT (p
->pid
);
3634 #endif /* ! defined (pfa) */
3640 #else /* ! defined (TIOCGPGRP ) */
3641 /* Can't select pgrps on this system, so we know that
3642 the child itself heads the pgrp. */
3643 gid
= - XFASTINT (p
->pid
);
3644 #endif /* ! defined (TIOCGPGRP ) */
3646 /* If current_group is lambda, and the shell owns the terminal,
3647 don't send any signal. */
3648 if (EQ (current_group
, Qlambda
) && gid
== - XFASTINT (p
->pid
))
3652 gid
= - XFASTINT (p
->pid
);
3658 p
->raw_status_low
= Qnil
;
3659 p
->raw_status_high
= Qnil
;
3661 XSETINT (p
->tick
, ++process_tick
);
3665 #endif /* ! defined (SIGCONT) */
3668 send_process (proc
, "\003", 1, Qnil
); /* ^C */
3673 send_process (proc
, "\031", 1, Qnil
); /* ^Y */
3678 sys$
forcex (&(XFASTINT (p
->pid
)), 0, 1);
3681 flush_pending_output (XINT (p
->infd
));
3685 /* If we don't have process groups, send the signal to the immediate
3686 subprocess. That isn't really right, but it's better than any
3687 obvious alternative. */
3690 kill (XFASTINT (p
->pid
), signo
);
3694 /* gid may be a pid, or minus a pgrp's number */
3696 if (!NILP (current_group
))
3697 ioctl (XINT (p
->infd
), TIOCSIGSEND
, signo
);
3700 gid
= - XFASTINT (p
->pid
);
3703 #else /* ! defined (TIOCSIGSEND) */
3704 EMACS_KILLPG (-gid
, signo
);
3705 #endif /* ! defined (TIOCSIGSEND) */
3708 DEFUN ("interrupt-process", Finterrupt_process
, Sinterrupt_process
, 0, 2, 0,
3709 "Interrupt process PROCESS.\n\
3710 PROCESS may be a process, a buffer, or the name of a process or buffer.\n\
3711 nil or no arg means current buffer's process.\n\
3712 Second arg CURRENT-GROUP non-nil means send signal to\n\
3713 the current process-group of the process's controlling terminal\n\
3714 rather than to the process's own process group.\n\
3715 If the process is a shell, this means interrupt current subjob\n\
3716 rather than the shell.\n\
3718 If CURRENT-GROUP is `lambda', and if the shell owns the terminal,\n\
3719 don't send the signal.")
3720 (process
, current_group
)
3721 Lisp_Object process
, current_group
;
3723 process_send_signal (process
, SIGINT
, current_group
, 0);
3727 DEFUN ("kill-process", Fkill_process
, Skill_process
, 0, 2, 0,
3728 "Kill process PROCESS. May be process or name of one.\n\
3729 See function `interrupt-process' for more details on usage.")
3730 (process
, current_group
)
3731 Lisp_Object process
, current_group
;
3733 process_send_signal (process
, SIGKILL
, current_group
, 0);
3737 DEFUN ("quit-process", Fquit_process
, Squit_process
, 0, 2, 0,
3738 "Send QUIT signal to process PROCESS. May be process or name of one.\n\
3739 See function `interrupt-process' for more details on usage.")
3740 (process
, current_group
)
3741 Lisp_Object process
, current_group
;
3743 process_send_signal (process
, SIGQUIT
, current_group
, 0);
3747 DEFUN ("stop-process", Fstop_process
, Sstop_process
, 0, 2, 0,
3748 "Stop process PROCESS. May be process or name of one.\n\
3749 See function `interrupt-process' for more details on usage.")
3750 (process
, current_group
)
3751 Lisp_Object process
, current_group
;
3754 error ("no SIGTSTP support");
3756 process_send_signal (process
, SIGTSTP
, current_group
, 0);
3761 DEFUN ("continue-process", Fcontinue_process
, Scontinue_process
, 0, 2, 0,
3762 "Continue process PROCESS. May be process or name of one.\n\
3763 See function `interrupt-process' for more details on usage.")
3764 (process
, current_group
)
3765 Lisp_Object process
, current_group
;
3768 process_send_signal (process
, SIGCONT
, current_group
, 0);
3770 error ("no SIGCONT support");
3775 DEFUN ("signal-process", Fsignal_process
, Ssignal_process
,
3776 2, 2, "nProcess number: \nnSignal code: ",
3777 "Send the process with process id PID the signal with code SIGCODE.\n\
3778 PID must be an integer. The process need not be a child of this Emacs.\n\
3779 SIGCODE may be an integer, or a symbol whose name is a signal name.")
3781 Lisp_Object pid
, sigcode
;
3783 CHECK_NUMBER (pid
, 0);
3785 #define handle_signal(NAME, VALUE) \
3786 else if (!strcmp (name, NAME)) \
3787 XSETINT (sigcode, VALUE)
3789 if (INTEGERP (sigcode
))
3793 unsigned char *name
;
3795 CHECK_SYMBOL (sigcode
, 1);
3796 name
= XSYMBOL (sigcode
)->name
->data
;
3801 handle_signal ("SIGHUP", SIGHUP
);
3804 handle_signal ("SIGINT", SIGINT
);
3807 handle_signal ("SIGQUIT", SIGQUIT
);
3810 handle_signal ("SIGILL", SIGILL
);
3813 handle_signal ("SIGABRT", SIGABRT
);
3816 handle_signal ("SIGEMT", SIGEMT
);
3819 handle_signal ("SIGKILL", SIGKILL
);
3822 handle_signal ("SIGFPE", SIGFPE
);
3825 handle_signal ("SIGBUS", SIGBUS
);
3828 handle_signal ("SIGSEGV", SIGSEGV
);
3831 handle_signal ("SIGSYS", SIGSYS
);
3834 handle_signal ("SIGPIPE", SIGPIPE
);
3837 handle_signal ("SIGALRM", SIGALRM
);
3840 handle_signal ("SIGTERM", SIGTERM
);
3843 handle_signal ("SIGURG", SIGURG
);
3846 handle_signal ("SIGSTOP", SIGSTOP
);
3849 handle_signal ("SIGTSTP", SIGTSTP
);
3852 handle_signal ("SIGCONT", SIGCONT
);
3855 handle_signal ("SIGCHLD", SIGCHLD
);
3858 handle_signal ("SIGTTIN", SIGTTIN
);
3861 handle_signal ("SIGTTOU", SIGTTOU
);
3864 handle_signal ("SIGIO", SIGIO
);
3867 handle_signal ("SIGXCPU", SIGXCPU
);
3870 handle_signal ("SIGXFSZ", SIGXFSZ
);
3873 handle_signal ("SIGVTALRM", SIGVTALRM
);
3876 handle_signal ("SIGPROF", SIGPROF
);
3879 handle_signal ("SIGWINCH", SIGWINCH
);
3882 handle_signal ("SIGINFO", SIGINFO
);
3885 handle_signal ("SIGUSR1", SIGUSR1
);
3888 handle_signal ("SIGUSR2", SIGUSR2
);
3891 error ("Undefined signal name %s", name
);
3894 #undef handle_signal
3896 return make_number (kill (XINT (pid
), XINT (sigcode
)));
3899 DEFUN ("process-send-eof", Fprocess_send_eof
, Sprocess_send_eof
, 0, 1, 0,
3900 "Make PROCESS see end-of-file in its input.\n\
3901 EOF comes after any text already sent to it.\n\
3902 PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
3903 nil, indicating the current buffer's process.\n\
3904 If PROCESS is a network connection, or is a process communicating\n\
3905 through a pipe (as opposed to a pty), then you cannot send any more\n\
3906 text to PROCESS after you call this function.")
3908 Lisp_Object process
;
3911 struct coding_system
*coding
;
3913 proc
= get_process (process
);
3914 coding
= proc_encode_coding_system
[XINT (XPROCESS (proc
)->outfd
)];
3916 /* Make sure the process is really alive. */
3917 if (! NILP (XPROCESS (proc
)->raw_status_low
))
3918 update_status (XPROCESS (proc
));
3919 if (! EQ (XPROCESS (proc
)->status
, Qrun
))
3920 error ("Process %s not running", XSTRING (XPROCESS (proc
)->name
)->data
);
3922 if (CODING_REQUIRE_FLUSHING (coding
))
3924 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
3925 send_process (proc
, "", 0, Qnil
);
3929 send_process (proc
, "\032", 1, Qnil
); /* ^z */
3931 if (!NILP (XPROCESS (proc
)->pty_flag
))
3932 send_process (proc
, "\004", 1, Qnil
);
3935 int old_outfd
, new_outfd
;
3937 #ifdef HAVE_SHUTDOWN
3938 /* If this is a network connection, or socketpair is used
3939 for communication with the subprocess, call shutdown to cause EOF.
3940 (In some old system, shutdown to socketpair doesn't work.
3941 Then we just can't win.) */
3942 if (NILP (XPROCESS (proc
)->pid
)
3943 || XINT (XPROCESS (proc
)->outfd
) == XINT (XPROCESS (proc
)->infd
))
3944 shutdown (XINT (XPROCESS (proc
)->outfd
), 1);
3945 /* In case of socketpair, outfd == infd, so don't close it. */
3946 if (XINT (XPROCESS (proc
)->outfd
) != XINT (XPROCESS (proc
)->infd
))
3947 close (XINT (XPROCESS (proc
)->outfd
));
3948 #else /* not HAVE_SHUTDOWN */
3949 close (XINT (XPROCESS (proc
)->outfd
));
3950 #endif /* not HAVE_SHUTDOWN */
3951 new_outfd
= open (NULL_DEVICE
, O_WRONLY
);
3952 old_outfd
= XINT (XPROCESS (proc
)->outfd
);
3954 if (!proc_encode_coding_system
[new_outfd
])
3955 proc_encode_coding_system
[new_outfd
]
3956 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
3957 bcopy (proc_encode_coding_system
[old_outfd
],
3958 proc_encode_coding_system
[new_outfd
],
3959 sizeof (struct coding_system
));
3960 bzero (proc_encode_coding_system
[old_outfd
],
3961 sizeof (struct coding_system
));
3963 XSETINT (XPROCESS (proc
)->outfd
, new_outfd
);
3969 /* Kill all processes associated with `buffer'.
3970 If `buffer' is nil, kill all processes */
3973 kill_buffer_processes (buffer
)
3976 Lisp_Object tail
, proc
;
3978 for (tail
= Vprocess_alist
; GC_CONSP (tail
); tail
= XCONS (tail
)->cdr
)
3980 proc
= XCONS (XCONS (tail
)->car
)->cdr
;
3981 if (GC_PROCESSP (proc
)
3982 && (NILP (buffer
) || EQ (XPROCESS (proc
)->buffer
, buffer
)))
3984 if (NETCONN_P (proc
))
3985 Fdelete_process (proc
);
3986 else if (XINT (XPROCESS (proc
)->infd
) >= 0)
3987 process_send_signal (proc
, SIGHUP
, Qnil
, 1);
3992 /* On receipt of a signal that a child status has changed,
3993 loop asking about children with changed statuses until
3994 the system says there are no more.
3995 All we do is change the status;
3996 we do not run sentinels or print notifications.
3997 That is saved for the next time keyboard input is done,
3998 in order to avoid timing errors. */
4000 /** WARNING: this can be called during garbage collection.
4001 Therefore, it must not be fooled by the presence of mark bits in
4004 /** USG WARNING: Although it is not obvious from the documentation
4005 in signal(2), on a USG system the SIGCLD handler MUST NOT call
4006 signal() before executing at least one wait(), otherwise the handler
4007 will be called again, resulting in an infinite loop. The relevant
4008 portion of the documentation reads "SIGCLD signals will be queued
4009 and the signal-catching function will be continually reentered until
4010 the queue is empty". Invoking signal() causes the kernel to reexamine
4011 the SIGCLD queue. Fred Fish, UniSoft Systems Inc. */
4014 sigchld_handler (signo
)
4017 int old_errno
= errno
;
4019 register struct Lisp_Process
*p
;
4020 extern EMACS_TIME
*input_available_clear_time
;
4024 sigheld
|= sigbit (SIGCHLD
);
4036 #endif /* no WUNTRACED */
4037 /* Keep trying to get a status until we get a definitive result. */
4041 pid
= wait3 (&w
, WNOHANG
| WUNTRACED
, 0);
4043 while (pid
<= 0 && errno
== EINTR
);
4047 /* A real failure. We have done all our job, so return. */
4049 /* USG systems forget handlers when they are used;
4050 must reestablish each time */
4051 #if defined (USG) && !defined (POSIX_SIGNALS)
4052 signal (signo
, sigchld_handler
); /* WARNING - must come after wait3() */
4055 sigheld
&= ~sigbit (SIGCHLD
);
4063 #endif /* no WNOHANG */
4065 /* Find the process that signaled us, and record its status. */
4068 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
4070 proc
= XCONS (XCONS (tail
)->car
)->cdr
;
4071 p
= XPROCESS (proc
);
4072 if (EQ (p
->childp
, Qt
) && XFASTINT (p
->pid
) == pid
)
4077 /* Look for an asynchronous process whose pid hasn't been filled
4080 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
4082 proc
= XCONS (XCONS (tail
)->car
)->cdr
;
4083 p
= XPROCESS (proc
);
4084 if (INTEGERP (p
->pid
) && XINT (p
->pid
) == -1)
4089 /* Change the status of the process that was found. */
4092 union { int i
; WAITTYPE wt
; } u
;
4093 int clear_desc_flag
= 0;
4095 XSETINT (p
->tick
, ++process_tick
);
4097 XSETINT (p
->raw_status_low
, u
.i
& 0xffff);
4098 XSETINT (p
->raw_status_high
, u
.i
>> 16);
4100 /* If process has terminated, stop waiting for its output. */
4101 if ((WIFSIGNALED (w
) || WIFEXITED (w
))
4102 && XINT (p
->infd
) >= 0)
4103 clear_desc_flag
= 1;
4105 /* We use clear_desc_flag to avoid a compiler bug in Microsoft C. */
4106 if (clear_desc_flag
)
4108 FD_CLR (XINT (p
->infd
), &input_wait_mask
);
4109 FD_CLR (XINT (p
->infd
), &non_keyboard_wait_mask
);
4112 /* Tell wait_reading_process_input that it needs to wake up and
4114 if (input_available_clear_time
)
4115 EMACS_SET_SECS_USECS (*input_available_clear_time
, 0, 0);
4118 /* There was no asynchronous process found for that id. Check
4119 if we have a synchronous process. */
4122 synch_process_alive
= 0;
4124 /* Report the status of the synchronous process. */
4126 synch_process_retcode
= WRETCODE (w
);
4127 else if (WIFSIGNALED (w
))
4129 int code
= WTERMSIG (w
);
4135 /* Suppress warning if the table has const char *. */
4136 signame
= (char *) sys_siglist
[code
];
4138 signame
= sys_errlist
[code
];
4142 signame
= "unknown";
4144 synch_process_death
= signame
;
4147 /* Tell wait_reading_process_input that it needs to wake up and
4149 if (input_available_clear_time
)
4150 EMACS_SET_SECS_USECS (*input_available_clear_time
, 0, 0);
4153 /* On some systems, we must return right away.
4154 If any more processes want to signal us, we will
4156 Otherwise (on systems that have WNOHANG), loop around
4157 to use up all the processes that have something to tell us. */
4158 #if defined (USG) && ! (defined (HPUX) && defined (WNOHANG)) || defined (WINDOWSNT)
4159 #if defined (USG) && ! defined (POSIX_SIGNALS)
4160 signal (signo
, sigchld_handler
);
4164 #endif /* USG, but not HPUX with WNOHANG */
4170 exec_sentinel_unwind (data
)
4173 XPROCESS (XCONS (data
)->car
)->sentinel
= XCONS (data
)->cdr
;
4178 exec_sentinel_error_handler (error
)
4181 cmd_error_internal (error
, "error in process sentinel: ");
4183 update_echo_area ();
4184 Fsleep_for (make_number (2), Qnil
);
4188 exec_sentinel (proc
, reason
)
4189 Lisp_Object proc
, reason
;
4191 Lisp_Object sentinel
, obuffer
, odeactivate
, okeymap
;
4192 register struct Lisp_Process
*p
= XPROCESS (proc
);
4193 int count
= specpdl_ptr
- specpdl
;
4194 int outer_running_asynch_code
= running_asynch_code
;
4195 int waiting
= waiting_for_user_input_p
;
4197 /* No need to gcpro these, because all we do with them later
4198 is test them for EQness, and none of them should be a string. */
4199 odeactivate
= Vdeactivate_mark
;
4200 XSETBUFFER (obuffer
, current_buffer
);
4201 okeymap
= current_buffer
->keymap
;
4203 sentinel
= p
->sentinel
;
4204 if (NILP (sentinel
))
4207 /* Zilch the sentinel while it's running, to avoid recursive invocations;
4208 assure that it gets restored no matter how the sentinel exits. */
4210 record_unwind_protect (exec_sentinel_unwind
, Fcons (proc
, sentinel
));
4211 /* Inhibit quit so that random quits don't screw up a running filter. */
4212 specbind (Qinhibit_quit
, Qt
);
4213 specbind (Qlast_nonmenu_event
, Qt
);
4215 /* In case we get recursively called,
4216 and we already saved the match data nonrecursively,
4217 save the same match data in safely recursive fashion. */
4218 if (outer_running_asynch_code
)
4221 tem
= Fmatch_data (Qnil
, Qnil
);
4222 restore_match_data ();
4223 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
4224 Fset_match_data (tem
);
4227 /* For speed, if a search happens within this code,
4228 save the match data in a special nonrecursive fashion. */
4229 running_asynch_code
= 1;
4231 internal_condition_case_1 (read_process_output_call
,
4233 Fcons (proc
, Fcons (reason
, Qnil
))),
4234 !NILP (Vdebug_on_error
) ? Qnil
: Qerror
,
4235 exec_sentinel_error_handler
);
4237 /* If we saved the match data nonrecursively, restore it now. */
4238 restore_match_data ();
4239 running_asynch_code
= outer_running_asynch_code
;
4241 Vdeactivate_mark
= odeactivate
;
4243 /* Restore waiting_for_user_input_p as it was
4244 when we were called, in case the filter clobbered it. */
4245 waiting_for_user_input_p
= waiting
;
4248 if (! EQ (Fcurrent_buffer (), obuffer
)
4249 || ! EQ (current_buffer
->keymap
, okeymap
))
4251 /* But do it only if the caller is actually going to read events.
4252 Otherwise there's no need to make him wake up, and it could
4253 cause trouble (for example it would make Fsit_for return). */
4254 if (waiting_for_user_input_p
== -1)
4255 record_asynch_buffer_change ();
4257 unbind_to (count
, Qnil
);
4260 /* Report all recent events of a change in process status
4261 (either run the sentinel or output a message).
4262 This is done while Emacs is waiting for keyboard input. */
4267 register Lisp_Object proc
, buffer
;
4268 Lisp_Object tail
, msg
;
4269 struct gcpro gcpro1
, gcpro2
;
4273 /* We need to gcpro tail; if read_process_output calls a filter
4274 which deletes a process and removes the cons to which tail points
4275 from Vprocess_alist, and then causes a GC, tail is an unprotected
4279 /* Set this now, so that if new processes are created by sentinels
4280 that we run, we get called again to handle their status changes. */
4281 update_tick
= process_tick
;
4283 for (tail
= Vprocess_alist
; !NILP (tail
); tail
= Fcdr (tail
))
4286 register struct Lisp_Process
*p
;
4288 proc
= Fcdr (Fcar (tail
));
4289 p
= XPROCESS (proc
);
4291 if (XINT (p
->tick
) != XINT (p
->update_tick
))
4293 XSETINT (p
->update_tick
, XINT (p
->tick
));
4295 /* If process is still active, read any output that remains. */
4296 while (! EQ (p
->filter
, Qt
)
4297 && XINT (p
->infd
) >= 0
4298 && read_process_output (proc
, XINT (p
->infd
)) > 0);
4302 /* Get the text to use for the message. */
4303 if (!NILP (p
->raw_status_low
))
4305 msg
= status_message (p
->status
);
4307 /* If process is terminated, deactivate it or delete it. */
4309 if (CONSP (p
->status
))
4310 symbol
= XCONS (p
->status
)->car
;
4312 if (EQ (symbol
, Qsignal
) || EQ (symbol
, Qexit
)
4313 || EQ (symbol
, Qclosed
))
4315 if (delete_exited_processes
)
4316 remove_process (proc
);
4318 deactivate_process (proc
);
4321 /* The actions above may have further incremented p->tick.
4322 So set p->update_tick again
4323 so that an error in the sentinel will not cause
4324 this code to be run again. */
4325 XSETINT (p
->update_tick
, XINT (p
->tick
));
4326 /* Now output the message suitably. */
4327 if (!NILP (p
->sentinel
))
4328 exec_sentinel (proc
, msg
);
4329 /* Don't bother with a message in the buffer
4330 when a process becomes runnable. */
4331 else if (!EQ (symbol
, Qrun
) && !NILP (buffer
))
4333 Lisp_Object ro
, tem
;
4334 struct buffer
*old
= current_buffer
;
4335 int opoint
, opoint_byte
;
4336 int before
, before_byte
;
4338 ro
= XBUFFER (buffer
)->read_only
;
4340 /* Avoid error if buffer is deleted
4341 (probably that's why the process is dead, too) */
4342 if (NILP (XBUFFER (buffer
)->name
))
4344 Fset_buffer (buffer
);
4347 opoint_byte
= PT_BYTE
;
4348 /* Insert new output into buffer
4349 at the current end-of-output marker,
4350 thus preserving logical ordering of input and output. */
4351 if (XMARKER (p
->mark
)->buffer
)
4352 Fgoto_char (p
->mark
);
4354 SET_PT_BOTH (ZV
, ZV_BYTE
);
4357 before_byte
= PT_BYTE
;
4359 tem
= current_buffer
->read_only
;
4360 current_buffer
->read_only
= Qnil
;
4361 insert_string ("\nProcess ");
4362 Finsert (1, &p
->name
);
4363 insert_string (" ");
4365 current_buffer
->read_only
= tem
;
4366 set_marker_both (p
->mark
, p
->buffer
, PT
, PT_BYTE
);
4368 if (opoint
>= before
)
4369 SET_PT_BOTH (opoint
+ (PT
- before
),
4370 opoint_byte
+ (PT_BYTE
- before_byte
));
4372 SET_PT_BOTH (opoint
, opoint_byte
);
4374 set_buffer_internal (old
);
4379 update_mode_lines
++; /* in case buffers use %s in mode-line-format */
4380 redisplay_preserve_echo_area ();
4386 DEFUN ("set-process-coding-system", Fset_process_coding_system
,
4387 Sset_process_coding_system
, 1, 3, 0,
4388 "Set coding systems of PROCESS to DECODING and ENCODING.\n\
4389 DECODING will be used to decode subprocess output and ENCODING to\n\
4390 encode subprocess input.")
4391 (proc
, decoding
, encoding
)
4392 register Lisp_Object proc
, decoding
, encoding
;
4394 register struct Lisp_Process
*p
;
4396 CHECK_PROCESS (proc
, 0);
4397 p
= XPROCESS (proc
);
4398 if (XINT (p
->infd
) < 0)
4399 error ("Input file descriptor of %s closed", XSTRING (p
->name
)->data
);
4400 if (XINT (p
->outfd
) < 0)
4401 error ("Output file descriptor of %s closed", XSTRING (p
->name
)->data
);
4403 p
->decode_coding_system
= Fcheck_coding_system (decoding
);
4404 p
->encode_coding_system
= Fcheck_coding_system (encoding
);
4405 setup_coding_system (decoding
,
4406 proc_decode_coding_system
[XINT (p
->infd
)]);
4407 setup_coding_system (encoding
,
4408 proc_encode_coding_system
[XINT (p
->outfd
)]);
4413 DEFUN ("process-coding-system",
4414 Fprocess_coding_system
, Sprocess_coding_system
, 1, 1, 0,
4415 "Return a cons of coding systems for decoding and encoding of PROCESS.")
4417 register Lisp_Object proc
;
4419 CHECK_PROCESS (proc
, 0);
4420 return Fcons (XPROCESS (proc
)->decode_coding_system
,
4421 XPROCESS (proc
)->encode_coding_system
);
4424 /* The first time this is called, assume keyboard input comes from DESC
4425 instead of from where we used to expect it.
4426 Subsequent calls mean assume input keyboard can come from DESC
4427 in addition to other places. */
4429 static int add_keyboard_wait_descriptor_called_flag
;
4432 add_keyboard_wait_descriptor (desc
)
4435 if (! add_keyboard_wait_descriptor_called_flag
)
4436 FD_CLR (0, &input_wait_mask
);
4437 add_keyboard_wait_descriptor_called_flag
= 1;
4438 FD_SET (desc
, &input_wait_mask
);
4439 FD_SET (desc
, &non_process_wait_mask
);
4440 if (desc
> max_keyboard_desc
)
4441 max_keyboard_desc
= desc
;
4444 /* From now on, do not expect DESC to give keyboard input. */
4447 delete_keyboard_wait_descriptor (desc
)
4451 int lim
= max_keyboard_desc
;
4453 FD_CLR (desc
, &input_wait_mask
);
4454 FD_CLR (desc
, &non_process_wait_mask
);
4456 if (desc
== max_keyboard_desc
)
4457 for (fd
= 0; fd
< lim
; fd
++)
4458 if (FD_ISSET (fd
, &input_wait_mask
)
4459 && !FD_ISSET (fd
, &non_keyboard_wait_mask
))
4460 max_keyboard_desc
= fd
;
4463 /* Return nonzero if *MASK has a bit set
4464 that corresponds to one of the keyboard input descriptors. */
4467 keyboard_bit_set (mask
)
4472 for (fd
= 0; fd
<= max_keyboard_desc
; fd
++)
4473 if (FD_ISSET (fd
, mask
) && FD_ISSET (fd
, &input_wait_mask
)
4474 && !FD_ISSET (fd
, &non_keyboard_wait_mask
))
4487 if (! noninteractive
|| initialized
)
4489 signal (SIGCHLD
, sigchld_handler
);
4492 FD_ZERO (&input_wait_mask
);
4493 FD_ZERO (&non_keyboard_wait_mask
);
4494 FD_ZERO (&non_process_wait_mask
);
4495 max_process_desc
= 0;
4497 FD_SET (0, &input_wait_mask
);
4499 Vprocess_alist
= Qnil
;
4500 for (i
= 0; i
< MAXDESC
; i
++)
4502 chan_process
[i
] = Qnil
;
4503 proc_buffered_char
[i
] = -1;
4505 bzero (proc_decode_coding_system
, sizeof proc_decode_coding_system
);
4506 bzero (proc_encode_coding_system
, sizeof proc_encode_coding_system
);
4508 Vdefault_process_coding_system
4509 = (NILP (buffer_defaults
.enable_multibyte_characters
)
4510 ? Fcons (Qraw_text
, Qnil
)
4511 : Fcons (Qemacs_mule
, Qnil
));
4517 Qprocessp
= intern ("processp");
4518 staticpro (&Qprocessp
);
4519 Qrun
= intern ("run");
4521 Qstop
= intern ("stop");
4523 Qsignal
= intern ("signal");
4524 staticpro (&Qsignal
);
4526 /* Qexit is already staticpro'd by syms_of_eval; don't staticpro it
4529 Qexit = intern ("exit");
4530 staticpro (&Qexit); */
4532 Qopen
= intern ("open");
4534 Qclosed
= intern ("closed");
4535 staticpro (&Qclosed
);
4537 Qlast_nonmenu_event
= intern ("last-nonmenu-event");
4538 staticpro (&Qlast_nonmenu_event
);
4540 staticpro (&Vprocess_alist
);
4542 DEFVAR_BOOL ("delete-exited-processes", &delete_exited_processes
,
4543 "*Non-nil means delete processes immediately when they exit.\n\
4544 nil means don't delete them until `list-processes' is run.");
4546 delete_exited_processes
= 1;
4548 DEFVAR_LISP ("process-connection-type", &Vprocess_connection_type
,
4549 "Control type of device used to communicate with subprocesses.\n\
4550 Values are nil to use a pipe, or t or `pty' to use a pty.\n\
4551 The value has no effect if the system has no ptys or if all ptys are busy:\n\
4552 then a pipe is used in any case.\n\
4553 The value takes effect when `start-process' is called.");
4554 Vprocess_connection_type
= Qt
;
4556 defsubr (&Sprocessp
);
4557 defsubr (&Sget_process
);
4558 defsubr (&Sget_buffer_process
);
4559 defsubr (&Sdelete_process
);
4560 defsubr (&Sprocess_status
);
4561 defsubr (&Sprocess_exit_status
);
4562 defsubr (&Sprocess_id
);
4563 defsubr (&Sprocess_name
);
4564 defsubr (&Sprocess_tty_name
);
4565 defsubr (&Sprocess_command
);
4566 defsubr (&Sset_process_buffer
);
4567 defsubr (&Sprocess_buffer
);
4568 defsubr (&Sprocess_mark
);
4569 defsubr (&Sset_process_filter
);
4570 defsubr (&Sprocess_filter
);
4571 defsubr (&Sset_process_sentinel
);
4572 defsubr (&Sprocess_sentinel
);
4573 defsubr (&Sset_process_window_size
);
4574 defsubr (&Sset_process_inherit_coding_system_flag
);
4575 defsubr (&Sprocess_inherit_coding_system_flag
);
4576 defsubr (&Sprocess_kill_without_query
);
4577 defsubr (&Sprocess_contact
);
4578 defsubr (&Slist_processes
);
4579 defsubr (&Sprocess_list
);
4580 defsubr (&Sstart_process
);
4582 defsubr (&Sopen_network_stream
);
4583 #endif /* HAVE_SOCKETS */
4584 defsubr (&Saccept_process_output
);
4585 defsubr (&Sprocess_send_region
);
4586 defsubr (&Sprocess_send_string
);
4587 defsubr (&Sinterrupt_process
);
4588 defsubr (&Skill_process
);
4589 defsubr (&Squit_process
);
4590 defsubr (&Sstop_process
);
4591 defsubr (&Scontinue_process
);
4592 defsubr (&Sprocess_running_child_p
);
4593 defsubr (&Sprocess_send_eof
);
4594 defsubr (&Ssignal_process
);
4595 defsubr (&Swaiting_for_user_input_p
);
4596 /* defsubr (&Sprocess_connection); */
4597 defsubr (&Sset_process_coding_system
);
4598 defsubr (&Sprocess_coding_system
);
4602 #else /* not subprocesses */
4604 #include <sys/types.h>
4608 #include "systime.h"
4609 #include "charset.h"
4611 #include "termopts.h"
4612 #include "sysselect.h"
4614 extern int frame_garbaged
;
4616 extern EMACS_TIME
timer_check ();
4617 extern int timers_run
;
4619 /* As described above, except assuming that there are no subprocesses:
4621 Wait for timeout to elapse and/or keyboard input to be available.
4624 timeout in seconds, or
4625 zero for no limit, or
4626 -1 means gobble data immediately available but don't wait for any.
4628 read_kbd is a Lisp_Object:
4629 0 to ignore keyboard input, or
4630 1 to return when input is available, or
4631 -1 means caller will actually read the input, so don't throw to
4633 a cons cell, meaning wait until its car is non-nil
4634 (and gobble terminal input into the buffer if any arrives), or
4635 We know that read_kbd will never be a Lisp_Process, since
4636 `subprocesses' isn't defined.
4638 do_display != 0 means redisplay should be done to show subprocess
4639 output that arrives.
4641 Return true iff we received input from any process. */
4644 wait_reading_process_input (time_limit
, microsecs
, read_kbd
, do_display
)
4645 int time_limit
, microsecs
;
4646 Lisp_Object read_kbd
;
4650 EMACS_TIME end_time
, timeout
;
4651 SELECT_TYPE waitchannels
;
4653 Lisp_Object
*wait_for_cell
= 0;
4655 /* If waiting for non-nil in a cell, record where. */
4656 if (CONSP (read_kbd
))
4658 wait_for_cell
= &XCONS (read_kbd
)->car
;
4659 XSETFASTINT (read_kbd
, 0);
4662 /* What does time_limit really mean? */
4663 if (time_limit
|| microsecs
)
4665 EMACS_GET_TIME (end_time
);
4666 EMACS_SET_SECS_USECS (timeout
, time_limit
, microsecs
);
4667 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
4670 /* Turn off periodic alarms (in case they are in use)
4671 because the select emulator uses alarms. */
4676 int timeout_reduced_for_timers
= 0;
4678 /* If calling from keyboard input, do not quit
4679 since we want to return C-g as an input character.
4680 Otherwise, do pending quit if requested. */
4681 if (XINT (read_kbd
) >= 0)
4684 /* Exit now if the cell we're waiting for became non-nil. */
4685 if (wait_for_cell
&& ! NILP (*wait_for_cell
))
4688 /* Compute time from now till when time limit is up */
4689 /* Exit if already run out */
4690 if (time_limit
== -1)
4692 /* -1 specified for timeout means
4693 gobble output available now
4694 but don't wait at all. */
4696 EMACS_SET_SECS_USECS (timeout
, 0, 0);
4698 else if (time_limit
|| microsecs
)
4700 EMACS_GET_TIME (timeout
);
4701 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
4702 if (EMACS_TIME_NEG_P (timeout
))
4707 EMACS_SET_SECS_USECS (timeout
, 100000, 0);
4710 /* If our caller will not immediately handle keyboard events,
4711 run timer events directly.
4712 (Callers that will immediately read keyboard events
4713 call timer_delay on their own.) */
4714 if (! wait_for_cell
)
4716 EMACS_TIME timer_delay
;
4720 old_timers_run
= timers_run
;
4721 timer_delay
= timer_check (1);
4722 if (timers_run
!= old_timers_run
&& do_display
)
4724 redisplay_preserve_echo_area ();
4725 /* We must retry, since a timer may have requeued itself
4726 and that could alter the time delay. */
4730 /* If there is unread keyboard input, also return. */
4731 if (XINT (read_kbd
) != 0
4732 && requeued_events_pending_p ())
4735 if (! EMACS_TIME_NEG_P (timer_delay
) && time_limit
!= -1)
4737 EMACS_TIME difference
;
4738 EMACS_SUB_TIME (difference
, timer_delay
, timeout
);
4739 if (EMACS_TIME_NEG_P (difference
))
4741 timeout
= timer_delay
;
4742 timeout_reduced_for_timers
= 1;
4747 /* Cause C-g and alarm signals to take immediate action,
4748 and cause input available signals to zero out timeout. */
4749 if (XINT (read_kbd
) < 0)
4750 set_waiting_for_input (&timeout
);
4752 /* Wait till there is something to do. */
4754 if (! XINT (read_kbd
) && wait_for_cell
== 0)
4755 FD_ZERO (&waitchannels
);
4757 FD_SET (0, &waitchannels
);
4759 /* If a frame has been newly mapped and needs updating,
4760 reprocess its display stuff. */
4761 if (frame_garbaged
&& do_display
)
4763 clear_waiting_for_input ();
4764 redisplay_preserve_echo_area ();
4765 if (XINT (read_kbd
) < 0)
4766 set_waiting_for_input (&timeout
);
4769 if (XINT (read_kbd
) && detect_input_pending ())
4772 FD_ZERO (&waitchannels
);
4775 nfds
= select (1, &waitchannels
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0,
4780 /* Make C-g and alarm signals set flags again */
4781 clear_waiting_for_input ();
4783 /* If we woke up due to SIGWINCH, actually change size now. */
4784 do_pending_window_change ();
4786 if (time_limit
&& nfds
== 0 && ! timeout_reduced_for_timers
)
4787 /* We waited the full specified time, so return now. */
4792 /* If the system call was interrupted, then go around the
4794 if (xerrno
== EINTR
)
4795 FD_ZERO (&waitchannels
);
4797 error ("select error: %s", strerror (xerrno
));
4800 else if (nfds
> 0 && (waitchannels
& 1) && interrupt_input
)
4801 /* System sometimes fails to deliver SIGIO. */
4802 kill (getpid (), SIGIO
);
4805 if (XINT (read_kbd
) && interrupt_input
&& (waitchannels
& 1))
4806 kill (getpid (), SIGIO
);
4809 /* Check for keyboard input */
4811 if ((XINT (read_kbd
) != 0)
4812 && detect_input_pending_run_timers (do_display
))
4814 swallow_events (do_display
);
4815 if (detect_input_pending_run_timers (do_display
))
4819 /* If there is unread keyboard input, also return. */
4820 if (XINT (read_kbd
) != 0
4821 && requeued_events_pending_p ())
4824 /* If wait_for_cell. check for keyboard input
4825 but don't run any timers.
4826 ??? (It seems wrong to me to check for keyboard
4827 input at all when wait_for_cell, but the code
4828 has been this way since July 1994.
4829 Try changing this after version 19.31.) */
4831 && detect_input_pending ())
4833 swallow_events (do_display
);
4834 if (detect_input_pending ())
4838 /* Exit now if the cell we're waiting for became non-nil. */
4839 if (wait_for_cell
&& ! NILP (*wait_for_cell
))
4849 DEFUN ("get-buffer-process", Fget_buffer_process
, Sget_buffer_process
, 1, 1, 0,
4850 /* Don't confuse make-docfile by having two doc strings for this function.
4851 make-docfile does not pay attention to #if, for good reason! */
4854 register Lisp_Object name
;
4859 DEFUN ("process-inherit-coding-system-flag",
4860 Fprocess_inherit_coding_system_flag
, Sprocess_inherit_coding_system_flag
,
4862 /* Don't confuse make-docfile by having two doc strings for this function.
4863 make-docfile does not pay attention to #if, for good reason! */
4866 register Lisp_Object process
;
4868 /* Ignore the argument and return the value of
4869 inherit-process-coding-system. */
4870 return inherit_process_coding_system
? Qt
: Qnil
;
4873 /* Kill all processes associated with `buffer'.
4874 If `buffer' is nil, kill all processes.
4875 Since we have no subprocesses, this does nothing. */
4878 kill_buffer_processes (buffer
)
4891 defsubr (&Sget_buffer_process
);
4892 defsubr (&Sprocess_inherit_coding_system_flag
);
4896 #endif /* not subprocesses */