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"
146 extern void set_waiting_for_input
P_ ((EMACS_TIME
*));
149 extern char *strerror ();
151 extern char *sys_errlist
[];
158 #ifndef SYS_SIGLIST_DECLARED
163 extern char *sys_siglist
[];
164 #endif /* not LINUX */
166 char *sys_siglist
[] =
172 "illegal instruction",
176 "floating point exception",
179 "segmentation violation",
180 "bad argument to system call",
181 "write on a pipe with no one to read it",
183 "software termination signal from kill",
185 "sendable stop signal not from tty",
186 "stop signal from tty",
187 "continue a stopped process",
188 "child status has changed",
189 "background read attempted from control tty",
190 "background write attempted from control tty",
191 "input record available at control tty",
192 "exceeded CPU time limit",
193 "exceeded file size limit"
195 #endif /* not WINDOWSNT */
198 #endif /* ! SYS_SIGLIST_DECLARED */
200 /* t means use pty, nil means use a pipe,
201 maybe other values to come. */
202 static Lisp_Object Vprocess_connection_type
;
206 #include <sys/socket.h>
210 /* These next two vars are non-static since sysdep.c uses them in the
211 emulation of `select'. */
212 /* Number of events of change of status of a process. */
214 /* Number of events for which the user or sentinel has been notified. */
217 #include "sysselect.h"
219 extern int keyboard_bit_set
P_ ((SELECT_TYPE
*));
221 /* If we support a window system, turn on the code to poll periodically
222 to detect C-g. It isn't actually used when doing interrupt input. */
223 #ifdef HAVE_WINDOW_SYSTEM
224 #define POLL_FOR_INPUT
227 /* Mask of bits indicating the descriptors that we wait for input on. */
229 static SELECT_TYPE input_wait_mask
;
231 /* Mask that excludes keyboard input descriptor (s). */
233 static SELECT_TYPE non_keyboard_wait_mask
;
235 /* Mask that excludes process input descriptor (s). */
237 static SELECT_TYPE non_process_wait_mask
;
239 /* The largest descriptor currently in use for a process object. */
240 static int max_process_desc
;
242 /* The largest descriptor currently in use for keyboard input. */
243 static int max_keyboard_desc
;
245 /* Nonzero means delete a process right away if it exits. */
246 static int delete_exited_processes
;
248 /* Indexed by descriptor, gives the process (if any) for that descriptor */
249 Lisp_Object chan_process
[MAXDESC
];
251 /* Alist of elements (NAME . PROCESS) */
252 Lisp_Object Vprocess_alist
;
254 /* Buffered-ahead input char from process, indexed by channel.
255 -1 means empty (no char is buffered).
256 Used on sys V where the only way to tell if there is any
257 output from the process is to read at least one char.
258 Always -1 on systems that support FIONREAD. */
260 /* Don't make static; need to access externally. */
261 int proc_buffered_char
[MAXDESC
];
263 /* Table of `struct coding-system' for each process. */
264 static struct coding_system
*proc_decode_coding_system
[MAXDESC
];
265 static struct coding_system
*proc_encode_coding_system
[MAXDESC
];
267 static Lisp_Object
get_process ();
269 extern EMACS_TIME
timer_check ();
270 extern int timers_run
;
272 /* Maximum number of bytes to send to a pty without an eof. */
273 static int pty_max_bytes
;
275 extern Lisp_Object Vfile_name_coding_system
, Vdefault_file_name_coding_system
;
278 /* The file name of the pty opened by allocate_pty. */
280 static char pty_name
[24];
283 /* Compute the Lisp form of the process status, p->status, from
284 the numeric status that was returned by `wait'. */
286 Lisp_Object
status_convert ();
290 struct Lisp_Process
*p
;
292 union { int i
; WAITTYPE wt
; } u
;
293 u
.i
= XFASTINT (p
->raw_status_low
) + (XFASTINT (p
->raw_status_high
) << 16);
294 p
->status
= status_convert (u
.wt
);
295 p
->raw_status_low
= Qnil
;
296 p
->raw_status_high
= Qnil
;
299 /* Convert a process status word in Unix format to
300 the list that we use internally. */
307 return Fcons (Qstop
, Fcons (make_number (WSTOPSIG (w
)), Qnil
));
308 else if (WIFEXITED (w
))
309 return Fcons (Qexit
, Fcons (make_number (WRETCODE (w
)),
310 WCOREDUMP (w
) ? Qt
: Qnil
));
311 else if (WIFSIGNALED (w
))
312 return Fcons (Qsignal
, Fcons (make_number (WTERMSIG (w
)),
313 WCOREDUMP (w
) ? Qt
: Qnil
));
318 /* Given a status-list, extract the three pieces of information
319 and store them individually through the three pointers. */
322 decode_status (l
, symbol
, code
, coredump
)
340 *code
= XFASTINT (XCAR (tem
));
342 *coredump
= !NILP (tem
);
346 /* Return a string describing a process status list. */
349 status_message (status
)
354 Lisp_Object string
, string2
;
356 decode_status (status
, &symbol
, &code
, &coredump
);
358 if (EQ (symbol
, Qsignal
) || EQ (symbol
, Qstop
))
364 /* Cast to suppress warning if the table has const char *. */
365 signame
= (char *) sys_siglist
[code
];
367 signame
= sys_errlist
[code
];
372 string
= build_string (signame
);
373 string2
= build_string (coredump
? " (core dumped)\n" : "\n");
374 XSTRING (string
)->data
[0] = DOWNCASE (XSTRING (string
)->data
[0]);
375 return concat2 (string
, string2
);
377 else if (EQ (symbol
, Qexit
))
380 return build_string ("finished\n");
381 string
= Fnumber_to_string (make_number (code
));
382 string2
= build_string (coredump
? " (core dumped)\n" : "\n");
383 return concat2 (build_string ("exited abnormally with code "),
384 concat2 (string
, string2
));
387 return Fcopy_sequence (Fsymbol_name (symbol
));
392 /* Open an available pty, returning a file descriptor.
393 Return -1 on failure.
394 The file name of the terminal corresponding to the pty
395 is left in the variable pty_name. */
404 /* Some systems name their pseudoterminals so that there are gaps in
405 the usual sequence - for example, on HP9000/S700 systems, there
406 are no pseudoterminals with names ending in 'f'. So we wait for
407 three failures in a row before deciding that we've reached the
409 int failed_count
= 0;
414 for (c
= FIRST_PTY_LETTER
; c
<= 'z'; c
++)
415 for (i
= 0; i
< 16; i
++)
418 #ifdef PTY_NAME_SPRINTF
421 sprintf (pty_name
, "/dev/pty%c%x", c
, i
);
422 #endif /* no PTY_NAME_SPRINTF */
426 #else /* no PTY_OPEN */
428 /* Unusual IRIS code */
429 *ptyv
= open ("/dev/ptc", O_RDWR
| O_NDELAY
, 0);
432 if (fstat (fd
, &stb
) < 0)
435 if (stat (pty_name
, &stb
) < 0)
438 if (failed_count
>= 3)
444 fd
= open (pty_name
, O_RDWR
| O_NONBLOCK
, 0);
446 fd
= open (pty_name
, O_RDWR
| O_NDELAY
, 0);
448 #endif /* not IRIS */
449 #endif /* no PTY_OPEN */
453 /* check to make certain that both sides are available
454 this avoids a nasty yet stupid bug in rlogins */
455 #ifdef PTY_TTY_NAME_SPRINTF
458 sprintf (pty_name
, "/dev/tty%c%x", c
, i
);
459 #endif /* no PTY_TTY_NAME_SPRINTF */
461 if (access (pty_name
, 6) != 0)
464 #if !defined(IRIS) && !defined(__sgi)
470 #endif /* not UNIPLUS */
477 #endif /* HAVE_PTYS */
483 struct Lisp_Vector
*vec
;
484 register Lisp_Object val
, tem
, name1
;
485 register struct Lisp_Process
*p
;
489 vec
= allocate_vectorlike ((EMACS_INT
) VECSIZE (struct Lisp_Process
));
490 for (i
= 0; i
< VECSIZE (struct Lisp_Process
); i
++)
491 vec
->contents
[i
] = Qnil
;
492 vec
->size
= VECSIZE (struct Lisp_Process
);
493 p
= (struct Lisp_Process
*)vec
;
495 XSETINT (p
->infd
, -1);
496 XSETINT (p
->outfd
, -1);
497 XSETFASTINT (p
->pid
, 0);
498 XSETFASTINT (p
->tick
, 0);
499 XSETFASTINT (p
->update_tick
, 0);
500 p
->raw_status_low
= Qnil
;
501 p
->raw_status_high
= Qnil
;
503 p
->mark
= Fmake_marker ();
505 /* If name is already in use, modify it until it is unused. */
510 tem
= Fget_process (name1
);
511 if (NILP (tem
)) break;
512 sprintf (suffix
, "<%d>", i
);
513 name1
= concat2 (name
, build_string (suffix
));
517 XSETPROCESS (val
, p
);
518 Vprocess_alist
= Fcons (Fcons (name
, val
), Vprocess_alist
);
523 remove_process (proc
)
524 register Lisp_Object proc
;
526 register Lisp_Object pair
;
528 pair
= Frassq (proc
, Vprocess_alist
);
529 Vprocess_alist
= Fdelq (pair
, Vprocess_alist
);
531 deactivate_process (proc
);
534 DEFUN ("processp", Fprocessp
, Sprocessp
, 1, 1, 0,
535 "Return t if OBJECT is a process.")
539 return PROCESSP (object
) ? Qt
: Qnil
;
542 DEFUN ("get-process", Fget_process
, Sget_process
, 1, 1, 0,
543 "Return the process named NAME, or nil if there is none.")
545 register Lisp_Object name
;
549 CHECK_STRING (name
, 0);
550 return Fcdr (Fassoc (name
, Vprocess_alist
));
553 DEFUN ("get-buffer-process", Fget_buffer_process
, Sget_buffer_process
, 1, 1, 0,
554 "Return the (or a) process associated with BUFFER.\n\
555 BUFFER may be a buffer or the name of one.")
557 register Lisp_Object buffer
;
559 register Lisp_Object buf
, tail
, proc
;
561 if (NILP (buffer
)) return Qnil
;
562 buf
= Fget_buffer (buffer
);
563 if (NILP (buf
)) return Qnil
;
565 for (tail
= Vprocess_alist
; !NILP (tail
); tail
= Fcdr (tail
))
567 proc
= Fcdr (Fcar (tail
));
568 if (PROCESSP (proc
) && EQ (XPROCESS (proc
)->buffer
, buf
))
574 /* This is how commands for the user decode process arguments. It
575 accepts a process, a process name, a buffer, a buffer name, or nil.
576 Buffers denote the first process in the buffer, and nil denotes the
581 register Lisp_Object name
;
583 register Lisp_Object proc
, obj
;
586 obj
= Fget_process (name
);
588 obj
= Fget_buffer (name
);
590 error ("Process %s does not exist", XSTRING (name
)->data
);
592 else if (NILP (name
))
593 obj
= Fcurrent_buffer ();
597 /* Now obj should be either a buffer object or a process object.
601 proc
= Fget_buffer_process (obj
);
603 error ("Buffer %s has no process", XSTRING (XBUFFER (obj
)->name
)->data
);
607 CHECK_PROCESS (obj
, 0);
613 DEFUN ("delete-process", Fdelete_process
, Sdelete_process
, 1, 1, 0,
614 "Delete PROCESS: kill it and forget about it immediately.\n\
615 PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
616 nil, indicating the current buffer's process.")
618 register Lisp_Object process
;
620 process
= get_process (process
);
621 XPROCESS (process
)->raw_status_low
= Qnil
;
622 XPROCESS (process
)->raw_status_high
= Qnil
;
623 if (NETCONN_P (process
))
625 XPROCESS (process
)->status
= Fcons (Qexit
, Fcons (make_number (0), Qnil
));
626 XSETINT (XPROCESS (process
)->tick
, ++process_tick
);
628 else if (XINT (XPROCESS (process
)->infd
) >= 0)
630 Fkill_process (process
, Qnil
);
631 /* Do this now, since remove_process will make sigchld_handler do nothing. */
632 XPROCESS (process
)->status
633 = Fcons (Qsignal
, Fcons (make_number (SIGKILL
), Qnil
));
634 XSETINT (XPROCESS (process
)->tick
, ++process_tick
);
637 remove_process (process
);
641 DEFUN ("process-status", Fprocess_status
, Sprocess_status
, 1, 1, 0,
642 "Return the status of PROCESS.\n\
643 The returned value is one of the following symbols:\n\
644 run -- for a process that is running.\n\
645 stop -- for a process stopped but continuable.\n\
646 exit -- for a process that has exited.\n\
647 signal -- for a process that has got a fatal signal.\n\
648 open -- for a network stream connection that is open.\n\
649 closed -- for a network stream connection that is closed.\n\
650 nil -- if arg is a process name and no such process exists.\n\
651 PROCESS may be a process, a buffer, the name of a process, or\n\
652 nil, indicating the current buffer's process.")
654 register Lisp_Object process
;
656 register struct Lisp_Process
*p
;
657 register Lisp_Object status
;
659 if (STRINGP (process
))
660 process
= Fget_process (process
);
662 process
= get_process (process
);
667 p
= XPROCESS (process
);
668 if (!NILP (p
->raw_status_low
))
672 status
= XCAR (status
);
673 if (NETCONN_P (process
))
675 if (EQ (status
, Qrun
))
677 else if (EQ (status
, Qexit
))
683 DEFUN ("process-exit-status", Fprocess_exit_status
, Sprocess_exit_status
,
685 "Return the exit status of PROCESS or the signal number that killed it.\n\
686 If PROCESS has not yet exited or died, return 0.")
688 register Lisp_Object process
;
690 CHECK_PROCESS (process
, 0);
691 if (!NILP (XPROCESS (process
)->raw_status_low
))
692 update_status (XPROCESS (process
));
693 if (CONSP (XPROCESS (process
)->status
))
694 return XCAR (XCDR (XPROCESS (process
)->status
));
695 return make_number (0);
698 DEFUN ("process-id", Fprocess_id
, Sprocess_id
, 1, 1, 0,
699 "Return the process id of PROCESS.\n\
700 This is the pid of the Unix process which PROCESS uses or talks to.\n\
701 For a network connection, this value is nil.")
703 register Lisp_Object process
;
705 CHECK_PROCESS (process
, 0);
706 return XPROCESS (process
)->pid
;
709 DEFUN ("process-name", Fprocess_name
, Sprocess_name
, 1, 1, 0,
710 "Return the name of PROCESS, as a string.\n\
711 This is the name of the program invoked in PROCESS,\n\
712 possibly modified to make it unique among process names.")
714 register Lisp_Object process
;
716 CHECK_PROCESS (process
, 0);
717 return XPROCESS (process
)->name
;
720 DEFUN ("process-command", Fprocess_command
, Sprocess_command
, 1, 1, 0,
721 "Return the command that was executed to start PROCESS.\n\
722 This is a list of strings, the first string being the program executed\n\
723 and the rest of the strings being the arguments given to it.\n\
724 For a non-child channel, this is nil.")
726 register Lisp_Object process
;
728 CHECK_PROCESS (process
, 0);
729 return XPROCESS (process
)->command
;
732 DEFUN ("process-tty-name", Fprocess_tty_name
, Sprocess_tty_name
, 1, 1, 0,
733 "Return the name of the terminal PROCESS uses, or nil if none.\n\
734 This is the terminal that the process itself reads and writes on,\n\
735 not the name of the pty that Emacs uses to talk with that terminal.")
737 register Lisp_Object process
;
739 CHECK_PROCESS (process
, 0);
740 return XPROCESS (process
)->tty_name
;
743 DEFUN ("set-process-buffer", Fset_process_buffer
, Sset_process_buffer
,
745 "Set buffer associated with PROCESS to BUFFER (a buffer, or nil).")
747 register Lisp_Object process
, buffer
;
749 CHECK_PROCESS (process
, 0);
751 CHECK_BUFFER (buffer
, 1);
752 XPROCESS (process
)->buffer
= buffer
;
756 DEFUN ("process-buffer", Fprocess_buffer
, Sprocess_buffer
,
758 "Return the buffer PROCESS is associated with.\n\
759 Output from PROCESS is inserted in this buffer unless PROCESS has a filter.")
761 register Lisp_Object process
;
763 CHECK_PROCESS (process
, 0);
764 return XPROCESS (process
)->buffer
;
767 DEFUN ("process-mark", Fprocess_mark
, Sprocess_mark
,
769 "Return the marker for the end of the last output from PROCESS.")
771 register Lisp_Object process
;
773 CHECK_PROCESS (process
, 0);
774 return XPROCESS (process
)->mark
;
777 DEFUN ("set-process-filter", Fset_process_filter
, Sset_process_filter
,
779 "Give PROCESS the filter function FILTER; nil means no filter.\n\
780 t means stop accepting output from the process.\n\
781 When a process has a filter, each time it does output\n\
782 the entire string of output is passed to the filter.\n\
783 The filter gets two arguments: the process and the string of output.\n\
784 If the process has a filter, its buffer is not used for output.")
786 register Lisp_Object process
, filter
;
788 CHECK_PROCESS (process
, 0);
791 FD_CLR (XINT (XPROCESS (process
)->infd
), &input_wait_mask
);
792 FD_CLR (XINT (XPROCESS (process
)->infd
), &non_keyboard_wait_mask
);
794 else if (EQ (XPROCESS (process
)->filter
, Qt
))
796 FD_SET (XINT (XPROCESS (process
)->infd
), &input_wait_mask
);
797 FD_SET (XINT (XPROCESS (process
)->infd
), &non_keyboard_wait_mask
);
799 XPROCESS (process
)->filter
= filter
;
803 DEFUN ("process-filter", Fprocess_filter
, Sprocess_filter
,
805 "Returns the filter function of PROCESS; nil if none.\n\
806 See `set-process-filter' for more info on filter functions.")
808 register Lisp_Object process
;
810 CHECK_PROCESS (process
, 0);
811 return XPROCESS (process
)->filter
;
814 DEFUN ("set-process-sentinel", Fset_process_sentinel
, Sset_process_sentinel
,
816 "Give PROCESS the sentinel SENTINEL; nil for none.\n\
817 The sentinel is called as a function when the process changes state.\n\
818 It gets two arguments: the process, and a string describing the change.")
820 register Lisp_Object process
, sentinel
;
822 CHECK_PROCESS (process
, 0);
823 XPROCESS (process
)->sentinel
= sentinel
;
827 DEFUN ("process-sentinel", Fprocess_sentinel
, Sprocess_sentinel
,
829 "Return the sentinel of PROCESS; nil if none.\n\
830 See `set-process-sentinel' for more info on sentinels.")
832 register Lisp_Object process
;
834 CHECK_PROCESS (process
, 0);
835 return XPROCESS (process
)->sentinel
;
838 DEFUN ("set-process-window-size", Fset_process_window_size
,
839 Sset_process_window_size
, 3, 3, 0,
840 "Tell PROCESS that it has logical window size HEIGHT and WIDTH.")
841 (process
, height
, width
)
842 register Lisp_Object process
, height
, width
;
844 CHECK_PROCESS (process
, 0);
845 CHECK_NATNUM (height
, 0);
846 CHECK_NATNUM (width
, 0);
847 if (set_window_size (XINT (XPROCESS (process
)->infd
),
848 XINT (height
), XINT (width
)) <= 0)
854 DEFUN ("set-process-inherit-coding-system-flag",
855 Fset_process_inherit_coding_system_flag
,
856 Sset_process_inherit_coding_system_flag
, 2, 2, 0,
857 "Determine whether buffer of PROCESS will inherit coding-system.\n\
858 If the second argument FLAG is non-nil, then the variable\n\
859 `buffer-file-coding-system' of the buffer associated with PROCESS\n\
860 will be bound to the value of the coding system used to decode\n\
861 the process output.\n\
863 This is useful when the coding system specified for the process buffer\n\
864 leaves either the character code conversion or the end-of-line conversion\n\
865 unspecified, or if the coding system used to decode the process output\n\
866 is more appropriate for saving the process buffer.\n\
868 Binding the variable `inherit-process-coding-system' to non-nil before\n\
869 starting the process is an alternative way of setting the inherit flag\n\
870 for the process which will run.")
872 register Lisp_Object process
, flag
;
874 CHECK_PROCESS (process
, 0);
875 XPROCESS (process
)->inherit_coding_system_flag
= flag
;
879 DEFUN ("process-inherit-coding-system-flag",
880 Fprocess_inherit_coding_system_flag
, Sprocess_inherit_coding_system_flag
,
882 "Return the value of inherit-coding-system flag for PROCESS.\n\
883 If this flag is t, `buffer-file-coding-system' of the buffer\n\
884 associated with PROCESS will inherit the coding system used to decode\n\
885 the process output.")
887 register Lisp_Object process
;
889 CHECK_PROCESS (process
, 0);
890 return XPROCESS (process
)->inherit_coding_system_flag
;
893 DEFUN ("process-kill-without-query", Fprocess_kill_without_query
,
894 Sprocess_kill_without_query
, 1, 2, 0,
895 "Say no query needed if PROCESS is running when Emacs is exited.\n\
896 Optional second argument if non-nil says to require a query.\n\
897 Value is t if a query was formerly required.")
899 register Lisp_Object process
, value
;
903 CHECK_PROCESS (process
, 0);
904 tem
= XPROCESS (process
)->kill_without_query
;
905 XPROCESS (process
)->kill_without_query
= Fnull (value
);
910 DEFUN ("process-contact", Fprocess_contact
, Sprocess_contact
,
912 "Return the contact info of PROCESS; t for a real child.\n\
913 For a net connection, the value is a cons cell of the form (HOST SERVICE).")
915 register Lisp_Object process
;
917 CHECK_PROCESS (process
, 0);
918 return XPROCESS (process
)->childp
;
921 #if 0 /* Turned off because we don't currently record this info
922 in the process. Perhaps add it. */
923 DEFUN ("process-connection", Fprocess_connection
, Sprocess_connection
, 1, 1, 0,
924 "Return the connection type of PROCESS.\n\
925 The value is nil for a pipe, t or `pty' for a pty, or `stream' for\n\
926 a socket connection.")
930 return XPROCESS (process
)->type
;
937 register Lisp_Object tail
, tem
;
938 Lisp_Object proc
, minspace
, tem1
;
939 register struct Lisp_Process
*p
;
942 XSETFASTINT (minspace
, 1);
944 set_buffer_internal (XBUFFER (Vstandard_output
));
945 Fbuffer_disable_undo (Vstandard_output
);
947 current_buffer
->truncate_lines
= Qt
;
950 Proc Status Buffer Tty Command\n\
951 ---- ------ ------ --- -------\n", -1);
953 for (tail
= Vprocess_alist
; !NILP (tail
); tail
= Fcdr (tail
))
957 proc
= Fcdr (Fcar (tail
));
959 if (NILP (p
->childp
))
962 Finsert (1, &p
->name
);
963 Findent_to (make_number (13), minspace
);
965 if (!NILP (p
->raw_status_low
))
968 if (CONSP (p
->status
))
969 symbol
= XCAR (p
->status
);
972 if (EQ (symbol
, Qsignal
))
975 tem
= Fcar (Fcdr (p
->status
));
977 if (XINT (tem
) < NSIG
)
978 write_string (sys_errlist
[XINT (tem
)], -1);
981 Fprinc (symbol
, Qnil
);
983 else if (NETCONN_P (proc
))
985 if (EQ (symbol
, Qrun
))
986 write_string ("open", -1);
987 else if (EQ (symbol
, Qexit
))
988 write_string ("closed", -1);
990 Fprinc (symbol
, Qnil
);
993 Fprinc (symbol
, Qnil
);
995 if (EQ (symbol
, Qexit
))
998 tem
= Fcar (Fcdr (p
->status
));
1001 sprintf (tembuf
, " %d", (int) XFASTINT (tem
));
1002 write_string (tembuf
, -1);
1006 if (EQ (symbol
, Qsignal
) || EQ (symbol
, Qexit
))
1007 remove_process (proc
);
1009 Findent_to (make_number (22), minspace
);
1010 if (NILP (p
->buffer
))
1011 insert_string ("(none)");
1012 else if (NILP (XBUFFER (p
->buffer
)->name
))
1013 insert_string ("(Killed)");
1015 Finsert (1, &XBUFFER (p
->buffer
)->name
);
1017 Findent_to (make_number (37), minspace
);
1019 if (STRINGP (p
->tty_name
))
1020 Finsert (1, &p
->tty_name
);
1022 insert_string ("(none)");
1024 Findent_to (make_number (49), minspace
);
1026 if (NETCONN_P (proc
))
1028 sprintf (tembuf
, "(network stream connection to %s)\n",
1029 XSTRING (XCAR (p
->childp
))->data
);
1030 insert_string (tembuf
);
1042 insert_string (" ");
1044 insert_string ("\n");
1050 DEFUN ("list-processes", Flist_processes
, Slist_processes
, 0, 0, "",
1051 "Display a list of all processes.\n\
1052 Any process listed as exited or signaled is actually eliminated\n\
1053 after the listing is made.")
1056 internal_with_output_to_temp_buffer ("*Process List*",
1057 list_processes_1
, Qnil
);
1061 DEFUN ("process-list", Fprocess_list
, Sprocess_list
, 0, 0, 0,
1062 "Return a list of all processes.")
1065 return Fmapcar (Qcdr
, Vprocess_alist
);
1068 /* Starting asynchronous inferior processes. */
1070 static Lisp_Object
start_process_unwind ();
1072 DEFUN ("start-process", Fstart_process
, Sstart_process
, 3, MANY
, 0,
1073 "Start a program in a subprocess. Return the process object for it.\n\
1074 Args are NAME BUFFER PROGRAM &rest PROGRAM-ARGS\n\
1075 NAME is name for process. It is modified if necessary to make it unique.\n\
1076 BUFFER is the buffer or (buffer-name) to associate with the process.\n\
1077 Process output goes at end of that buffer, unless you specify\n\
1078 an output stream or filter function to handle the output.\n\
1079 BUFFER may be also nil, meaning that this process is not associated\n\
1081 Third arg is program file name. It is searched for in PATH.\n\
1082 Remaining arguments are strings to give program as arguments.")
1085 register Lisp_Object
*args
;
1087 Lisp_Object buffer
, name
, program
, proc
, current_dir
, tem
;
1089 register unsigned char *new_argv
;
1092 register unsigned char **new_argv
;
1095 int count
= specpdl_ptr
- specpdl
;
1099 buffer
= Fget_buffer_create (buffer
);
1101 /* Make sure that the child will be able to chdir to the current
1102 buffer's current directory, or its unhandled equivalent. We
1103 can't just have the child check for an error when it does the
1104 chdir, since it's in a vfork.
1106 We have to GCPRO around this because Fexpand_file_name and
1107 Funhandled_file_name_directory might call a file name handling
1108 function. The argument list is protected by the caller, so all
1109 we really have to worry about is buffer. */
1111 struct gcpro gcpro1
, gcpro2
;
1113 current_dir
= current_buffer
->directory
;
1115 GCPRO2 (buffer
, current_dir
);
1118 = expand_and_dir_to_file (Funhandled_file_name_directory (current_dir
),
1120 if (NILP (Ffile_accessible_directory_p (current_dir
)))
1121 report_file_error ("Setting current directory",
1122 Fcons (current_buffer
->directory
, Qnil
));
1128 CHECK_STRING (name
, 0);
1132 CHECK_STRING (program
, 2);
1135 /* Make a one member argv with all args concatenated
1136 together separated by a blank. */
1137 len
= STRING_BYTES (XSTRING (program
)) + 2;
1138 for (i
= 3; i
< nargs
; i
++)
1141 CHECK_STRING (tem
, i
);
1142 len
+= STRING_BYTES (XSTRING (tem
)) + 1; /* count the blank */
1144 new_argv
= (unsigned char *) alloca (len
);
1145 strcpy (new_argv
, XSTRING (program
)->data
);
1146 for (i
= 3; i
< nargs
; i
++)
1149 CHECK_STRING (tem
, i
);
1150 strcat (new_argv
, " ");
1151 strcat (new_argv
, XSTRING (tem
)->data
);
1153 /* Need to add code here to check for program existence on VMS */
1156 new_argv
= (unsigned char **) alloca ((nargs
- 1) * sizeof (char *));
1158 /* If program file name is not absolute, search our path for it */
1159 if (!IS_DIRECTORY_SEP (XSTRING (program
)->data
[0])
1160 && !(XSTRING (program
)->size
> 1
1161 && IS_DEVICE_SEP (XSTRING (program
)->data
[1])))
1163 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1166 GCPRO4 (name
, program
, buffer
, current_dir
);
1167 openp (Vexec_path
, program
, EXEC_SUFFIXES
, &tem
, 1);
1170 report_file_error ("Searching for program", Fcons (program
, Qnil
));
1171 tem
= Fexpand_file_name (tem
, Qnil
);
1172 new_argv
[0] = XSTRING (tem
)->data
;
1176 if (!NILP (Ffile_directory_p (program
)))
1177 error ("Specified program for new process is a directory");
1179 new_argv
[0] = XSTRING (program
)->data
;
1182 for (i
= 3; i
< nargs
; i
++)
1185 CHECK_STRING (tem
, i
);
1186 new_argv
[i
- 2] = XSTRING (tem
)->data
;
1188 new_argv
[i
- 2] = 0;
1189 #endif /* not VMS */
1191 proc
= make_process (name
);
1192 /* If an error occurs and we can't start the process, we want to
1193 remove it from the process list. This means that each error
1194 check in create_process doesn't need to call remove_process
1195 itself; it's all taken care of here. */
1196 record_unwind_protect (start_process_unwind
, proc
);
1198 XPROCESS (proc
)->childp
= Qt
;
1199 XPROCESS (proc
)->command_channel_p
= Qnil
;
1200 XPROCESS (proc
)->buffer
= buffer
;
1201 XPROCESS (proc
)->sentinel
= Qnil
;
1202 XPROCESS (proc
)->filter
= Qnil
;
1203 XPROCESS (proc
)->command
= Flist (nargs
- 2, args
+ 2);
1205 /* Make the process marker point into the process buffer (if any). */
1207 set_marker_both (XPROCESS (proc
)->mark
, buffer
,
1208 BUF_ZV (XBUFFER (buffer
)),
1209 BUF_ZV_BYTE (XBUFFER (buffer
)));
1212 /* Decide coding systems for communicating with the process. Here
1213 we don't setup the structure coding_system nor pay attention to
1214 unibyte mode. They are done in create_process. */
1216 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
1217 Lisp_Object coding_systems
= Qt
;
1218 Lisp_Object val
, *args2
;
1219 struct gcpro gcpro1
;
1221 val
= Vcoding_system_for_read
;
1224 args2
= (Lisp_Object
*) alloca ((nargs
+ 1) * sizeof *args2
);
1225 args2
[0] = Qstart_process
;
1226 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
1228 coding_systems
= Ffind_operation_coding_system (nargs
+ 1, args2
);
1230 if (CONSP (coding_systems
))
1231 val
= XCAR (coding_systems
);
1232 else if (CONSP (Vdefault_process_coding_system
))
1233 val
= XCAR (Vdefault_process_coding_system
);
1235 XPROCESS (proc
)->decode_coding_system
= val
;
1237 val
= Vcoding_system_for_write
;
1240 if (EQ (coding_systems
, Qt
))
1242 args2
= (Lisp_Object
*) alloca ((nargs
+ 1) * sizeof args2
);
1243 args2
[0] = Qstart_process
;
1244 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
1246 coding_systems
= Ffind_operation_coding_system (nargs
+ 1, args2
);
1249 if (CONSP (coding_systems
))
1250 val
= XCDR (coding_systems
);
1251 else if (CONSP (Vdefault_process_coding_system
))
1252 val
= XCDR (Vdefault_process_coding_system
);
1254 XPROCESS (proc
)->encode_coding_system
= val
;
1257 XPROCESS (proc
)->decoding_buf
= make_uninit_string (0);
1258 XPROCESS (proc
)->decoding_carryover
= make_number (0);
1259 XPROCESS (proc
)->encoding_buf
= make_uninit_string (0);
1260 XPROCESS (proc
)->encoding_carryover
= make_number (0);
1262 XPROCESS (proc
)->inherit_coding_system_flag
1263 = (NILP (buffer
) || !inherit_process_coding_system
1266 create_process (proc
, (char **) new_argv
, current_dir
);
1268 return unbind_to (count
, proc
);
1271 /* This function is the unwind_protect form for Fstart_process. If
1272 PROC doesn't have its pid set, then we know someone has signaled
1273 an error and the process wasn't started successfully, so we should
1274 remove it from the process list. */
1276 start_process_unwind (proc
)
1279 if (!PROCESSP (proc
))
1282 /* Was PROC started successfully? */
1283 if (XINT (XPROCESS (proc
)->pid
) <= 0)
1284 remove_process (proc
);
1291 create_process_1 (signo
)
1294 #if defined (USG) && !defined (POSIX_SIGNALS)
1295 /* USG systems forget handlers when they are used;
1296 must reestablish each time */
1297 signal (signo
, create_process_1
);
1301 #if 0 /* This doesn't work; see the note before sigchld_handler. */
1304 /* Mimic blocking of signals on system V, which doesn't really have it. */
1306 /* Nonzero means we got a SIGCHLD when it was supposed to be blocked. */
1307 int sigchld_deferred
;
1310 create_process_sigchld ()
1312 signal (SIGCHLD
, create_process_sigchld
);
1314 sigchld_deferred
= 1;
1320 #ifndef VMS /* VMS version of this function is in vmsproc.c. */
1322 create_process (process
, new_argv
, current_dir
)
1323 Lisp_Object process
;
1325 Lisp_Object current_dir
;
1327 int pid
, inchannel
, outchannel
;
1329 #ifdef POSIX_SIGNALS
1332 struct sigaction sigint_action
;
1333 struct sigaction sigquit_action
;
1335 struct sigaction sighup_action
;
1337 #else /* !POSIX_SIGNALS */
1340 SIGTYPE (*sigchld
)();
1343 #endif /* !POSIX_SIGNALS */
1344 /* Use volatile to protect variables from being clobbered by longjmp. */
1345 volatile int forkin
, forkout
;
1346 volatile int pty_flag
= 0;
1347 extern char **environ
;
1348 Lisp_Object buffer
= XPROCESS (process
)->buffer
;
1350 inchannel
= outchannel
= -1;
1353 if (!NILP (Vprocess_connection_type
))
1354 outchannel
= inchannel
= allocate_pty ();
1359 /* On USG systems it does not work to open the pty's tty here
1360 and then close and reopen it in the child. */
1362 /* Don't let this terminal become our controlling terminal
1363 (in case we don't have one). */
1364 forkout
= forkin
= open (pty_name
, O_RDWR
| O_NOCTTY
, 0);
1366 forkout
= forkin
= open (pty_name
, O_RDWR
, 0);
1369 report_file_error ("Opening pty", Qnil
);
1371 forkin
= forkout
= -1;
1372 #endif /* not USG */
1376 #endif /* HAVE_PTYS */
1379 if (socketpair (AF_UNIX
, SOCK_STREAM
, 0, sv
) < 0)
1380 report_file_error ("Opening socketpair", Qnil
);
1381 outchannel
= inchannel
= sv
[0];
1382 forkout
= forkin
= sv
[1];
1384 #else /* not SKTPAIR */
1389 report_file_error ("Creating pipe", Qnil
);
1397 report_file_error ("Creating pipe", Qnil
);
1402 #endif /* not SKTPAIR */
1405 /* Replaced by close_process_descs */
1406 set_exclusive_use (inchannel
);
1407 set_exclusive_use (outchannel
);
1410 /* Stride people say it's a mystery why this is needed
1411 as well as the O_NDELAY, but that it fails without this. */
1412 #if defined (STRIDE) || (defined (pfa) && defined (HAVE_PTYS))
1415 ioctl (inchannel
, FIONBIO
, &one
);
1420 fcntl (inchannel
, F_SETFL
, O_NONBLOCK
);
1421 fcntl (outchannel
, F_SETFL
, O_NONBLOCK
);
1424 fcntl (inchannel
, F_SETFL
, O_NDELAY
);
1425 fcntl (outchannel
, F_SETFL
, O_NDELAY
);
1429 /* Record this as an active process, with its channels.
1430 As a result, child_setup will close Emacs's side of the pipes. */
1431 chan_process
[inchannel
] = process
;
1432 XSETINT (XPROCESS (process
)->infd
, inchannel
);
1433 XSETINT (XPROCESS (process
)->outfd
, outchannel
);
1434 /* Record the tty descriptor used in the subprocess. */
1436 XPROCESS (process
)->subtty
= Qnil
;
1438 XSETFASTINT (XPROCESS (process
)->subtty
, forkin
);
1439 XPROCESS (process
)->pty_flag
= (pty_flag
? Qt
: Qnil
);
1440 XPROCESS (process
)->status
= Qrun
;
1441 if (!proc_decode_coding_system
[inchannel
])
1442 proc_decode_coding_system
[inchannel
]
1443 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
1444 setup_coding_system (XPROCESS (process
)->decode_coding_system
,
1445 proc_decode_coding_system
[inchannel
]);
1446 if (!proc_encode_coding_system
[outchannel
])
1447 proc_encode_coding_system
[outchannel
]
1448 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
1449 setup_coding_system (XPROCESS (process
)->encode_coding_system
,
1450 proc_encode_coding_system
[outchannel
]);
1452 if ((!NILP (buffer
) && NILP (XBUFFER (buffer
)->enable_multibyte_characters
))
1453 || (NILP (buffer
) && NILP (buffer_defaults
.enable_multibyte_characters
)))
1455 /* In unibyte mode, character code conversion should not take
1456 place but EOL conversion should. So, setup raw-text or one
1457 of the subsidiary according to the information just setup. */
1458 if (!NILP (XPROCESS (process
)->decode_coding_system
))
1459 setup_raw_text_coding_system (proc_decode_coding_system
[inchannel
]);
1460 if (!NILP (XPROCESS (process
)->encode_coding_system
))
1461 setup_raw_text_coding_system (proc_encode_coding_system
[outchannel
]);
1464 if (CODING_REQUIRE_ENCODING (proc_encode_coding_system
[outchannel
]))
1466 /* Here we encode arguments by the coding system used for
1467 sending data to the process. We don't support using
1468 different coding systems for encoding arguments and for
1469 encoding data sent to the process. */
1470 struct gcpro gcpro1
;
1472 struct coding_system
*coding
= proc_encode_coding_system
[outchannel
];
1474 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
1476 while (new_argv
[i
] != 0)
1478 int len
= strlen (new_argv
[i
]);
1479 int size
= encoding_buffer_size (coding
, len
);
1480 unsigned char *buf
= (unsigned char *) alloca (size
);
1482 encode_coding (coding
, (unsigned char *)new_argv
[i
], buf
, len
, size
);
1483 buf
[coding
->produced
] = 0;
1484 /* We don't have to free new_argv[i] because it points to a
1485 Lisp string given as an argument to `start-process'. */
1486 new_argv
[i
++] = (char *) buf
;
1489 coding
->mode
&= ~CODING_MODE_LAST_BLOCK
;
1492 /* Delay interrupts until we have a chance to store
1493 the new fork's pid in its process structure */
1494 #ifdef POSIX_SIGNALS
1495 sigemptyset (&blocked
);
1497 sigaddset (&blocked
, SIGCHLD
);
1500 /* On many hosts (e.g. Solaris 2.4), if a vforked child calls `signal',
1501 this sets the parent's signal handlers as well as the child's.
1502 So delay all interrupts whose handlers the child might munge,
1503 and record the current handlers so they can be restored later. */
1504 sigaddset (&blocked
, SIGINT
); sigaction (SIGINT
, 0, &sigint_action
);
1505 sigaddset (&blocked
, SIGQUIT
); sigaction (SIGQUIT
, 0, &sigquit_action
);
1507 sigaddset (&blocked
, SIGHUP
); sigaction (SIGHUP
, 0, &sighup_action
);
1509 #endif /* HAVE_VFORK */
1510 sigprocmask (SIG_BLOCK
, &blocked
, &procmask
);
1511 #else /* !POSIX_SIGNALS */
1515 #else /* not BSD4_1 */
1516 #if defined (BSD_SYSTEM) || defined (UNIPLUS) || defined (HPUX)
1517 sigsetmask (sigmask (SIGCHLD
));
1518 #else /* ordinary USG */
1520 sigchld_deferred
= 0;
1521 sigchld
= signal (SIGCHLD
, create_process_sigchld
);
1523 #endif /* ordinary USG */
1524 #endif /* not BSD4_1 */
1525 #endif /* SIGCHLD */
1526 #endif /* !POSIX_SIGNALS */
1528 FD_SET (inchannel
, &input_wait_mask
);
1529 FD_SET (inchannel
, &non_keyboard_wait_mask
);
1530 if (inchannel
> max_process_desc
)
1531 max_process_desc
= inchannel
;
1533 /* Until we store the proper pid, enable sigchld_handler
1534 to recognize an unknown pid as standing for this process.
1535 It is very important not to let this `marker' value stay
1536 in the table after this function has returned; if it does
1537 it might cause call-process to hang and subsequent asynchronous
1538 processes to get their return values scrambled. */
1539 XSETINT (XPROCESS (process
)->pid
, -1);
1544 /* child_setup must clobber environ on systems with true vfork.
1545 Protect it from permanent change. */
1546 char **save_environ
= environ
;
1548 current_dir
= ENCODE_FILE (current_dir
);
1553 #endif /* not WINDOWSNT */
1555 int xforkin
= forkin
;
1556 int xforkout
= forkout
;
1558 #if 0 /* This was probably a mistake--it duplicates code later on,
1559 but fails to handle all the cases. */
1560 /* Make sure SIGCHLD is not blocked in the child. */
1561 sigsetmask (SIGEMPTYMASK
);
1564 /* Make the pty be the controlling terminal of the process. */
1566 /* First, disconnect its current controlling terminal. */
1568 /* We tried doing setsid only if pty_flag, but it caused
1569 process_set_signal to fail on SGI when using a pipe. */
1571 /* Make the pty's terminal the controlling terminal. */
1575 /* We ignore the return value
1576 because faith@cs.unc.edu says that is necessary on Linux. */
1577 ioctl (xforkin
, TIOCSCTTY
, 0);
1580 #else /* not HAVE_SETSID */
1582 /* It's very important to call setpgrp here and no time
1583 afterwards. Otherwise, we lose our controlling tty which
1584 is set when we open the pty. */
1587 #endif /* not HAVE_SETSID */
1588 #if defined (HAVE_TERMIOS) && defined (LDISC1)
1589 if (pty_flag
&& xforkin
>= 0)
1592 tcgetattr (xforkin
, &t
);
1594 if (tcsetattr (xforkin
, TCSANOW
, &t
) < 0)
1595 write (1, "create_process/tcsetattr LDISC1 failed\n", 39);
1598 #if defined (NTTYDISC) && defined (TIOCSETD)
1599 if (pty_flag
&& xforkin
>= 0)
1601 /* Use new line discipline. */
1602 int ldisc
= NTTYDISC
;
1603 ioctl (xforkin
, TIOCSETD
, &ldisc
);
1608 /* In 4.3BSD, the TIOCSPGRP bug has been fixed, and now you
1609 can do TIOCSPGRP only to the process's controlling tty. */
1612 /* I wonder: would just ioctl (0, TIOCNOTTY, 0) work here?
1613 I can't test it since I don't have 4.3. */
1614 int j
= open ("/dev/tty", O_RDWR
, 0);
1615 ioctl (j
, TIOCNOTTY
, 0);
1618 /* In order to get a controlling terminal on some versions
1619 of BSD, it is necessary to put the process in pgrp 0
1620 before it opens the terminal. */
1628 #endif /* TIOCNOTTY */
1630 #if !defined (RTU) && !defined (UNIPLUS) && !defined (DONT_REOPEN_PTY)
1631 /*** There is a suggestion that this ought to be a
1632 conditional on TIOCSPGRP,
1633 or !(defined (HAVE_SETSID) && defined (TIOCSCTTY)).
1634 Trying the latter gave the wrong results on Debian GNU/Linux 1.1;
1635 that system does seem to need this code, even though
1636 both HAVE_SETSID and TIOCSCTTY are defined. */
1637 /* Now close the pty (if we had it open) and reopen it.
1638 This makes the pty the controlling terminal of the subprocess. */
1641 #ifdef SET_CHILD_PTY_PGRP
1642 int pgrp
= getpid ();
1645 /* I wonder if close (open (pty_name, ...)) would work? */
1648 xforkout
= xforkin
= open (pty_name
, O_RDWR
, 0);
1652 write (1, "Couldn't open the pty terminal ", 31);
1653 write (1, pty_name
, strlen (pty_name
));
1658 #ifdef SET_CHILD_PTY_PGRP
1659 ioctl (xforkin
, TIOCSPGRP
, &pgrp
);
1660 ioctl (xforkout
, TIOCSPGRP
, &pgrp
);
1663 #endif /* not UNIPLUS and not RTU and not DONT_REOPEN_PTY */
1665 #ifdef SETUP_SLAVE_PTY
1670 #endif /* SETUP_SLAVE_PTY */
1672 /* On AIX, we've disabled SIGHUP above once we start a child on a pty.
1673 Now reenable it in the child, so it will die when we want it to. */
1675 signal (SIGHUP
, SIG_DFL
);
1677 #endif /* HAVE_PTYS */
1679 signal (SIGINT
, SIG_DFL
);
1680 signal (SIGQUIT
, SIG_DFL
);
1682 /* Stop blocking signals in the child. */
1683 #ifdef POSIX_SIGNALS
1684 sigprocmask (SIG_SETMASK
, &procmask
, 0);
1685 #else /* !POSIX_SIGNALS */
1689 #else /* not BSD4_1 */
1690 #if defined (BSD_SYSTEM) || defined (UNIPLUS) || defined (HPUX)
1691 sigsetmask (SIGEMPTYMASK
);
1692 #else /* ordinary USG */
1694 signal (SIGCHLD
, sigchld
);
1696 #endif /* ordinary USG */
1697 #endif /* not BSD4_1 */
1698 #endif /* SIGCHLD */
1699 #endif /* !POSIX_SIGNALS */
1702 child_setup_tty (xforkout
);
1704 pid
= child_setup (xforkin
, xforkout
, xforkout
,
1705 new_argv
, 1, current_dir
);
1706 #else /* not WINDOWSNT */
1707 child_setup (xforkin
, xforkout
, xforkout
,
1708 new_argv
, 1, current_dir
);
1709 #endif /* not WINDOWSNT */
1711 environ
= save_environ
;
1716 /* This runs in the Emacs process. */
1721 if (forkin
!= forkout
&& forkout
>= 0)
1726 /* vfork succeeded. */
1727 XSETFASTINT (XPROCESS (process
)->pid
, pid
);
1730 register_child (pid
, inchannel
);
1731 #endif /* WINDOWSNT */
1733 /* If the subfork execv fails, and it exits,
1734 this close hangs. I don't know why.
1735 So have an interrupt jar it loose. */
1737 signal (SIGALRM
, create_process_1
);
1739 XPROCESS (process
)->subtty
= Qnil
;
1744 if (forkin
!= forkout
&& forkout
>= 0)
1749 XPROCESS (process
)->tty_name
= build_string (pty_name
);
1752 XPROCESS (process
)->tty_name
= Qnil
;
1755 /* Restore the signal state whether vfork succeeded or not.
1756 (We will signal an error, below, if it failed.) */
1757 #ifdef POSIX_SIGNALS
1759 /* Restore the parent's signal handlers. */
1760 sigaction (SIGINT
, &sigint_action
, 0);
1761 sigaction (SIGQUIT
, &sigquit_action
, 0);
1763 sigaction (SIGHUP
, &sighup_action
, 0);
1765 #endif /* HAVE_VFORK */
1766 /* Stop blocking signals in the parent. */
1767 sigprocmask (SIG_SETMASK
, &procmask
, 0);
1768 #else /* !POSIX_SIGNALS */
1772 #else /* not BSD4_1 */
1773 #if defined (BSD_SYSTEM) || defined (UNIPLUS) || defined (HPUX)
1774 sigsetmask (SIGEMPTYMASK
);
1775 #else /* ordinary USG */
1777 signal (SIGCHLD
, sigchld
);
1778 /* Now really handle any of these signals
1779 that came in during this function. */
1780 if (sigchld_deferred
)
1781 kill (getpid (), SIGCHLD
);
1783 #endif /* ordinary USG */
1784 #endif /* not BSD4_1 */
1785 #endif /* SIGCHLD */
1786 #endif /* !POSIX_SIGNALS */
1788 /* Now generate the error if vfork failed. */
1790 report_file_error ("Doing vfork", Qnil
);
1792 #endif /* not VMS */
1796 /* open a TCP network connection to a given HOST/SERVICE. Treated
1797 exactly like a normal process when reading and writing. Only
1798 differences are in status display and process deletion. A network
1799 connection has no PID; you cannot signal it. All you can do is
1800 deactivate and close it via delete-process */
1802 DEFUN ("open-network-stream", Fopen_network_stream
, Sopen_network_stream
,
1804 "Open a TCP connection for a service to a host.\n\
1805 Returns a subprocess-object to represent the connection.\n\
1806 Input and output work as for subprocesses; `delete-process' closes it.\n\
1807 Args are NAME BUFFER HOST SERVICE.\n\
1808 NAME is name for process. It is modified if necessary to make it unique.\n\
1809 BUFFER is the buffer (or buffer-name) to associate with the process.\n\
1810 Process output goes at end of that buffer, unless you specify\n\
1811 an output stream or filter function to handle the output.\n\
1812 BUFFER may be also nil, meaning that this process is not associated\n\
1814 Third arg is name of the host to connect to, or its IP address.\n\
1815 Fourth arg SERVICE is name of the service desired, or an integer\n\
1816 specifying a port number to connect to.")
1817 (name
, buffer
, host
, service
)
1818 Lisp_Object name
, buffer
, host
, service
;
1821 #ifndef HAVE_GETADDRINFO
1822 struct sockaddr_in address
;
1823 struct servent
*svc_info
;
1824 struct hostent
*host_info_ptr
, host_info
;
1825 char *(addr_list
[2]);
1826 IN_ADDR numeric_addr
;
1828 #else /* HAVE_GETADDRINFO */
1829 struct addrinfo hints
, *res
, *lres
;
1832 char *portstring
, portbuf
[128];
1833 #endif /* HAVE_GETADDRINFO */
1834 int s
= -1, outch
, inch
;
1835 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1837 int count
= specpdl_ptr
- specpdl
;
1841 /* Ensure socket support is loaded if available. */
1842 init_winsock (TRUE
);
1845 GCPRO4 (name
, buffer
, host
, service
);
1846 CHECK_STRING (name
, 0);
1847 CHECK_STRING (host
, 0);
1849 #ifdef HAVE_GETADDRINFO
1851 * SERVICE can either be a string or int.
1852 * Convert to a C string for later use by getaddrinfo.
1854 if (INTEGERP (service
))
1856 sprintf (portbuf
, "%d", XINT (service
));
1857 portstring
= portbuf
;
1861 CHECK_STRING (service
, 0);
1862 portstring
= XSTRING (service
)->data
;
1864 #else /* ! HAVE_GETADDRINFO */
1865 if (INTEGERP (service
))
1866 port
= htons ((unsigned short) XINT (service
));
1869 CHECK_STRING (service
, 0);
1870 svc_info
= getservbyname (XSTRING (service
)->data
, "tcp");
1872 error ("Unknown service \"%s\"", XSTRING (service
)->data
);
1873 port
= svc_info
->s_port
;
1875 #endif /* ! HAVE_GETADDRINFO */
1878 /* Slow down polling to every ten seconds.
1879 Some kernels have a bug which causes retrying connect to fail
1880 after a connect. Polling can interfere with gethostbyname too. */
1881 #ifdef POLL_FOR_INPUT
1882 bind_polling_period (10);
1886 #ifdef HAVE_GETADDRINFO
1890 memset (&hints
, 0, sizeof (hints
));
1892 hints
.ai_family
= AF_UNSPEC
;
1893 hints
.ai_socktype
= SOCK_STREAM
;
1894 hints
.ai_protocol
= 0;
1895 ret
= getaddrinfo (XSTRING (host
)->data
, portstring
, &hints
, &res
);
1898 error ("%s/%s %s", XSTRING (host
)->data
, portstring
,
1905 count1
= specpdl_ptr
- specpdl
;
1906 record_unwind_protect (close_file_unwind
, make_number (s
));
1908 for (lres
= res
; lres
; lres
= lres
->ai_next
)
1910 s
= socket (lres
->ai_family
, lres
->ai_socktype
, lres
->ai_protocol
);
1914 /* Kernel bugs (on Ultrix at least) cause lossage (not just EINTR)
1915 when connect is interrupted. So let's not let it get interrupted.
1916 Note we do not turn off polling, because polling is only used
1917 when not interrupt_input, and thus not normally used on the systems
1918 which have this bug. On systems which use polling, there's no way
1919 to quit if polling is turned off. */
1920 if (interrupt_input
)
1926 ret
= connect (s
, lres
->ai_addr
, lres
->ai_addrlen
);
1936 if (interrupt_input
)
1940 report_file_error ("connection failed",
1941 Fcons (host
, Fcons (name
, Qnil
)));
1943 #else /* ! HAVE_GETADDRINFO */
1952 host_info_ptr
= gethostbyname (XSTRING (host
)->data
);
1955 if (! (host_info_ptr
== 0 && h_errno
== TRY_AGAIN
))
1958 Fsleep_for (make_number (1), Qnil
);
1960 if (host_info_ptr
== 0)
1961 /* Attempt to interpret host as numeric inet address */
1963 numeric_addr
= inet_addr ((char *) XSTRING (host
)->data
);
1964 if (NUMERIC_ADDR_ERROR
)
1965 error ("Unknown host \"%s\"", XSTRING (host
)->data
);
1967 host_info_ptr
= &host_info
;
1968 host_info
.h_name
= 0;
1969 host_info
.h_aliases
= 0;
1970 host_info
.h_addrtype
= AF_INET
;
1972 /* Older machines have only one address slot called h_addr.
1973 Newer machines have h_addr_list, but #define h_addr to
1974 be its first element. */
1975 host_info
.h_addr_list
= &(addr_list
[0]);
1977 host_info
.h_addr
= (char*)(&numeric_addr
);
1979 /* numeric_addr isn't null-terminated; it has fixed length. */
1980 host_info
.h_length
= sizeof (numeric_addr
);
1983 bzero (&address
, sizeof address
);
1984 bcopy (host_info_ptr
->h_addr
, (char *) &address
.sin_addr
,
1985 host_info_ptr
->h_length
);
1986 address
.sin_family
= host_info_ptr
->h_addrtype
;
1987 address
.sin_port
= port
;
1989 s
= socket (host_info_ptr
->h_addrtype
, SOCK_STREAM
, 0);
1991 report_file_error ("error creating socket", Fcons (name
, Qnil
));
1993 count1
= specpdl_ptr
- specpdl
;
1994 record_unwind_protect (close_file_unwind
, make_number (s
));
1996 /* Kernel bugs (on Ultrix at least) cause lossage (not just EINTR)
1997 when connect is interrupted. So let's not let it get interrupted.
1998 Note we do not turn off polling, because polling is only used
1999 when not interrupt_input, and thus not normally used on the systems
2000 which have this bug. On systems which use polling, there's no way
2001 to quit if polling is turned off. */
2002 if (interrupt_input
)
2010 if (connect (s
, (struct sockaddr
*) &address
, sizeof address
) == -1
2011 && errno
!= EISCONN
)
2019 if (errno
== EADDRINUSE
&& retry
< 20)
2021 /* A delay here is needed on some FreeBSD systems,
2022 and it is harmless, since this retrying takes time anyway
2023 and should be infrequent. */
2024 Fsleep_for (make_number (1), Qnil
);
2029 /* Discard the unwind protect. */
2030 specpdl_ptr
= specpdl
+ count1
;
2034 if (interrupt_input
)
2038 report_file_error ("connection failed",
2039 Fcons (host
, Fcons (name
, Qnil
)));
2041 #endif /* ! HAVE_GETADDRINFO */
2045 /* Discard the unwind protect. */
2046 specpdl_ptr
= specpdl
+ count1
;
2048 #ifdef POLL_FOR_INPUT
2049 unbind_to (count
, Qnil
);
2052 if (interrupt_input
)
2056 s
= connect_server (0);
2058 report_file_error ("error creating socket", Fcons (name
, Qnil
));
2059 send_command (s
, C_PORT
, 0, "%s:%d", XSTRING (host
)->data
, ntohs (port
));
2060 send_command (s
, C_DUMB
, 1, 0);
2067 buffer
= Fget_buffer_create (buffer
);
2068 proc
= make_process (name
);
2070 chan_process
[inch
] = proc
;
2073 fcntl (inch
, F_SETFL
, O_NONBLOCK
);
2076 fcntl (inch
, F_SETFL
, O_NDELAY
);
2080 XPROCESS (proc
)->childp
= Fcons (host
, Fcons (service
, Qnil
));
2081 XPROCESS (proc
)->command_channel_p
= Qnil
;
2082 XPROCESS (proc
)->buffer
= buffer
;
2083 XPROCESS (proc
)->sentinel
= Qnil
;
2084 XPROCESS (proc
)->filter
= Qnil
;
2085 XPROCESS (proc
)->command
= Qnil
;
2086 XPROCESS (proc
)->pid
= Qnil
;
2087 XSETINT (XPROCESS (proc
)->infd
, inch
);
2088 XSETINT (XPROCESS (proc
)->outfd
, outch
);
2089 XPROCESS (proc
)->status
= Qrun
;
2090 FD_SET (inch
, &input_wait_mask
);
2091 FD_SET (inch
, &non_keyboard_wait_mask
);
2092 if (inch
> max_process_desc
)
2093 max_process_desc
= inch
;
2096 /* Setup coding systems for communicating with the network stream. */
2097 struct gcpro gcpro1
;
2098 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
2099 Lisp_Object coding_systems
= Qt
;
2100 Lisp_Object args
[5], val
;
2102 if (!NILP (Vcoding_system_for_read
))
2103 val
= Vcoding_system_for_read
;
2104 else if ((!NILP (buffer
) && NILP (XBUFFER (buffer
)->enable_multibyte_characters
))
2105 || (NILP (buffer
) && NILP (buffer_defaults
.enable_multibyte_characters
)))
2106 /* We dare not decode end-of-line format by setting VAL to
2107 Qraw_text, because the existing Emacs Lisp libraries
2108 assume that they receive bare code including a sequene of
2113 args
[0] = Qopen_network_stream
, args
[1] = name
,
2114 args
[2] = buffer
, args
[3] = host
, args
[4] = service
;
2116 coding_systems
= Ffind_operation_coding_system (5, args
);
2118 if (CONSP (coding_systems
))
2119 val
= XCAR (coding_systems
);
2120 else if (CONSP (Vdefault_process_coding_system
))
2121 val
= XCAR (Vdefault_process_coding_system
);
2125 XPROCESS (proc
)->decode_coding_system
= val
;
2127 if (!NILP (Vcoding_system_for_write
))
2128 val
= Vcoding_system_for_write
;
2129 else if (NILP (current_buffer
->enable_multibyte_characters
))
2133 if (EQ (coding_systems
, Qt
))
2135 args
[0] = Qopen_network_stream
, args
[1] = name
,
2136 args
[2] = buffer
, args
[3] = host
, args
[4] = service
;
2138 coding_systems
= Ffind_operation_coding_system (5, args
);
2141 if (CONSP (coding_systems
))
2142 val
= XCDR (coding_systems
);
2143 else if (CONSP (Vdefault_process_coding_system
))
2144 val
= XCDR (Vdefault_process_coding_system
);
2148 XPROCESS (proc
)->encode_coding_system
= val
;
2151 if (!proc_decode_coding_system
[inch
])
2152 proc_decode_coding_system
[inch
]
2153 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
2154 setup_coding_system (XPROCESS (proc
)->decode_coding_system
,
2155 proc_decode_coding_system
[inch
]);
2156 if (!proc_encode_coding_system
[outch
])
2157 proc_encode_coding_system
[outch
]
2158 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
2159 setup_coding_system (XPROCESS (proc
)->encode_coding_system
,
2160 proc_encode_coding_system
[outch
]);
2162 XPROCESS (proc
)->decoding_buf
= make_uninit_string (0);
2163 XPROCESS (proc
)->decoding_carryover
= make_number (0);
2164 XPROCESS (proc
)->encoding_buf
= make_uninit_string (0);
2165 XPROCESS (proc
)->encoding_carryover
= make_number (0);
2167 XPROCESS (proc
)->inherit_coding_system_flag
2168 = (NILP (buffer
) || !inherit_process_coding_system
2174 #endif /* HAVE_SOCKETS */
2177 deactivate_process (proc
)
2180 register int inchannel
, outchannel
;
2181 register struct Lisp_Process
*p
= XPROCESS (proc
);
2183 inchannel
= XINT (p
->infd
);
2184 outchannel
= XINT (p
->outfd
);
2188 /* Beware SIGCHLD hereabouts. */
2189 flush_pending_output (inchannel
);
2192 VMS_PROC_STUFF
*get_vms_process_pointer (), *vs
;
2193 sys$
dassgn (outchannel
);
2194 vs
= get_vms_process_pointer (p
->pid
);
2196 give_back_vms_process_stuff (vs
);
2200 if (outchannel
>= 0 && outchannel
!= inchannel
)
2204 XSETINT (p
->infd
, -1);
2205 XSETINT (p
->outfd
, -1);
2206 chan_process
[inchannel
] = Qnil
;
2207 FD_CLR (inchannel
, &input_wait_mask
);
2208 FD_CLR (inchannel
, &non_keyboard_wait_mask
);
2209 if (inchannel
== max_process_desc
)
2212 /* We just closed the highest-numbered process input descriptor,
2213 so recompute the highest-numbered one now. */
2214 max_process_desc
= 0;
2215 for (i
= 0; i
< MAXDESC
; i
++)
2216 if (!NILP (chan_process
[i
]))
2217 max_process_desc
= i
;
2222 /* Close all descriptors currently in use for communication
2223 with subprocess. This is used in a newly-forked subprocess
2224 to get rid of irrelevant descriptors. */
2227 close_process_descs ()
2231 for (i
= 0; i
< MAXDESC
; i
++)
2233 Lisp_Object process
;
2234 process
= chan_process
[i
];
2235 if (!NILP (process
))
2237 int in
= XINT (XPROCESS (process
)->infd
);
2238 int out
= XINT (XPROCESS (process
)->outfd
);
2241 if (out
>= 0 && in
!= out
)
2248 DEFUN ("accept-process-output", Faccept_process_output
, Saccept_process_output
,
2250 "Allow any pending output from subprocesses to be read by Emacs.\n\
2251 It is read into the process' buffers or given to their filter functions.\n\
2252 Non-nil arg PROCESS means do not return until some output has been received\n\
2254 Non-nil second arg TIMEOUT and third arg TIMEOUT-MSECS are number of\n\
2255 seconds and microseconds to wait; return after that much time whether\n\
2256 or not there is input.\n\
2257 Return non-nil iff we received any output before the timeout expired.")
2258 (process
, timeout
, timeout_msecs
)
2259 register Lisp_Object process
, timeout
, timeout_msecs
;
2264 if (! NILP (process
))
2265 CHECK_PROCESS (process
, 0);
2267 if (! NILP (timeout_msecs
))
2269 CHECK_NUMBER (timeout_msecs
, 2);
2270 useconds
= XINT (timeout_msecs
);
2271 if (!INTEGERP (timeout
))
2272 XSETINT (timeout
, 0);
2275 int carry
= useconds
/ 1000000;
2277 XSETINT (timeout
, XINT (timeout
) + carry
);
2278 useconds
-= carry
* 1000000;
2280 /* I think this clause is necessary because C doesn't
2281 guarantee a particular rounding direction for negative
2285 XSETINT (timeout
, XINT (timeout
) - 1);
2286 useconds
+= 1000000;
2293 if (! NILP (timeout
))
2295 CHECK_NUMBER (timeout
, 1);
2296 seconds
= XINT (timeout
);
2297 if (seconds
< 0 || (seconds
== 0 && useconds
== 0))
2309 XSETFASTINT (process
, 0);
2312 (wait_reading_process_input (seconds
, useconds
, process
, 0)
2316 /* This variable is different from waiting_for_input in keyboard.c.
2317 It is used to communicate to a lisp process-filter/sentinel (via the
2318 function Fwaiting_for_user_input_p below) whether emacs was waiting
2319 for user-input when that process-filter was called.
2320 waiting_for_input cannot be used as that is by definition 0 when
2321 lisp code is being evalled.
2322 This is also used in record_asynch_buffer_change.
2323 For that purpose, this must be 0
2324 when not inside wait_reading_process_input. */
2325 static int waiting_for_user_input_p
;
2327 /* This is here so breakpoints can be put on it. */
2329 wait_reading_process_input_1 ()
2333 /* Read and dispose of subprocess output while waiting for timeout to
2334 elapse and/or keyboard input to be available.
2337 timeout in seconds, or
2338 zero for no limit, or
2339 -1 means gobble data immediately available but don't wait for any.
2342 an additional duration to wait, measured in microseconds.
2343 If this is nonzero and time_limit is 0, then the timeout
2344 consists of MICROSECS only.
2346 READ_KBD is a lisp value:
2347 0 to ignore keyboard input, or
2348 1 to return when input is available, or
2349 -1 meaning caller will actually read the input, so don't throw to
2350 the quit handler, or
2351 a cons cell, meaning wait until its car is non-nil
2352 (and gobble terminal input into the buffer if any arrives), or
2353 a process object, meaning wait until something arrives from that
2354 process. The return value is true iff we read some input from
2357 DO_DISPLAY != 0 means redisplay should be done to show subprocess
2358 output that arrives.
2360 If READ_KBD is a pointer to a struct Lisp_Process, then the
2361 function returns true iff we received input from that process
2362 before the timeout elapsed.
2363 Otherwise, return true iff we received input from any process. */
2366 wait_reading_process_input (time_limit
, microsecs
, read_kbd
, do_display
)
2367 int time_limit
, microsecs
;
2368 Lisp_Object read_kbd
;
2371 register int channel
, nfds
;
2372 static SELECT_TYPE Available
;
2375 EMACS_TIME timeout
, end_time
;
2377 int wait_channel
= -1;
2378 struct Lisp_Process
*wait_proc
= 0;
2379 int got_some_input
= 0;
2380 Lisp_Object
*wait_for_cell
= 0;
2382 FD_ZERO (&Available
);
2384 /* If read_kbd is a process to watch, set wait_proc and wait_channel
2386 if (PROCESSP (read_kbd
))
2388 wait_proc
= XPROCESS (read_kbd
);
2389 wait_channel
= XINT (wait_proc
->infd
);
2390 XSETFASTINT (read_kbd
, 0);
2393 /* If waiting for non-nil in a cell, record where. */
2394 if (CONSP (read_kbd
))
2396 wait_for_cell
= &XCAR (read_kbd
);
2397 XSETFASTINT (read_kbd
, 0);
2400 waiting_for_user_input_p
= XINT (read_kbd
);
2402 /* Since we may need to wait several times,
2403 compute the absolute time to return at. */
2404 if (time_limit
|| microsecs
)
2406 EMACS_GET_TIME (end_time
);
2407 EMACS_SET_SECS_USECS (timeout
, time_limit
, microsecs
);
2408 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
2411 /* AlainF 5-Jul-1996
2412 HP-UX 10.10 seem to have problems with signals coming in
2413 Causes "poll: interrupted system call" messages when Emacs is run
2415 Turn off periodic alarms (in case they are in use) */
2421 int timeout_reduced_for_timers
= 0;
2423 #ifdef HAVE_X_WINDOWS
2424 if (display_busy_cursor_p
)
2425 Fx_hide_busy_cursor (Qnil
);
2428 /* If calling from keyboard input, do not quit
2429 since we want to return C-g as an input character.
2430 Otherwise, do pending quit if requested. */
2431 if (XINT (read_kbd
) >= 0)
2434 /* Exit now if the cell we're waiting for became non-nil. */
2435 if (wait_for_cell
&& ! NILP (*wait_for_cell
))
2438 /* Compute time from now till when time limit is up */
2439 /* Exit if already run out */
2440 if (time_limit
== -1)
2442 /* -1 specified for timeout means
2443 gobble output available now
2444 but don't wait at all. */
2446 EMACS_SET_SECS_USECS (timeout
, 0, 0);
2448 else if (time_limit
|| microsecs
)
2450 EMACS_GET_TIME (timeout
);
2451 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
2452 if (EMACS_TIME_NEG_P (timeout
))
2457 EMACS_SET_SECS_USECS (timeout
, 100000, 0);
2460 /* Normally we run timers here.
2461 But not if wait_for_cell; in those cases,
2462 the wait is supposed to be short,
2463 and those callers cannot handle running arbitrary Lisp code here. */
2464 if (! wait_for_cell
)
2466 EMACS_TIME timer_delay
;
2470 old_timers_run
= timers_run
;
2471 timer_delay
= timer_check (1);
2472 if (timers_run
!= old_timers_run
&& do_display
)
2474 redisplay_preserve_echo_area ();
2475 /* We must retry, since a timer may have requeued itself
2476 and that could alter the time_delay. */
2480 /* If there is unread keyboard input, also return. */
2481 if (XINT (read_kbd
) != 0
2482 && requeued_events_pending_p ())
2485 if (! EMACS_TIME_NEG_P (timer_delay
) && time_limit
!= -1)
2487 EMACS_TIME difference
;
2488 EMACS_SUB_TIME (difference
, timer_delay
, timeout
);
2489 if (EMACS_TIME_NEG_P (difference
))
2491 timeout
= timer_delay
;
2492 timeout_reduced_for_timers
= 1;
2495 /* If time_limit is -1, we are not going to wait at all. */
2496 else if (time_limit
!= -1)
2498 /* This is so a breakpoint can be put here. */
2499 wait_reading_process_input_1 ();
2503 /* Cause C-g and alarm signals to take immediate action,
2504 and cause input available signals to zero out timeout.
2506 It is important that we do this before checking for process
2507 activity. If we get a SIGCHLD after the explicit checks for
2508 process activity, timeout is the only way we will know. */
2509 if (XINT (read_kbd
) < 0)
2510 set_waiting_for_input (&timeout
);
2512 /* If status of something has changed, and no input is
2513 available, notify the user of the change right away. After
2514 this explicit check, we'll let the SIGCHLD handler zap
2515 timeout to get our attention. */
2516 if (update_tick
!= process_tick
&& do_display
)
2518 Atemp
= input_wait_mask
;
2519 EMACS_SET_SECS_USECS (timeout
, 0, 0);
2520 if ((select (max (max_process_desc
, max_keyboard_desc
) + 1,
2521 &Atemp
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0,
2525 /* It's okay for us to do this and then continue with
2526 the loop, since timeout has already been zeroed out. */
2527 clear_waiting_for_input ();
2532 /* Don't wait for output from a non-running process. */
2533 if (wait_proc
!= 0 && !NILP (wait_proc
->raw_status_low
))
2534 update_status (wait_proc
);
2536 && ! EQ (wait_proc
->status
, Qrun
))
2538 int nread
, total_nread
= 0;
2540 clear_waiting_for_input ();
2541 XSETPROCESS (proc
, wait_proc
);
2543 /* Read data from the process, until we exhaust it. */
2544 while (XINT (wait_proc
->infd
) >= 0
2546 = read_process_output (proc
, XINT (wait_proc
->infd
))))
2549 total_nread
+= nread
;
2551 else if (nread
== -1 && EIO
== errno
)
2555 if (total_nread
> 0 && do_display
)
2556 redisplay_preserve_echo_area ();
2561 /* Wait till there is something to do */
2564 Available
= non_process_wait_mask
;
2565 else if (! XINT (read_kbd
))
2566 Available
= non_keyboard_wait_mask
;
2568 Available
= input_wait_mask
;
2570 /* If frame size has changed or the window is newly mapped,
2571 redisplay now, before we start to wait. There is a race
2572 condition here; if a SIGIO arrives between now and the select
2573 and indicates that a frame is trashed, the select may block
2574 displaying a trashed screen. */
2575 if (frame_garbaged
&& do_display
)
2577 clear_waiting_for_input ();
2578 redisplay_preserve_echo_area ();
2579 if (XINT (read_kbd
) < 0)
2580 set_waiting_for_input (&timeout
);
2583 if (XINT (read_kbd
) && detect_input_pending ())
2586 FD_ZERO (&Available
);
2589 nfds
= select (max (max_process_desc
, max_keyboard_desc
) + 1,
2590 &Available
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0,
2595 /* Make C-g and alarm signals set flags again */
2596 clear_waiting_for_input ();
2598 /* If we woke up due to SIGWINCH, actually change size now. */
2599 do_pending_window_change (0);
2601 if (time_limit
&& nfds
== 0 && ! timeout_reduced_for_timers
)
2602 /* We wanted the full specified time, so return now. */
2606 if (xerrno
== EINTR
)
2607 FD_ZERO (&Available
);
2609 /* Ultrix select seems to return ENOMEM when it is
2610 interrupted. Treat it just like EINTR. Bleah. Note
2611 that we want to test for the "ultrix" CPP symbol, not
2612 "__ultrix__"; the latter is only defined under GCC, but
2613 not by DEC's bundled CC. -JimB */
2614 else if (xerrno
== ENOMEM
)
2615 FD_ZERO (&Available
);
2618 /* This happens for no known reason on ALLIANT.
2619 I am guessing that this is the right response. -- RMS. */
2620 else if (xerrno
== EFAULT
)
2621 FD_ZERO (&Available
);
2623 else if (xerrno
== EBADF
)
2626 /* AIX doesn't handle PTY closure the same way BSD does. On AIX,
2627 the child's closure of the pts gives the parent a SIGHUP, and
2628 the ptc file descriptor is automatically closed,
2629 yielding EBADF here or at select() call above.
2630 So, SIGHUP is ignored (see def of PTY_TTY_NAME_SPRINTF
2631 in m/ibmrt-aix.h), and here we just ignore the select error.
2632 Cleanup occurs c/o status_notify after SIGCLD. */
2633 FD_ZERO (&Available
); /* Cannot depend on values returned */
2639 error ("select error: %s", strerror (xerrno
));
2641 #if defined(sun) && !defined(USG5_4)
2642 else if (nfds
> 0 && keyboard_bit_set (&Available
)
2644 /* System sometimes fails to deliver SIGIO.
2646 David J. Mackenzie says that Emacs doesn't compile under
2647 Solaris if this code is enabled, thus the USG5_4 in the CPP
2648 conditional. "I haven't noticed any ill effects so far.
2649 If you find a Solaris expert somewhere, they might know
2651 kill (getpid (), SIGIO
);
2654 #if 0 /* When polling is used, interrupt_input is 0,
2655 so get_input_pending should read the input.
2656 So this should not be needed. */
2657 /* If we are using polling for input,
2658 and we see input available, make it get read now.
2659 Otherwise it might not actually get read for a second.
2660 And on hpux, since we turn off polling in wait_reading_process_input,
2661 it might never get read at all if we don't spend much time
2662 outside of wait_reading_process_input. */
2663 if (XINT (read_kbd
) && interrupt_input
2664 && keyboard_bit_set (&Available
)
2665 && input_polling_used ())
2666 kill (getpid (), SIGALRM
);
2669 /* Check for keyboard input */
2670 /* If there is any, return immediately
2671 to give it higher priority than subprocesses */
2673 if (XINT (read_kbd
) != 0
2674 && detect_input_pending_run_timers (do_display
))
2676 swallow_events (do_display
);
2677 if (detect_input_pending_run_timers (do_display
))
2681 /* If there is unread keyboard input, also return. */
2682 if (XINT (read_kbd
) != 0
2683 && requeued_events_pending_p ())
2686 /* If we are not checking for keyboard input now,
2687 do process events (but don't run any timers).
2688 This is so that X events will be processed.
2689 Otherwise they may have to wait until polling takes place.
2690 That would causes delays in pasting selections, for example.
2692 (We used to do this only if wait_for_cell.) */
2693 if (XINT (read_kbd
) == 0 && detect_input_pending ())
2695 swallow_events (do_display
);
2696 #if 0 /* Exiting when read_kbd doesn't request that seems wrong, though. */
2697 if (detect_input_pending ())
2702 /* Exit now if the cell we're waiting for became non-nil. */
2703 if (wait_for_cell
&& ! NILP (*wait_for_cell
))
2707 /* If we think we have keyboard input waiting, but didn't get SIGIO,
2708 go read it. This can happen with X on BSD after logging out.
2709 In that case, there really is no input and no SIGIO,
2710 but select says there is input. */
2712 if (XINT (read_kbd
) && interrupt_input
2713 && keyboard_bit_set (&Available
))
2714 kill (getpid (), SIGIO
);
2718 got_some_input
|= nfds
> 0;
2720 /* If checking input just got us a size-change event from X,
2721 obey it now if we should. */
2722 if (XINT (read_kbd
) || wait_for_cell
)
2723 do_pending_window_change (0);
2725 /* Check for data from a process. */
2726 /* Really FIRST_PROC_DESC should be 0 on Unix,
2727 but this is safer in the short run. */
2728 for (channel
= 0; channel
<= max_process_desc
; channel
++)
2730 if (FD_ISSET (channel
, &Available
)
2731 && FD_ISSET (channel
, &non_keyboard_wait_mask
))
2735 /* If waiting for this channel, arrange to return as
2736 soon as no more input to be processed. No more
2738 if (wait_channel
== channel
)
2744 proc
= chan_process
[channel
];
2748 /* Read data from the process, starting with our
2749 buffered-ahead character if we have one. */
2751 nread
= read_process_output (proc
, channel
);
2754 /* Since read_process_output can run a filter,
2755 which can call accept-process-output,
2756 don't try to read from any other processes
2757 before doing the select again. */
2758 FD_ZERO (&Available
);
2761 redisplay_preserve_echo_area ();
2764 else if (nread
== -1 && errno
== EWOULDBLOCK
)
2767 /* ISC 4.1 defines both EWOULDBLOCK and O_NONBLOCK,
2768 and Emacs uses O_NONBLOCK, so what we get is EAGAIN. */
2770 else if (nread
== -1 && errno
== EAGAIN
)
2774 else if (nread
== -1 && errno
== EAGAIN
)
2776 /* Note that we cannot distinguish between no input
2777 available now and a closed pipe.
2778 With luck, a closed pipe will be accompanied by
2779 subprocess termination and SIGCHLD. */
2780 else if (nread
== 0 && !NETCONN_P (proc
))
2782 #endif /* O_NDELAY */
2783 #endif /* O_NONBLOCK */
2785 /* On some OSs with ptys, when the process on one end of
2786 a pty exits, the other end gets an error reading with
2787 errno = EIO instead of getting an EOF (0 bytes read).
2788 Therefore, if we get an error reading and errno =
2789 EIO, just continue, because the child process has
2790 exited and should clean itself up soon (e.g. when we
2793 However, it has been known to happen that the SIGCHLD
2794 got lost. So raise the signl again just in case.
2796 else if (nread
== -1 && errno
== EIO
)
2797 kill (getpid (), SIGCHLD
);
2798 #endif /* HAVE_PTYS */
2799 /* If we can detect process termination, don't consider the process
2800 gone just because its pipe is closed. */
2802 else if (nread
== 0 && !NETCONN_P (proc
))
2807 /* Preserve status of processes already terminated. */
2808 XSETINT (XPROCESS (proc
)->tick
, ++process_tick
);
2809 deactivate_process (proc
);
2810 if (!NILP (XPROCESS (proc
)->raw_status_low
))
2811 update_status (XPROCESS (proc
));
2812 if (EQ (XPROCESS (proc
)->status
, Qrun
))
2813 XPROCESS (proc
)->status
2814 = Fcons (Qexit
, Fcons (make_number (256), Qnil
));
2817 } /* end for each file descriptor */
2818 } /* end while exit conditions not met */
2820 waiting_for_user_input_p
= 0;
2822 /* If calling from keyboard input, do not quit
2823 since we want to return C-g as an input character.
2824 Otherwise, do pending quit if requested. */
2825 if (XINT (read_kbd
) >= 0)
2827 /* Prevent input_pending from remaining set if we quit. */
2828 clear_input_pending ();
2832 /* AlainF 5-Jul-1996
2833 HP-UX 10.10 seems to have problems with signals coming in
2834 Causes "poll: interrupted system call" messages when Emacs is run
2836 Turn periodic alarms back on */
2840 #ifdef HAVE_X_WINDOWS
2841 if (display_busy_cursor_p
)
2842 if (!inhibit_busy_cursor
)
2843 Fx_show_busy_cursor ();
2846 return got_some_input
;
2849 /* Given a list (FUNCTION ARGS...), apply FUNCTION to the ARGS. */
2852 read_process_output_call (fun_and_args
)
2853 Lisp_Object fun_and_args
;
2855 return apply1 (XCAR (fun_and_args
), XCDR (fun_and_args
));
2859 read_process_output_error_handler (error
)
2862 cmd_error_internal (error
, "error in process filter: ");
2864 update_echo_area ();
2865 Fsleep_for (make_number (2), Qnil
);
2868 /* Read pending output from the process channel,
2869 starting with our buffered-ahead character if we have one.
2870 Yield number of decoded characters read.
2872 This function reads at most 1024 characters.
2873 If you want to read all available subprocess output,
2874 you must call it repeatedly until it returns zero.
2876 The characters read are decoded according to PROC's coding-system
2880 read_process_output (proc
, channel
)
2882 register int channel
;
2884 register int nchars
, nbytes
;
2887 int chars_allocated
= 0; /* If 1, `chars' should be freed later. */
2891 register Lisp_Object outstream
;
2892 register struct buffer
*old
= current_buffer
;
2893 register struct Lisp_Process
*p
= XPROCESS (proc
);
2894 register int opoint
;
2895 struct coding_system
*coding
= proc_decode_coding_system
[channel
];
2896 int chars_in_decoding_buf
= 0; /* If 1, `chars' points
2897 XSTRING (p->decoding_buf)->data. */
2898 int carryover
= XINT (p
->decoding_carryover
);
2901 VMS_PROC_STUFF
*vs
, *get_vms_process_pointer();
2903 vs
= get_vms_process_pointer (p
->pid
);
2907 return (0); /* Really weird if it does this */
2908 if (!(vs
->iosb
[0] & 1))
2909 return -1; /* I/O error */
2912 error ("Could not get VMS process pointer");
2913 chars
= vs
->inputBuffer
;
2914 nbytes
= clean_vms_buffer (chars
, vs
->iosb
[1]);
2917 start_vms_process_read (vs
); /* Crank up the next read on the process */
2918 return 1; /* Nothing worth printing, say we got 1 */
2922 /* The data carried over in the previous decoding (which are at
2923 the tail of decoding buffer) should be prepended to the new
2924 data read to decode all together. */
2925 char *buf
= (char *) xmalloc (nbytes
+ carryover
);
2927 bcopy (XSTRING (p
->decoding_buf
)->data
2928 + STRING_BYTES (XSTRING (p
->decoding_buf
)) - carryover
,
2930 bcopy (chars
, buf
+ carryover
, nbytes
);
2932 chars_allocated
= 1;
2937 /* See the comment above. */
2938 bcopy (XSTRING (p
->decoding_buf
)->data
2939 + STRING_BYTES (XSTRING (p
->decoding_buf
)) - carryover
,
2942 if (proc_buffered_char
[channel
] < 0)
2943 nbytes
= read (channel
, buf
+ carryover
, (sizeof buf
) - carryover
);
2946 buf
[carryover
] = proc_buffered_char
[channel
];
2947 proc_buffered_char
[channel
] = -1;
2948 nbytes
= read (channel
, buf
+ carryover
+ 1,
2949 (sizeof buf
) - carryover
- 1);
2953 nbytes
= nbytes
+ 1;
2956 #endif /* not VMS */
2958 XSETINT (p
->decoding_carryover
, 0);
2960 /* At this point, NBYTES holds number of characters just received
2961 (including the one in proc_buffered_char[channel]). */
2964 if (nbytes
< 0 || coding
->mode
& CODING_MODE_LAST_BLOCK
)
2966 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
2969 /* Now set NBYTES how many bytes we must decode. */
2970 nbytes
+= carryover
;
2973 if (CODING_MAY_REQUIRE_DECODING (coding
))
2975 int require
= decoding_buffer_size (coding
, nbytes
);
2978 if (STRING_BYTES (XSTRING (p
->decoding_buf
)) < require
)
2979 p
->decoding_buf
= make_uninit_string (require
);
2980 result
= decode_coding (coding
, chars
, XSTRING (p
->decoding_buf
)->data
,
2981 nbytes
, STRING_BYTES (XSTRING (p
->decoding_buf
)));
2982 carryover
= nbytes
- coding
->consumed
;
2985 /* Copy the carryover bytes to the end of p->decoding_buf, to
2986 be processed on the next read. Since decoding_buffer_size
2987 asks for an extra amount of space beyond the maximum
2988 expected for the output, there should always be sufficient
2989 space for the carryover (which is by definition a sequence
2990 of bytes that was not long enough to be decoded, and thus
2991 has a bounded length). */
2992 if (STRING_BYTES (XSTRING (p
->decoding_buf
))
2993 < coding
->produced
+ carryover
)
2995 bcopy (chars
+ coding
->consumed
,
2996 XSTRING (p
->decoding_buf
)->data
2997 + STRING_BYTES (XSTRING (p
->decoding_buf
)) - carryover
,
2999 XSETINT (p
->decoding_carryover
, carryover
);
3002 /* A new coding system might be found by `decode_coding'. */
3003 if (!EQ (p
->decode_coding_system
, coding
->symbol
))
3005 p
->decode_coding_system
= coding
->symbol
;
3007 /* Don't call setup_coding_system for
3008 proc_decode_coding_system[channel] here. It is done in
3009 detect_coding called via decode_coding above. */
3011 /* If a coding system for encoding is not yet decided, we set
3012 it as the same as coding-system for decoding.
3014 But, before doing that we must check if
3015 proc_encode_coding_system[p->outfd] surely points to a
3016 valid memory because p->outfd will be changed once EOF is
3017 sent to the process. */
3018 if (NILP (p
->encode_coding_system
)
3019 && proc_encode_coding_system
[XINT (p
->outfd
)])
3021 p
->encode_coding_system
= coding
->symbol
;
3022 setup_coding_system (coding
->symbol
,
3023 proc_encode_coding_system
[XINT (p
->outfd
)]);
3028 /* Now we don't need the contents of `chars'. */
3029 if (chars_allocated
)
3032 if (coding
->produced
== 0)
3034 chars
= (char *) XSTRING (p
->decoding_buf
)->data
;
3035 nbytes
= coding
->produced
;
3036 nchars
= (coding
->fake_multibyte
3037 ? multibyte_chars_in_text (chars
, nbytes
)
3038 : coding
->produced_char
);
3039 chars_in_decoding_buf
= 1;
3044 if (chars_allocated
)
3046 /* Although we don't have to decode the received data, we
3047 must move it to an area which we don't have to free. */
3048 if (! STRINGP (p
->decoding_buf
)
3049 || STRING_BYTES (XSTRING (p
->decoding_buf
)) < nbytes
)
3050 p
->decoding_buf
= make_uninit_string (nbytes
);
3051 bcopy (chars
, XSTRING (p
->decoding_buf
)->data
, nbytes
);
3053 chars
= XSTRING (p
->decoding_buf
)->data
;
3054 chars_in_decoding_buf
= 1;
3057 nchars
= multibyte_chars_in_text (chars
, nbytes
);
3060 Vlast_coding_system_used
= coding
->symbol
;
3062 /* If the caller required, let the process associated buffer
3063 inherit the coding-system used to decode the process output. */
3064 if (! NILP (p
->inherit_coding_system_flag
)
3065 && !NILP (p
->buffer
) && !NILP (XBUFFER (p
->buffer
)->name
))
3067 struct buffer
*prev_buf
= current_buffer
;
3069 Fset_buffer (p
->buffer
);
3070 call1 (intern ("after-insert-file-set-buffer-file-coding-system"),
3071 make_number (nbytes
));
3072 set_buffer_internal (prev_buf
);
3075 /* Read and dispose of the process output. */
3076 outstream
= p
->filter
;
3077 if (!NILP (outstream
))
3079 /* We inhibit quit here instead of just catching it so that
3080 hitting ^G when a filter happens to be running won't screw
3082 int count
= specpdl_ptr
- specpdl
;
3083 Lisp_Object odeactivate
;
3084 Lisp_Object obuffer
, okeymap
;
3086 int outer_running_asynch_code
= running_asynch_code
;
3087 int waiting
= waiting_for_user_input_p
;
3089 /* No need to gcpro these, because all we do with them later
3090 is test them for EQness, and none of them should be a string. */
3091 odeactivate
= Vdeactivate_mark
;
3092 XSETBUFFER (obuffer
, current_buffer
);
3093 okeymap
= current_buffer
->keymap
;
3095 specbind (Qinhibit_quit
, Qt
);
3096 specbind (Qlast_nonmenu_event
, Qt
);
3098 /* In case we get recursively called,
3099 and we already saved the match data nonrecursively,
3100 save the same match data in safely recursive fashion. */
3101 if (outer_running_asynch_code
)
3104 /* Don't clobber the CURRENT match data, either! */
3105 tem
= Fmatch_data (Qnil
, Qnil
);
3106 restore_match_data ();
3107 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
3108 Fset_match_data (tem
);
3111 /* For speed, if a search happens within this code,
3112 save the match data in a special nonrecursive fashion. */
3113 running_asynch_code
= 1;
3115 /* The multibyteness of a string given to the filter is decided
3116 by which coding system we used for decoding. */
3117 if (coding
->type
== coding_type_no_conversion
3118 || coding
->type
== coding_type_raw_text
)
3119 text
= make_unibyte_string (chars
, nbytes
);
3121 text
= make_multibyte_string (chars
, nchars
, nbytes
);
3123 internal_condition_case_1 (read_process_output_call
,
3125 Fcons (proc
, Fcons (text
, Qnil
))),
3126 !NILP (Vdebug_on_error
) ? Qnil
: Qerror
,
3127 read_process_output_error_handler
);
3129 /* If we saved the match data nonrecursively, restore it now. */
3130 restore_match_data ();
3131 running_asynch_code
= outer_running_asynch_code
;
3133 /* Handling the process output should not deactivate the mark. */
3134 Vdeactivate_mark
= odeactivate
;
3136 /* Restore waiting_for_user_input_p as it was
3137 when we were called, in case the filter clobbered it. */
3138 waiting_for_user_input_p
= waiting
;
3140 #if 0 /* Call record_asynch_buffer_change unconditionally,
3141 because we might have changed minor modes or other things
3142 that affect key bindings. */
3143 if (! EQ (Fcurrent_buffer (), obuffer
)
3144 || ! EQ (current_buffer
->keymap
, okeymap
))
3146 /* But do it only if the caller is actually going to read events.
3147 Otherwise there's no need to make him wake up, and it could
3148 cause trouble (for example it would make Fsit_for return). */
3149 if (waiting_for_user_input_p
== -1)
3150 record_asynch_buffer_change ();
3153 start_vms_process_read (vs
);
3155 unbind_to (count
, Qnil
);
3159 /* If no filter, write into buffer if it isn't dead. */
3160 if (!NILP (p
->buffer
) && !NILP (XBUFFER (p
->buffer
)->name
))
3162 Lisp_Object old_read_only
;
3163 int old_begv
, old_zv
;
3164 int old_begv_byte
, old_zv_byte
;
3165 Lisp_Object odeactivate
;
3166 int before
, before_byte
;
3169 odeactivate
= Vdeactivate_mark
;
3171 Fset_buffer (p
->buffer
);
3173 opoint_byte
= PT_BYTE
;
3174 old_read_only
= current_buffer
->read_only
;
3177 old_begv_byte
= BEGV_BYTE
;
3178 old_zv_byte
= ZV_BYTE
;
3180 current_buffer
->read_only
= Qnil
;
3182 /* Insert new output into buffer
3183 at the current end-of-output marker,
3184 thus preserving logical ordering of input and output. */
3185 if (XMARKER (p
->mark
)->buffer
)
3186 SET_PT_BOTH (clip_to_bounds (BEGV
, marker_position (p
->mark
), ZV
),
3187 clip_to_bounds (BEGV_BYTE
, marker_byte_position (p
->mark
),
3190 SET_PT_BOTH (ZV
, ZV_BYTE
);
3192 before_byte
= PT_BYTE
;
3194 /* If the output marker is outside of the visible region, save
3195 the restriction and widen. */
3196 if (! (BEGV
<= PT
&& PT
<= ZV
))
3199 if (NILP (current_buffer
->enable_multibyte_characters
))
3202 /* Insert before markers in case we are inserting where
3203 the buffer's mark is, and the user's next command is Meta-y. */
3204 if (chars_in_decoding_buf
)
3206 /* Since multibyteness of p->docoding_buf is corrupted, we
3207 can't use insert_from_string_before_markers. */
3210 temp_buf
= (char *) alloca (nbytes
);
3211 bcopy (XSTRING (p
->decoding_buf
)->data
, temp_buf
, nbytes
);
3212 insert_before_markers (temp_buf
, nbytes
);
3216 insert_1_both (chars
, nchars
, nbytes
, 0, 1, 1);
3217 signal_after_change (opoint
, 0, PT
- opoint
);
3219 set_marker_both (p
->mark
, p
->buffer
, PT
, PT_BYTE
);
3221 update_mode_lines
++;
3223 /* Make sure opoint and the old restrictions
3224 float ahead of any new text just as point would. */
3225 if (opoint
>= before
)
3227 opoint
+= PT
- before
;
3228 opoint_byte
+= PT_BYTE
- before_byte
;
3230 if (old_begv
> before
)
3232 old_begv
+= PT
- before
;
3233 old_begv_byte
+= PT_BYTE
- before_byte
;
3235 if (old_zv
>= before
)
3237 old_zv
+= PT
- before
;
3238 old_zv_byte
+= PT_BYTE
- before_byte
;
3241 /* If the restriction isn't what it should be, set it. */
3242 if (old_begv
!= BEGV
|| old_zv
!= ZV
)
3243 Fnarrow_to_region (make_number (old_begv
), make_number (old_zv
));
3245 /* Handling the process output should not deactivate the mark. */
3246 Vdeactivate_mark
= odeactivate
;
3248 current_buffer
->read_only
= old_read_only
;
3249 SET_PT_BOTH (opoint
, opoint_byte
);
3250 set_buffer_internal (old
);
3253 start_vms_process_read (vs
);
3258 DEFUN ("waiting-for-user-input-p", Fwaiting_for_user_input_p
, Swaiting_for_user_input_p
,
3260 "Returns non-nil if emacs is waiting for input from the user.\n\
3261 This is intended for use by asynchronous process output filters and sentinels.")
3264 return (waiting_for_user_input_p
? Qt
: Qnil
);
3267 /* Sending data to subprocess */
3269 jmp_buf send_process_frame
;
3272 send_process_trap ()
3278 longjmp (send_process_frame
, 1);
3281 /* Send some data to process PROC.
3282 BUF is the beginning of the data; LEN is the number of characters.
3283 OBJECT is the Lisp object that the data comes from.
3285 The data is encoded by PROC's coding-system for encoding before it
3286 is sent. But if the data ends at the middle of multi-byte
3287 representation, that incomplete sequence of bytes are sent without
3288 being encoded. Should we store them in a buffer to prepend them to
3289 the data send later? */
3292 send_process (proc
, buf
, len
, object
)
3293 volatile Lisp_Object proc
;
3298 /* Use volatile to protect variables from being clobbered by longjmp. */
3300 volatile unsigned char *procname
= XSTRING (XPROCESS (proc
)->name
)->data
;
3301 struct coding_system
*coding
;
3302 struct gcpro gcpro1
;
3303 int carryover
= XINT (XPROCESS (proc
)->encoding_carryover
);
3308 struct Lisp_Process
*p
= XPROCESS (proc
);
3309 VMS_PROC_STUFF
*vs
, *get_vms_process_pointer();
3312 if (! NILP (XPROCESS (proc
)->raw_status_low
))
3313 update_status (XPROCESS (proc
));
3314 if (! EQ (XPROCESS (proc
)->status
, Qrun
))
3315 error ("Process %s not running", procname
);
3316 if (XINT (XPROCESS (proc
)->outfd
) < 0)
3317 error ("Output file descriptor of %s is closed", procname
);
3319 coding
= proc_encode_coding_system
[XINT (XPROCESS (proc
)->outfd
)];
3320 Vlast_coding_system_used
= coding
->symbol
;
3322 if (CODING_REQUIRE_ENCODING (coding
))
3324 int require
= encoding_buffer_size (coding
, len
);
3326 unsigned char *temp_buf
= NULL
;
3328 /* Remember the offset of data because a string or a buffer may
3329 be relocated. Setting OFFSET to -1 means we don't have to
3330 care about relocation. */
3331 offset
= (BUFFERP (object
)
3332 ? BUF_PTR_BYTE_POS (XBUFFER (object
), buf
)
3334 ? buf
- XSTRING (object
)->data
3339 temp_buf
= (unsigned char *) xmalloc (len
+ carryover
);
3343 if (BUFFERP (object
))
3344 buf
= BUF_BYTE_ADDRESS (XBUFFER (object
), offset
);
3345 else if (STRINGP (object
))
3346 buf
= offset
+ XSTRING (object
)->data
;
3347 /* Now we don't have to care about relocation. */
3350 bcopy ((XSTRING (XPROCESS (proc
)->encoding_buf
)->data
3351 + STRING_BYTES (XSTRING (XPROCESS (proc
)->encoding_buf
))
3355 bcopy (buf
, temp_buf
+ carryover
, len
);
3359 if (STRING_BYTES (XSTRING (XPROCESS (proc
)->encoding_buf
)) < require
)
3361 XPROCESS (proc
)->encoding_buf
= make_uninit_string (require
);
3365 if (BUFFERP (object
))
3366 buf
= BUF_BYTE_ADDRESS (XBUFFER (object
), offset
);
3367 else if (STRINGP (object
))
3368 buf
= offset
+ XSTRING (object
)->data
;
3371 object
= XPROCESS (proc
)->encoding_buf
;
3372 encode_coding (coding
, buf
, XSTRING (object
)->data
,
3373 len
, STRING_BYTES (XSTRING (object
)));
3374 len
= coding
->produced
;
3375 buf
= XSTRING (object
)->data
;
3381 vs
= get_vms_process_pointer (p
->pid
);
3383 error ("Could not find this process: %x", p
->pid
);
3384 else if (write_to_vms_process (vs
, buf
, len
))
3388 if (pty_max_bytes
== 0)
3390 #if defined (HAVE_FPATHCONF) && defined (_PC_MAX_CANON)
3391 pty_max_bytes
= fpathconf (XFASTINT (XPROCESS (proc
)->outfd
),
3393 if (pty_max_bytes
< 0)
3394 pty_max_bytes
= 250;
3396 pty_max_bytes
= 250;
3398 /* Deduct one, to leave space for the eof. */
3402 if (!setjmp (send_process_frame
))
3406 SIGTYPE (*old_sigpipe
)();
3408 /* Decide how much data we can send in one batch.
3409 Long lines need to be split into multiple batches. */
3410 if (!NILP (XPROCESS (proc
)->pty_flag
))
3412 /* Starting this at zero is always correct when not the first iteration
3413 because the previous iteration ended by sending C-d.
3414 It may not be correct for the first iteration
3415 if a partial line was sent in a separate send_process call.
3416 If that proves worth handling, we need to save linepos
3417 in the process object. */
3419 unsigned char *ptr
= buf
;
3420 unsigned char *end
= buf
+ len
;
3422 /* Scan through this text for a line that is too long. */
3423 while (ptr
!= end
&& linepos
< pty_max_bytes
)
3431 /* If we found one, break the line there
3432 and put in a C-d to force the buffer through. */
3436 /* Send this batch, using one or more write calls. */
3439 old_sigpipe
= (SIGTYPE (*) ()) signal (SIGPIPE
, send_process_trap
);
3440 rv
= write (XINT (XPROCESS (proc
)->outfd
), buf
, this);
3441 signal (SIGPIPE
, old_sigpipe
);
3447 || errno
== EWOULDBLOCK
3453 /* Buffer is full. Wait, accepting input;
3454 that may allow the program
3455 to finish doing output and read more. */
3460 /* Running filters might relocate buffers or strings.
3461 Arrange to relocate BUF. */
3462 if (BUFFERP (object
))
3463 offset
= BUF_PTR_BYTE_POS (XBUFFER (object
), buf
);
3464 else if (STRINGP (object
))
3465 offset
= buf
- XSTRING (object
)->data
;
3467 XSETFASTINT (zero
, 0);
3468 #ifdef EMACS_HAS_USECS
3469 wait_reading_process_input (0, 20000, zero
, 0);
3471 wait_reading_process_input (1, 0, zero
, 0);
3474 if (BUFFERP (object
))
3475 buf
= BUF_BYTE_ADDRESS (XBUFFER (object
), offset
);
3476 else if (STRINGP (object
))
3477 buf
= offset
+ XSTRING (object
)->data
;
3482 /* This is a real error. */
3483 report_file_error ("writing to process", Fcons (proc
, Qnil
));
3490 /* If we sent just part of the string, put in an EOF
3491 to force it through, before we send the rest. */
3493 Fprocess_send_eof (proc
);
3498 XPROCESS (proc
)->raw_status_low
= Qnil
;
3499 XPROCESS (proc
)->raw_status_high
= Qnil
;
3500 XPROCESS (proc
)->status
= Fcons (Qexit
, Fcons (make_number (256), Qnil
));
3501 XSETINT (XPROCESS (proc
)->tick
, ++process_tick
);
3502 deactivate_process (proc
);
3504 error ("Error writing to process %s; closed it", procname
);
3506 error ("SIGPIPE raised on process %s; closed it", procname
);
3513 DEFUN ("process-send-region", Fprocess_send_region
, Sprocess_send_region
,
3515 "Send current contents of region as input to PROCESS.\n\
3516 PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
3517 nil, indicating the current buffer's process.\n\
3518 Called from program, takes three arguments, PROCESS, START and END.\n\
3519 If the region is more than 500 characters long,\n\
3520 it is sent in several bunches. This may happen even for shorter regions.\n\
3521 Output from processes can arrive in between bunches.")
3522 (process
, start
, end
)
3523 Lisp_Object process
, start
, end
;
3528 proc
= get_process (process
);
3529 validate_region (&start
, &end
);
3531 if (XINT (start
) < GPT
&& XINT (end
) > GPT
)
3532 move_gap (XINT (start
));
3534 start1
= CHAR_TO_BYTE (XINT (start
));
3535 end1
= CHAR_TO_BYTE (XINT (end
));
3536 send_process (proc
, BYTE_POS_ADDR (start1
), end1
- start1
,
3537 Fcurrent_buffer ());
3542 DEFUN ("process-send-string", Fprocess_send_string
, Sprocess_send_string
,
3544 "Send PROCESS the contents of STRING as input.\n\
3545 PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
3546 nil, indicating the current buffer's process.\n\
3547 If STRING is more than 500 characters long,\n\
3548 it is sent in several bunches. This may happen even for shorter strings.\n\
3549 Output from processes can arrive in between bunches.")
3551 Lisp_Object process
, string
;
3554 CHECK_STRING (string
, 1);
3555 proc
= get_process (process
);
3556 send_process (proc
, XSTRING (string
)->data
,
3557 STRING_BYTES (XSTRING (string
)), string
);
3561 DEFUN ("process-running-child-p", Fprocess_running_child_p
,
3562 Sprocess_running_child_p
, 0, 1, 0,
3563 "Return t if PROCESS has given the terminal to a child.\n\
3564 If the operating system does not make it possible to find out,\n\
3565 return t unconditionally.")
3567 Lisp_Object process
;
3569 /* Initialize in case ioctl doesn't exist or gives an error,
3570 in a way that will cause returning t. */
3573 struct Lisp_Process
*p
;
3575 proc
= get_process (process
);
3576 p
= XPROCESS (proc
);
3578 if (!EQ (p
->childp
, Qt
))
3579 error ("Process %s is not a subprocess",
3580 XSTRING (p
->name
)->data
);
3581 if (XINT (p
->infd
) < 0)
3582 error ("Process %s is not active",
3583 XSTRING (p
->name
)->data
);
3586 if (!NILP (p
->subtty
))
3587 ioctl (XFASTINT (p
->subtty
), TIOCGPGRP
, &gid
);
3589 ioctl (XINT (p
->infd
), TIOCGPGRP
, &gid
);
3590 #endif /* defined (TIOCGPGRP ) */
3592 if (gid
== XFASTINT (p
->pid
))
3597 /* send a signal number SIGNO to PROCESS.
3598 If CURRENT_GROUP is t, that means send to the process group
3599 that currently owns the terminal being used to communicate with PROCESS.
3600 This is used for various commands in shell mode.
3601 If CURRENT_GROUP is lambda, that means send to the process group
3602 that currently owns the terminal, but only if it is NOT the shell itself.
3604 If NOMSG is zero, insert signal-announcements into process's buffers
3607 If we can, we try to signal PROCESS by sending control characters
3608 down the pty. This allows us to signal inferiors who have changed
3609 their uid, for which killpg would return an EPERM error. */
3612 process_send_signal (process
, signo
, current_group
, nomsg
)
3613 Lisp_Object process
;
3615 Lisp_Object current_group
;
3619 register struct Lisp_Process
*p
;
3623 proc
= get_process (process
);
3624 p
= XPROCESS (proc
);
3626 if (!EQ (p
->childp
, Qt
))
3627 error ("Process %s is not a subprocess",
3628 XSTRING (p
->name
)->data
);
3629 if (XINT (p
->infd
) < 0)
3630 error ("Process %s is not active",
3631 XSTRING (p
->name
)->data
);
3633 if (NILP (p
->pty_flag
))
3634 current_group
= Qnil
;
3636 /* If we are using pgrps, get a pgrp number and make it negative. */
3637 if (!NILP (current_group
))
3639 #ifdef SIGNALS_VIA_CHARACTERS
3640 /* If possible, send signals to the entire pgrp
3641 by sending an input character to it. */
3643 /* TERMIOS is the latest and bestest, and seems most likely to
3644 work. If the system has it, use it. */
3651 tcgetattr (XINT (p
->infd
), &t
);
3652 send_process (proc
, &t
.c_cc
[VINTR
], 1, Qnil
);
3656 tcgetattr (XINT (p
->infd
), &t
);
3657 send_process (proc
, &t
.c_cc
[VQUIT
], 1, Qnil
);
3661 tcgetattr (XINT (p
->infd
), &t
);
3662 #if defined (VSWTCH) && !defined (PREFER_VSUSP)
3663 send_process (proc
, &t
.c_cc
[VSWTCH
], 1, Qnil
);
3665 send_process (proc
, &t
.c_cc
[VSUSP
], 1, Qnil
);
3670 #else /* ! HAVE_TERMIOS */
3672 /* On Berkeley descendants, the following IOCTL's retrieve the
3673 current control characters. */
3674 #if defined (TIOCGLTC) && defined (TIOCGETC)
3682 ioctl (XINT (p
->infd
), TIOCGETC
, &c
);
3683 send_process (proc
, &c
.t_intrc
, 1, Qnil
);
3686 ioctl (XINT (p
->infd
), TIOCGETC
, &c
);
3687 send_process (proc
, &c
.t_quitc
, 1, Qnil
);
3691 ioctl (XINT (p
->infd
), TIOCGLTC
, &lc
);
3692 send_process (proc
, &lc
.t_suspc
, 1, Qnil
);
3694 #endif /* ! defined (SIGTSTP) */
3697 #else /* ! defined (TIOCGLTC) && defined (TIOCGETC) */
3699 /* On SYSV descendants, the TCGETA ioctl retrieves the current control
3706 ioctl (XINT (p
->infd
), TCGETA
, &t
);
3707 send_process (proc
, &t
.c_cc
[VINTR
], 1, Qnil
);
3710 ioctl (XINT (p
->infd
), TCGETA
, &t
);
3711 send_process (proc
, &t
.c_cc
[VQUIT
], 1, Qnil
);
3715 ioctl (XINT (p
->infd
), TCGETA
, &t
);
3716 send_process (proc
, &t
.c_cc
[VSWTCH
], 1, Qnil
);
3718 #endif /* ! defined (SIGTSTP) */
3720 #else /* ! defined (TCGETA) */
3721 Your configuration files are messed up
.
3722 /* If your system configuration files define SIGNALS_VIA_CHARACTERS,
3723 you'd better be using one of the alternatives above! */
3724 #endif /* ! defined (TCGETA) */
3725 #endif /* ! defined (TIOCGLTC) && defined (TIOCGETC) */
3726 #endif /* ! defined HAVE_TERMIOS */
3727 #endif /* ! defined (SIGNALS_VIA_CHARACTERS) */
3730 /* Get the pgrp using the tty itself, if we have that.
3731 Otherwise, use the pty to get the pgrp.
3732 On pfa systems, saka@pfu.fujitsu.co.JP writes:
3733 "TIOCGPGRP symbol defined in sys/ioctl.h at E50.
3734 But, TIOCGPGRP does not work on E50 ;-P works fine on E60"
3735 His patch indicates that if TIOCGPGRP returns an error, then
3736 we should just assume that p->pid is also the process group id. */
3740 if (!NILP (p
->subtty
))
3741 err
= ioctl (XFASTINT (p
->subtty
), TIOCGPGRP
, &gid
);
3743 err
= ioctl (XINT (p
->infd
), TIOCGPGRP
, &gid
);
3747 gid
= - XFASTINT (p
->pid
);
3748 #endif /* ! defined (pfa) */
3754 #else /* ! defined (TIOCGPGRP ) */
3755 /* Can't select pgrps on this system, so we know that
3756 the child itself heads the pgrp. */
3757 gid
= - XFASTINT (p
->pid
);
3758 #endif /* ! defined (TIOCGPGRP ) */
3760 /* If current_group is lambda, and the shell owns the terminal,
3761 don't send any signal. */
3762 if (EQ (current_group
, Qlambda
) && gid
== - XFASTINT (p
->pid
))
3766 gid
= - XFASTINT (p
->pid
);
3772 p
->raw_status_low
= Qnil
;
3773 p
->raw_status_high
= Qnil
;
3775 XSETINT (p
->tick
, ++process_tick
);
3779 #endif /* ! defined (SIGCONT) */
3782 send_process (proc
, "\003", 1, Qnil
); /* ^C */
3787 send_process (proc
, "\031", 1, Qnil
); /* ^Y */
3792 sys$
forcex (&(XFASTINT (p
->pid
)), 0, 1);
3795 flush_pending_output (XINT (p
->infd
));
3799 /* If we don't have process groups, send the signal to the immediate
3800 subprocess. That isn't really right, but it's better than any
3801 obvious alternative. */
3804 kill (XFASTINT (p
->pid
), signo
);
3808 /* gid may be a pid, or minus a pgrp's number */
3810 if (!NILP (current_group
))
3811 ioctl (XINT (p
->infd
), TIOCSIGSEND
, signo
);
3814 gid
= - XFASTINT (p
->pid
);
3817 #else /* ! defined (TIOCSIGSEND) */
3818 EMACS_KILLPG (-gid
, signo
);
3819 #endif /* ! defined (TIOCSIGSEND) */
3822 DEFUN ("interrupt-process", Finterrupt_process
, Sinterrupt_process
, 0, 2, 0,
3823 "Interrupt process PROCESS.\n\
3824 PROCESS may be a process, a buffer, or the name of a process or buffer.\n\
3825 nil or no arg means current buffer's process.\n\
3826 Second arg CURRENT-GROUP non-nil means send signal to\n\
3827 the current process-group of the process's controlling terminal\n\
3828 rather than to the process's own process group.\n\
3829 If the process is a shell, this means interrupt current subjob\n\
3830 rather than the shell.\n\
3832 If CURRENT-GROUP is `lambda', and if the shell owns the terminal,\n\
3833 don't send the signal.")
3834 (process
, current_group
)
3835 Lisp_Object process
, current_group
;
3837 process_send_signal (process
, SIGINT
, current_group
, 0);
3841 DEFUN ("kill-process", Fkill_process
, Skill_process
, 0, 2, 0,
3842 "Kill process PROCESS. May be process or name of one.\n\
3843 See function `interrupt-process' for more details on usage.")
3844 (process
, current_group
)
3845 Lisp_Object process
, current_group
;
3847 process_send_signal (process
, SIGKILL
, current_group
, 0);
3851 DEFUN ("quit-process", Fquit_process
, Squit_process
, 0, 2, 0,
3852 "Send QUIT signal to process PROCESS. May be process or name of one.\n\
3853 See function `interrupt-process' for more details on usage.")
3854 (process
, current_group
)
3855 Lisp_Object process
, current_group
;
3857 process_send_signal (process
, SIGQUIT
, current_group
, 0);
3861 DEFUN ("stop-process", Fstop_process
, Sstop_process
, 0, 2, 0,
3862 "Stop process PROCESS. May be process or name of one.\n\
3863 See function `interrupt-process' for more details on usage.")
3864 (process
, current_group
)
3865 Lisp_Object process
, current_group
;
3868 error ("no SIGTSTP support");
3870 process_send_signal (process
, SIGTSTP
, current_group
, 0);
3875 DEFUN ("continue-process", Fcontinue_process
, Scontinue_process
, 0, 2, 0,
3876 "Continue process PROCESS. May be process or name of one.\n\
3877 See function `interrupt-process' for more details on usage.")
3878 (process
, current_group
)
3879 Lisp_Object process
, current_group
;
3882 process_send_signal (process
, SIGCONT
, current_group
, 0);
3884 error ("no SIGCONT support");
3889 DEFUN ("signal-process", Fsignal_process
, Ssignal_process
,
3890 2, 2, "nProcess number: \nnSignal code: ",
3891 "Send the process with process id PID the signal with code SIGCODE.\n\
3892 PID must be an integer. The process need not be a child of this Emacs.\n\
3893 SIGCODE may be an integer, or a symbol whose name is a signal name.")
3895 Lisp_Object pid
, sigcode
;
3897 CHECK_NUMBER (pid
, 0);
3899 #define handle_signal(NAME, VALUE) \
3900 else if (!strcmp (name, NAME)) \
3901 XSETINT (sigcode, VALUE)
3903 if (INTEGERP (sigcode
))
3907 unsigned char *name
;
3909 CHECK_SYMBOL (sigcode
, 1);
3910 name
= XSYMBOL (sigcode
)->name
->data
;
3915 handle_signal ("SIGHUP", SIGHUP
);
3918 handle_signal ("SIGINT", SIGINT
);
3921 handle_signal ("SIGQUIT", SIGQUIT
);
3924 handle_signal ("SIGILL", SIGILL
);
3927 handle_signal ("SIGABRT", SIGABRT
);
3930 handle_signal ("SIGEMT", SIGEMT
);
3933 handle_signal ("SIGKILL", SIGKILL
);
3936 handle_signal ("SIGFPE", SIGFPE
);
3939 handle_signal ("SIGBUS", SIGBUS
);
3942 handle_signal ("SIGSEGV", SIGSEGV
);
3945 handle_signal ("SIGSYS", SIGSYS
);
3948 handle_signal ("SIGPIPE", SIGPIPE
);
3951 handle_signal ("SIGALRM", SIGALRM
);
3954 handle_signal ("SIGTERM", SIGTERM
);
3957 handle_signal ("SIGURG", SIGURG
);
3960 handle_signal ("SIGSTOP", SIGSTOP
);
3963 handle_signal ("SIGTSTP", SIGTSTP
);
3966 handle_signal ("SIGCONT", SIGCONT
);
3969 handle_signal ("SIGCHLD", SIGCHLD
);
3972 handle_signal ("SIGTTIN", SIGTTIN
);
3975 handle_signal ("SIGTTOU", SIGTTOU
);
3978 handle_signal ("SIGIO", SIGIO
);
3981 handle_signal ("SIGXCPU", SIGXCPU
);
3984 handle_signal ("SIGXFSZ", SIGXFSZ
);
3987 handle_signal ("SIGVTALRM", SIGVTALRM
);
3990 handle_signal ("SIGPROF", SIGPROF
);
3993 handle_signal ("SIGWINCH", SIGWINCH
);
3996 handle_signal ("SIGINFO", SIGINFO
);
3999 handle_signal ("SIGUSR1", SIGUSR1
);
4002 handle_signal ("SIGUSR2", SIGUSR2
);
4005 error ("Undefined signal name %s", name
);
4008 #undef handle_signal
4010 return make_number (kill (XINT (pid
), XINT (sigcode
)));
4013 DEFUN ("process-send-eof", Fprocess_send_eof
, Sprocess_send_eof
, 0, 1, 0,
4014 "Make PROCESS see end-of-file in its input.\n\
4015 EOF comes after any text already sent to it.\n\
4016 PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
4017 nil, indicating the current buffer's process.\n\
4018 If PROCESS is a network connection, or is a process communicating\n\
4019 through a pipe (as opposed to a pty), then you cannot send any more\n\
4020 text to PROCESS after you call this function.")
4022 Lisp_Object process
;
4025 struct coding_system
*coding
;
4027 proc
= get_process (process
);
4028 coding
= proc_encode_coding_system
[XINT (XPROCESS (proc
)->outfd
)];
4030 /* Make sure the process is really alive. */
4031 if (! NILP (XPROCESS (proc
)->raw_status_low
))
4032 update_status (XPROCESS (proc
));
4033 if (! EQ (XPROCESS (proc
)->status
, Qrun
))
4034 error ("Process %s not running", XSTRING (XPROCESS (proc
)->name
)->data
);
4036 if (CODING_REQUIRE_FLUSHING (coding
))
4038 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
4039 send_process (proc
, "", 0, Qnil
);
4043 send_process (proc
, "\032", 1, Qnil
); /* ^z */
4045 if (!NILP (XPROCESS (proc
)->pty_flag
))
4046 send_process (proc
, "\004", 1, Qnil
);
4049 int old_outfd
, new_outfd
;
4051 #ifdef HAVE_SHUTDOWN
4052 /* If this is a network connection, or socketpair is used
4053 for communication with the subprocess, call shutdown to cause EOF.
4054 (In some old system, shutdown to socketpair doesn't work.
4055 Then we just can't win.) */
4056 if (NILP (XPROCESS (proc
)->pid
)
4057 || XINT (XPROCESS (proc
)->outfd
) == XINT (XPROCESS (proc
)->infd
))
4058 shutdown (XINT (XPROCESS (proc
)->outfd
), 1);
4059 /* In case of socketpair, outfd == infd, so don't close it. */
4060 if (XINT (XPROCESS (proc
)->outfd
) != XINT (XPROCESS (proc
)->infd
))
4061 close (XINT (XPROCESS (proc
)->outfd
));
4062 #else /* not HAVE_SHUTDOWN */
4063 close (XINT (XPROCESS (proc
)->outfd
));
4064 #endif /* not HAVE_SHUTDOWN */
4065 new_outfd
= open (NULL_DEVICE
, O_WRONLY
);
4066 old_outfd
= XINT (XPROCESS (proc
)->outfd
);
4068 if (!proc_encode_coding_system
[new_outfd
])
4069 proc_encode_coding_system
[new_outfd
]
4070 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
4071 bcopy (proc_encode_coding_system
[old_outfd
],
4072 proc_encode_coding_system
[new_outfd
],
4073 sizeof (struct coding_system
));
4074 bzero (proc_encode_coding_system
[old_outfd
],
4075 sizeof (struct coding_system
));
4077 XSETINT (XPROCESS (proc
)->outfd
, new_outfd
);
4083 /* Kill all processes associated with `buffer'.
4084 If `buffer' is nil, kill all processes */
4087 kill_buffer_processes (buffer
)
4090 Lisp_Object tail
, proc
;
4092 for (tail
= Vprocess_alist
; GC_CONSP (tail
); tail
= XCDR (tail
))
4094 proc
= XCDR (XCAR (tail
));
4095 if (GC_PROCESSP (proc
)
4096 && (NILP (buffer
) || EQ (XPROCESS (proc
)->buffer
, buffer
)))
4098 if (NETCONN_P (proc
))
4099 Fdelete_process (proc
);
4100 else if (XINT (XPROCESS (proc
)->infd
) >= 0)
4101 process_send_signal (proc
, SIGHUP
, Qnil
, 1);
4106 /* On receipt of a signal that a child status has changed,
4107 loop asking about children with changed statuses until
4108 the system says there are no more.
4109 All we do is change the status;
4110 we do not run sentinels or print notifications.
4111 That is saved for the next time keyboard input is done,
4112 in order to avoid timing errors. */
4114 /** WARNING: this can be called during garbage collection.
4115 Therefore, it must not be fooled by the presence of mark bits in
4118 /** USG WARNING: Although it is not obvious from the documentation
4119 in signal(2), on a USG system the SIGCLD handler MUST NOT call
4120 signal() before executing at least one wait(), otherwise the handler
4121 will be called again, resulting in an infinite loop. The relevant
4122 portion of the documentation reads "SIGCLD signals will be queued
4123 and the signal-catching function will be continually reentered until
4124 the queue is empty". Invoking signal() causes the kernel to reexamine
4125 the SIGCLD queue. Fred Fish, UniSoft Systems Inc. */
4128 sigchld_handler (signo
)
4131 int old_errno
= errno
;
4133 register struct Lisp_Process
*p
;
4134 extern EMACS_TIME
*input_available_clear_time
;
4138 sigheld
|= sigbit (SIGCHLD
);
4150 #endif /* no WUNTRACED */
4151 /* Keep trying to get a status until we get a definitive result. */
4155 pid
= wait3 (&w
, WNOHANG
| WUNTRACED
, 0);
4157 while (pid
<= 0 && errno
== EINTR
);
4161 /* A real failure. We have done all our job, so return. */
4163 /* USG systems forget handlers when they are used;
4164 must reestablish each time */
4165 #if defined (USG) && !defined (POSIX_SIGNALS)
4166 signal (signo
, sigchld_handler
); /* WARNING - must come after wait3() */
4169 sigheld
&= ~sigbit (SIGCHLD
);
4177 #endif /* no WNOHANG */
4179 /* Find the process that signaled us, and record its status. */
4182 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
4184 proc
= XCDR (XCAR (tail
));
4185 p
= XPROCESS (proc
);
4186 if (EQ (p
->childp
, Qt
) && XFASTINT (p
->pid
) == pid
)
4191 /* Look for an asynchronous process whose pid hasn't been filled
4194 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
4196 proc
= XCDR (XCAR (tail
));
4197 p
= XPROCESS (proc
);
4198 if (INTEGERP (p
->pid
) && XINT (p
->pid
) == -1)
4203 /* Change the status of the process that was found. */
4206 union { int i
; WAITTYPE wt
; } u
;
4207 int clear_desc_flag
= 0;
4209 XSETINT (p
->tick
, ++process_tick
);
4211 XSETINT (p
->raw_status_low
, u
.i
& 0xffff);
4212 XSETINT (p
->raw_status_high
, u
.i
>> 16);
4214 /* If process has terminated, stop waiting for its output. */
4215 if ((WIFSIGNALED (w
) || WIFEXITED (w
))
4216 && XINT (p
->infd
) >= 0)
4217 clear_desc_flag
= 1;
4219 /* We use clear_desc_flag to avoid a compiler bug in Microsoft C. */
4220 if (clear_desc_flag
)
4222 FD_CLR (XINT (p
->infd
), &input_wait_mask
);
4223 FD_CLR (XINT (p
->infd
), &non_keyboard_wait_mask
);
4226 /* Tell wait_reading_process_input that it needs to wake up and
4228 if (input_available_clear_time
)
4229 EMACS_SET_SECS_USECS (*input_available_clear_time
, 0, 0);
4232 /* There was no asynchronous process found for that id. Check
4233 if we have a synchronous process. */
4236 synch_process_alive
= 0;
4238 /* Report the status of the synchronous process. */
4240 synch_process_retcode
= WRETCODE (w
);
4241 else if (WIFSIGNALED (w
))
4243 int code
= WTERMSIG (w
);
4249 /* Suppress warning if the table has const char *. */
4250 signame
= (char *) sys_siglist
[code
];
4252 signame
= sys_errlist
[code
];
4256 signame
= "unknown";
4258 synch_process_death
= signame
;
4261 /* Tell wait_reading_process_input that it needs to wake up and
4263 if (input_available_clear_time
)
4264 EMACS_SET_SECS_USECS (*input_available_clear_time
, 0, 0);
4267 /* On some systems, we must return right away.
4268 If any more processes want to signal us, we will
4270 Otherwise (on systems that have WNOHANG), loop around
4271 to use up all the processes that have something to tell us. */
4272 #if defined (USG) && ! (defined (HPUX) && defined (WNOHANG)) || defined (WINDOWSNT)
4273 #if defined (USG) && ! defined (POSIX_SIGNALS)
4274 signal (signo
, sigchld_handler
);
4278 #endif /* USG, but not HPUX with WNOHANG */
4284 exec_sentinel_unwind (data
)
4287 XPROCESS (XCAR (data
))->sentinel
= XCDR (data
);
4292 exec_sentinel_error_handler (error
)
4295 cmd_error_internal (error
, "error in process sentinel: ");
4297 update_echo_area ();
4298 Fsleep_for (make_number (2), Qnil
);
4302 exec_sentinel (proc
, reason
)
4303 Lisp_Object proc
, reason
;
4305 Lisp_Object sentinel
, obuffer
, odeactivate
, okeymap
;
4306 register struct Lisp_Process
*p
= XPROCESS (proc
);
4307 int count
= specpdl_ptr
- specpdl
;
4308 int outer_running_asynch_code
= running_asynch_code
;
4309 int waiting
= waiting_for_user_input_p
;
4311 /* No need to gcpro these, because all we do with them later
4312 is test them for EQness, and none of them should be a string. */
4313 odeactivate
= Vdeactivate_mark
;
4314 XSETBUFFER (obuffer
, current_buffer
);
4315 okeymap
= current_buffer
->keymap
;
4317 sentinel
= p
->sentinel
;
4318 if (NILP (sentinel
))
4321 /* Zilch the sentinel while it's running, to avoid recursive invocations;
4322 assure that it gets restored no matter how the sentinel exits. */
4324 record_unwind_protect (exec_sentinel_unwind
, Fcons (proc
, sentinel
));
4325 /* Inhibit quit so that random quits don't screw up a running filter. */
4326 specbind (Qinhibit_quit
, Qt
);
4327 specbind (Qlast_nonmenu_event
, Qt
);
4329 /* In case we get recursively called,
4330 and we already saved the match data nonrecursively,
4331 save the same match data in safely recursive fashion. */
4332 if (outer_running_asynch_code
)
4335 tem
= Fmatch_data (Qnil
, Qnil
);
4336 restore_match_data ();
4337 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
4338 Fset_match_data (tem
);
4341 /* For speed, if a search happens within this code,
4342 save the match data in a special nonrecursive fashion. */
4343 running_asynch_code
= 1;
4345 internal_condition_case_1 (read_process_output_call
,
4347 Fcons (proc
, Fcons (reason
, Qnil
))),
4348 !NILP (Vdebug_on_error
) ? Qnil
: Qerror
,
4349 exec_sentinel_error_handler
);
4351 /* If we saved the match data nonrecursively, restore it now. */
4352 restore_match_data ();
4353 running_asynch_code
= outer_running_asynch_code
;
4355 Vdeactivate_mark
= odeactivate
;
4357 /* Restore waiting_for_user_input_p as it was
4358 when we were called, in case the filter clobbered it. */
4359 waiting_for_user_input_p
= waiting
;
4362 if (! EQ (Fcurrent_buffer (), obuffer
)
4363 || ! EQ (current_buffer
->keymap
, okeymap
))
4365 /* But do it only if the caller is actually going to read events.
4366 Otherwise there's no need to make him wake up, and it could
4367 cause trouble (for example it would make Fsit_for return). */
4368 if (waiting_for_user_input_p
== -1)
4369 record_asynch_buffer_change ();
4371 unbind_to (count
, Qnil
);
4374 /* Report all recent events of a change in process status
4375 (either run the sentinel or output a message).
4376 This is done while Emacs is waiting for keyboard input. */
4381 register Lisp_Object proc
, buffer
;
4382 Lisp_Object tail
, msg
;
4383 struct gcpro gcpro1
, gcpro2
;
4387 /* We need to gcpro tail; if read_process_output calls a filter
4388 which deletes a process and removes the cons to which tail points
4389 from Vprocess_alist, and then causes a GC, tail is an unprotected
4393 /* Set this now, so that if new processes are created by sentinels
4394 that we run, we get called again to handle their status changes. */
4395 update_tick
= process_tick
;
4397 for (tail
= Vprocess_alist
; !NILP (tail
); tail
= Fcdr (tail
))
4400 register struct Lisp_Process
*p
;
4402 proc
= Fcdr (Fcar (tail
));
4403 p
= XPROCESS (proc
);
4405 if (XINT (p
->tick
) != XINT (p
->update_tick
))
4407 XSETINT (p
->update_tick
, XINT (p
->tick
));
4409 /* If process is still active, read any output that remains. */
4410 while (! EQ (p
->filter
, Qt
)
4411 && XINT (p
->infd
) >= 0
4412 && read_process_output (proc
, XINT (p
->infd
)) > 0);
4416 /* Get the text to use for the message. */
4417 if (!NILP (p
->raw_status_low
))
4419 msg
= status_message (p
->status
);
4421 /* If process is terminated, deactivate it or delete it. */
4423 if (CONSP (p
->status
))
4424 symbol
= XCAR (p
->status
);
4426 if (EQ (symbol
, Qsignal
) || EQ (symbol
, Qexit
)
4427 || EQ (symbol
, Qclosed
))
4429 if (delete_exited_processes
)
4430 remove_process (proc
);
4432 deactivate_process (proc
);
4435 /* The actions above may have further incremented p->tick.
4436 So set p->update_tick again
4437 so that an error in the sentinel will not cause
4438 this code to be run again. */
4439 XSETINT (p
->update_tick
, XINT (p
->tick
));
4440 /* Now output the message suitably. */
4441 if (!NILP (p
->sentinel
))
4442 exec_sentinel (proc
, msg
);
4443 /* Don't bother with a message in the buffer
4444 when a process becomes runnable. */
4445 else if (!EQ (symbol
, Qrun
) && !NILP (buffer
))
4447 Lisp_Object ro
, tem
;
4448 struct buffer
*old
= current_buffer
;
4449 int opoint
, opoint_byte
;
4450 int before
, before_byte
;
4452 ro
= XBUFFER (buffer
)->read_only
;
4454 /* Avoid error if buffer is deleted
4455 (probably that's why the process is dead, too) */
4456 if (NILP (XBUFFER (buffer
)->name
))
4458 Fset_buffer (buffer
);
4461 opoint_byte
= PT_BYTE
;
4462 /* Insert new output into buffer
4463 at the current end-of-output marker,
4464 thus preserving logical ordering of input and output. */
4465 if (XMARKER (p
->mark
)->buffer
)
4466 Fgoto_char (p
->mark
);
4468 SET_PT_BOTH (ZV
, ZV_BYTE
);
4471 before_byte
= PT_BYTE
;
4473 tem
= current_buffer
->read_only
;
4474 current_buffer
->read_only
= Qnil
;
4475 insert_string ("\nProcess ");
4476 Finsert (1, &p
->name
);
4477 insert_string (" ");
4479 current_buffer
->read_only
= tem
;
4480 set_marker_both (p
->mark
, p
->buffer
, PT
, PT_BYTE
);
4482 if (opoint
>= before
)
4483 SET_PT_BOTH (opoint
+ (PT
- before
),
4484 opoint_byte
+ (PT_BYTE
- before_byte
));
4486 SET_PT_BOTH (opoint
, opoint_byte
);
4488 set_buffer_internal (old
);
4493 update_mode_lines
++; /* in case buffers use %s in mode-line-format */
4494 redisplay_preserve_echo_area ();
4500 DEFUN ("set-process-coding-system", Fset_process_coding_system
,
4501 Sset_process_coding_system
, 1, 3, 0,
4502 "Set coding systems of PROCESS to DECODING and ENCODING.\n\
4503 DECODING will be used to decode subprocess output and ENCODING to\n\
4504 encode subprocess input.")
4505 (proc
, decoding
, encoding
)
4506 register Lisp_Object proc
, decoding
, encoding
;
4508 register struct Lisp_Process
*p
;
4510 CHECK_PROCESS (proc
, 0);
4511 p
= XPROCESS (proc
);
4512 if (XINT (p
->infd
) < 0)
4513 error ("Input file descriptor of %s closed", XSTRING (p
->name
)->data
);
4514 if (XINT (p
->outfd
) < 0)
4515 error ("Output file descriptor of %s closed", XSTRING (p
->name
)->data
);
4517 p
->decode_coding_system
= Fcheck_coding_system (decoding
);
4518 p
->encode_coding_system
= Fcheck_coding_system (encoding
);
4519 setup_coding_system (decoding
,
4520 proc_decode_coding_system
[XINT (p
->infd
)]);
4521 setup_coding_system (encoding
,
4522 proc_encode_coding_system
[XINT (p
->outfd
)]);
4527 DEFUN ("process-coding-system",
4528 Fprocess_coding_system
, Sprocess_coding_system
, 1, 1, 0,
4529 "Return a cons of coding systems for decoding and encoding of PROCESS.")
4531 register Lisp_Object proc
;
4533 CHECK_PROCESS (proc
, 0);
4534 return Fcons (XPROCESS (proc
)->decode_coding_system
,
4535 XPROCESS (proc
)->encode_coding_system
);
4538 /* The first time this is called, assume keyboard input comes from DESC
4539 instead of from where we used to expect it.
4540 Subsequent calls mean assume input keyboard can come from DESC
4541 in addition to other places. */
4543 static int add_keyboard_wait_descriptor_called_flag
;
4546 add_keyboard_wait_descriptor (desc
)
4549 if (! add_keyboard_wait_descriptor_called_flag
)
4550 FD_CLR (0, &input_wait_mask
);
4551 add_keyboard_wait_descriptor_called_flag
= 1;
4552 FD_SET (desc
, &input_wait_mask
);
4553 FD_SET (desc
, &non_process_wait_mask
);
4554 if (desc
> max_keyboard_desc
)
4555 max_keyboard_desc
= desc
;
4558 /* From now on, do not expect DESC to give keyboard input. */
4561 delete_keyboard_wait_descriptor (desc
)
4565 int lim
= max_keyboard_desc
;
4567 FD_CLR (desc
, &input_wait_mask
);
4568 FD_CLR (desc
, &non_process_wait_mask
);
4570 if (desc
== max_keyboard_desc
)
4571 for (fd
= 0; fd
< lim
; fd
++)
4572 if (FD_ISSET (fd
, &input_wait_mask
)
4573 && !FD_ISSET (fd
, &non_keyboard_wait_mask
))
4574 max_keyboard_desc
= fd
;
4577 /* Return nonzero if *MASK has a bit set
4578 that corresponds to one of the keyboard input descriptors. */
4581 keyboard_bit_set (mask
)
4586 for (fd
= 0; fd
<= max_keyboard_desc
; fd
++)
4587 if (FD_ISSET (fd
, mask
) && FD_ISSET (fd
, &input_wait_mask
)
4588 && !FD_ISSET (fd
, &non_keyboard_wait_mask
))
4601 if (! noninteractive
|| initialized
)
4603 signal (SIGCHLD
, sigchld_handler
);
4606 FD_ZERO (&input_wait_mask
);
4607 FD_ZERO (&non_keyboard_wait_mask
);
4608 FD_ZERO (&non_process_wait_mask
);
4609 max_process_desc
= 0;
4611 FD_SET (0, &input_wait_mask
);
4613 Vprocess_alist
= Qnil
;
4614 for (i
= 0; i
< MAXDESC
; i
++)
4616 chan_process
[i
] = Qnil
;
4617 proc_buffered_char
[i
] = -1;
4619 bzero (proc_decode_coding_system
, sizeof proc_decode_coding_system
);
4620 bzero (proc_encode_coding_system
, sizeof proc_encode_coding_system
);
4622 Vdefault_process_coding_system
4623 = (NILP (buffer_defaults
.enable_multibyte_characters
)
4624 ? Fcons (Qraw_text
, Qnil
)
4625 : Fcons (Qemacs_mule
, Qnil
));
4631 Qprocessp
= intern ("processp");
4632 staticpro (&Qprocessp
);
4633 Qrun
= intern ("run");
4635 Qstop
= intern ("stop");
4637 Qsignal
= intern ("signal");
4638 staticpro (&Qsignal
);
4640 /* Qexit is already staticpro'd by syms_of_eval; don't staticpro it
4643 Qexit = intern ("exit");
4644 staticpro (&Qexit); */
4646 Qopen
= intern ("open");
4648 Qclosed
= intern ("closed");
4649 staticpro (&Qclosed
);
4651 Qlast_nonmenu_event
= intern ("last-nonmenu-event");
4652 staticpro (&Qlast_nonmenu_event
);
4654 staticpro (&Vprocess_alist
);
4656 DEFVAR_BOOL ("delete-exited-processes", &delete_exited_processes
,
4657 "*Non-nil means delete processes immediately when they exit.\n\
4658 nil means don't delete them until `list-processes' is run.");
4660 delete_exited_processes
= 1;
4662 DEFVAR_LISP ("process-connection-type", &Vprocess_connection_type
,
4663 "Control type of device used to communicate with subprocesses.\n\
4664 Values are nil to use a pipe, or t or `pty' to use a pty.\n\
4665 The value has no effect if the system has no ptys or if all ptys are busy:\n\
4666 then a pipe is used in any case.\n\
4667 The value takes effect when `start-process' is called.");
4668 Vprocess_connection_type
= Qt
;
4670 defsubr (&Sprocessp
);
4671 defsubr (&Sget_process
);
4672 defsubr (&Sget_buffer_process
);
4673 defsubr (&Sdelete_process
);
4674 defsubr (&Sprocess_status
);
4675 defsubr (&Sprocess_exit_status
);
4676 defsubr (&Sprocess_id
);
4677 defsubr (&Sprocess_name
);
4678 defsubr (&Sprocess_tty_name
);
4679 defsubr (&Sprocess_command
);
4680 defsubr (&Sset_process_buffer
);
4681 defsubr (&Sprocess_buffer
);
4682 defsubr (&Sprocess_mark
);
4683 defsubr (&Sset_process_filter
);
4684 defsubr (&Sprocess_filter
);
4685 defsubr (&Sset_process_sentinel
);
4686 defsubr (&Sprocess_sentinel
);
4687 defsubr (&Sset_process_window_size
);
4688 defsubr (&Sset_process_inherit_coding_system_flag
);
4689 defsubr (&Sprocess_inherit_coding_system_flag
);
4690 defsubr (&Sprocess_kill_without_query
);
4691 defsubr (&Sprocess_contact
);
4692 defsubr (&Slist_processes
);
4693 defsubr (&Sprocess_list
);
4694 defsubr (&Sstart_process
);
4696 defsubr (&Sopen_network_stream
);
4697 #endif /* HAVE_SOCKETS */
4698 defsubr (&Saccept_process_output
);
4699 defsubr (&Sprocess_send_region
);
4700 defsubr (&Sprocess_send_string
);
4701 defsubr (&Sinterrupt_process
);
4702 defsubr (&Skill_process
);
4703 defsubr (&Squit_process
);
4704 defsubr (&Sstop_process
);
4705 defsubr (&Scontinue_process
);
4706 defsubr (&Sprocess_running_child_p
);
4707 defsubr (&Sprocess_send_eof
);
4708 defsubr (&Ssignal_process
);
4709 defsubr (&Swaiting_for_user_input_p
);
4710 /* defsubr (&Sprocess_connection); */
4711 defsubr (&Sset_process_coding_system
);
4712 defsubr (&Sprocess_coding_system
);
4716 #else /* not subprocesses */
4718 #include <sys/types.h>
4722 #include "systime.h"
4723 #include "charset.h"
4725 #include "termopts.h"
4726 #include "sysselect.h"
4728 extern int frame_garbaged
;
4730 extern EMACS_TIME
timer_check ();
4731 extern int timers_run
;
4733 /* As described above, except assuming that there are no subprocesses:
4735 Wait for timeout to elapse and/or keyboard input to be available.
4738 timeout in seconds, or
4739 zero for no limit, or
4740 -1 means gobble data immediately available but don't wait for any.
4742 read_kbd is a Lisp_Object:
4743 0 to ignore keyboard input, or
4744 1 to return when input is available, or
4745 -1 means caller will actually read the input, so don't throw to
4747 a cons cell, meaning wait until its car is non-nil
4748 (and gobble terminal input into the buffer if any arrives), or
4749 We know that read_kbd will never be a Lisp_Process, since
4750 `subprocesses' isn't defined.
4752 do_display != 0 means redisplay should be done to show subprocess
4753 output that arrives.
4755 Return true iff we received input from any process. */
4758 wait_reading_process_input (time_limit
, microsecs
, read_kbd
, do_display
)
4759 int time_limit
, microsecs
;
4760 Lisp_Object read_kbd
;
4764 EMACS_TIME end_time
, timeout
;
4765 SELECT_TYPE waitchannels
;
4767 Lisp_Object
*wait_for_cell
= 0;
4769 /* If waiting for non-nil in a cell, record where. */
4770 if (CONSP (read_kbd
))
4772 wait_for_cell
= &XCAR (read_kbd
);
4773 XSETFASTINT (read_kbd
, 0);
4776 /* What does time_limit really mean? */
4777 if (time_limit
|| microsecs
)
4779 EMACS_GET_TIME (end_time
);
4780 EMACS_SET_SECS_USECS (timeout
, time_limit
, microsecs
);
4781 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
4784 /* Turn off periodic alarms (in case they are in use)
4785 because the select emulator uses alarms. */
4790 int timeout_reduced_for_timers
= 0;
4792 /* If calling from keyboard input, do not quit
4793 since we want to return C-g as an input character.
4794 Otherwise, do pending quit if requested. */
4795 if (XINT (read_kbd
) >= 0)
4798 /* Exit now if the cell we're waiting for became non-nil. */
4799 if (wait_for_cell
&& ! NILP (*wait_for_cell
))
4802 /* Compute time from now till when time limit is up */
4803 /* Exit if already run out */
4804 if (time_limit
== -1)
4806 /* -1 specified for timeout means
4807 gobble output available now
4808 but don't wait at all. */
4810 EMACS_SET_SECS_USECS (timeout
, 0, 0);
4812 else if (time_limit
|| microsecs
)
4814 EMACS_GET_TIME (timeout
);
4815 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
4816 if (EMACS_TIME_NEG_P (timeout
))
4821 EMACS_SET_SECS_USECS (timeout
, 100000, 0);
4824 /* If our caller will not immediately handle keyboard events,
4825 run timer events directly.
4826 (Callers that will immediately read keyboard events
4827 call timer_delay on their own.) */
4828 if (! wait_for_cell
)
4830 EMACS_TIME timer_delay
;
4834 old_timers_run
= timers_run
;
4835 timer_delay
= timer_check (1);
4836 if (timers_run
!= old_timers_run
&& do_display
)
4838 redisplay_preserve_echo_area ();
4839 /* We must retry, since a timer may have requeued itself
4840 and that could alter the time delay. */
4844 /* If there is unread keyboard input, also return. */
4845 if (XINT (read_kbd
) != 0
4846 && requeued_events_pending_p ())
4849 if (! EMACS_TIME_NEG_P (timer_delay
) && time_limit
!= -1)
4851 EMACS_TIME difference
;
4852 EMACS_SUB_TIME (difference
, timer_delay
, timeout
);
4853 if (EMACS_TIME_NEG_P (difference
))
4855 timeout
= timer_delay
;
4856 timeout_reduced_for_timers
= 1;
4861 /* Cause C-g and alarm signals to take immediate action,
4862 and cause input available signals to zero out timeout. */
4863 if (XINT (read_kbd
) < 0)
4864 set_waiting_for_input (&timeout
);
4866 /* Wait till there is something to do. */
4868 if (! XINT (read_kbd
) && wait_for_cell
== 0)
4869 FD_ZERO (&waitchannels
);
4871 FD_SET (0, &waitchannels
);
4873 /* If a frame has been newly mapped and needs updating,
4874 reprocess its display stuff. */
4875 if (frame_garbaged
&& do_display
)
4877 clear_waiting_for_input ();
4878 redisplay_preserve_echo_area ();
4879 if (XINT (read_kbd
) < 0)
4880 set_waiting_for_input (&timeout
);
4883 if (XINT (read_kbd
) && detect_input_pending ())
4886 FD_ZERO (&waitchannels
);
4889 nfds
= select (1, &waitchannels
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0,
4894 /* Make C-g and alarm signals set flags again */
4895 clear_waiting_for_input ();
4897 /* If we woke up due to SIGWINCH, actually change size now. */
4898 do_pending_window_change (0);
4900 if (time_limit
&& nfds
== 0 && ! timeout_reduced_for_timers
)
4901 /* We waited the full specified time, so return now. */
4906 /* If the system call was interrupted, then go around the
4908 if (xerrno
== EINTR
)
4909 FD_ZERO (&waitchannels
);
4911 error ("select error: %s", strerror (xerrno
));
4914 else if (nfds
> 0 && (waitchannels
& 1) && interrupt_input
)
4915 /* System sometimes fails to deliver SIGIO. */
4916 kill (getpid (), SIGIO
);
4919 if (XINT (read_kbd
) && interrupt_input
&& (waitchannels
& 1))
4920 kill (getpid (), SIGIO
);
4923 /* Check for keyboard input */
4925 if ((XINT (read_kbd
) != 0)
4926 && detect_input_pending_run_timers (do_display
))
4928 swallow_events (do_display
);
4929 if (detect_input_pending_run_timers (do_display
))
4933 /* If there is unread keyboard input, also return. */
4934 if (XINT (read_kbd
) != 0
4935 && requeued_events_pending_p ())
4938 /* If wait_for_cell. check for keyboard input
4939 but don't run any timers.
4940 ??? (It seems wrong to me to check for keyboard
4941 input at all when wait_for_cell, but the code
4942 has been this way since July 1994.
4943 Try changing this after version 19.31.) */
4945 && detect_input_pending ())
4947 swallow_events (do_display
);
4948 if (detect_input_pending ())
4952 /* Exit now if the cell we're waiting for became non-nil. */
4953 if (wait_for_cell
&& ! NILP (*wait_for_cell
))
4963 DEFUN ("get-buffer-process", Fget_buffer_process
, Sget_buffer_process
, 1, 1, 0,
4964 /* Don't confuse make-docfile by having two doc strings for this function.
4965 make-docfile does not pay attention to #if, for good reason! */
4968 register Lisp_Object name
;
4973 DEFUN ("process-inherit-coding-system-flag",
4974 Fprocess_inherit_coding_system_flag
, Sprocess_inherit_coding_system_flag
,
4976 /* Don't confuse make-docfile by having two doc strings for this function.
4977 make-docfile does not pay attention to #if, for good reason! */
4980 register Lisp_Object process
;
4982 /* Ignore the argument and return the value of
4983 inherit-process-coding-system. */
4984 return inherit_process_coding_system
? Qt
: Qnil
;
4987 /* Kill all processes associated with `buffer'.
4988 If `buffer' is nil, kill all processes.
4989 Since we have no subprocesses, this does nothing. */
4992 kill_buffer_processes (buffer
)
5005 defsubr (&Sget_buffer_process
);
5006 defsubr (&Sprocess_inherit_coding_system_flag
);
5010 #endif /* not subprocesses */