1 /* Asynchronous subprocess control for GNU Emacs.
2 Copyright (C) 1985, 86, 87, 88, 93, 94, 95, 96, 1998
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
27 /* This file is split into two parts by the following preprocessor
28 conditional. The 'then' clause contains all of the support for
29 asynchronous subprocesses. The 'else' clause contains stub
30 versions of some of the asynchronous subprocess routines that are
31 often called elsewhere in Emacs, so we don't have to #ifdef the
32 sections that call them. */
40 #include <sys/types.h> /* some typedefs are used in sys/file.h */
50 #endif /* not WINDOWSNT */
52 #ifdef HAVE_SOCKETS /* TCP connection support, if kernel can do it */
53 #include <sys/socket.h>
55 #include <netinet/in.h>
56 #include <arpa/inet.h>
57 #ifdef NEED_NET_ERRNO_H
58 #include <net/errno.h>
59 #endif /* NEED_NET_ERRNO_H */
60 #endif /* HAVE_SOCKETS */
62 /* TERM is a poor-man's SLIP, used on Linux. */
67 /* On some systems, e.g. DGUX, inet_addr returns a 'struct in_addr'. */
68 #ifdef HAVE_BROKEN_INET_ADDR
69 #define IN_ADDR struct in_addr
70 #define NUMERIC_ADDR_ERROR (numeric_addr.s_addr == -1)
72 #define IN_ADDR unsigned long
73 #define NUMERIC_ADDR_ERROR (numeric_addr == -1)
76 #if defined(BSD_SYSTEM) || defined(STRIDE)
77 #include <sys/ioctl.h>
78 #if !defined (O_NDELAY) && defined (HAVE_PTYS) && !defined(USG5)
80 #endif /* HAVE_PTYS and no O_NDELAY */
81 #endif /* BSD_SYSTEM || STRIDE */
83 #ifdef BROKEN_O_NONBLOCK
85 #endif /* BROKEN_O_NONBLOCK */
92 #include <sys/sysmacros.h> /* for "minor" */
104 #include "termhooks.h"
105 #include "termopts.h"
106 #include "commands.h"
108 #include "blockinput.h"
109 #include "keyboard.h"
110 #include "dispextern.h"
112 #define max(a, b) ((a) > (b) ? (a) : (b))
114 Lisp_Object Qprocessp
;
115 Lisp_Object Qrun
, Qstop
, Qsignal
, Qopen
, Qclosed
;
116 Lisp_Object Qlast_nonmenu_event
;
117 /* Qexit is declared and initialized in eval.c. */
119 /* a process object is a network connection when its childp field is neither
120 Qt nor Qnil but is instead a cons cell (HOSTNAME PORTNUM). */
123 #define NETCONN_P(p) (GC_CONSP (XPROCESS (p)->childp))
125 #define NETCONN_P(p) 0
126 #endif /* HAVE_SOCKETS */
128 /* Define first descriptor number available for subprocesses. */
130 #define FIRST_PROC_DESC 1
132 #define FIRST_PROC_DESC 3
135 /* Define SIGCHLD as an alias for SIGCLD. There are many conditionals
138 #if !defined (SIGCHLD) && defined (SIGCLD)
139 #define SIGCHLD SIGCLD
142 #include "syssignal.h"
147 extern char *strerror ();
149 extern char *sys_errlist
[];
156 #ifndef SYS_SIGLIST_DECLARED
161 extern char *sys_siglist
[];
162 #endif /* not LINUX */
164 char *sys_siglist
[] =
170 "illegal instruction",
174 "floating point exception",
177 "segmentation violation",
178 "bad argument to system call",
179 "write on a pipe with no one to read it",
181 "software termination signal from kill",
183 "sendable stop signal not from tty",
184 "stop signal from tty",
185 "continue a stopped process",
186 "child status has changed",
187 "background read attempted from control tty",
188 "background write attempted from control tty",
189 "input record available at control tty",
190 "exceeded CPU time limit",
191 "exceeded file size limit"
193 #endif /* not WINDOWSNT */
196 #endif /* ! SYS_SIGLIST_DECLARED */
198 /* t means use pty, nil means use a pipe,
199 maybe other values to come. */
200 static Lisp_Object Vprocess_connection_type
;
204 #include <sys/socket.h>
208 /* These next two vars are non-static since sysdep.c uses them in the
209 emulation of `select'. */
210 /* Number of events of change of status of a process. */
212 /* Number of events for which the user or sentinel has been notified. */
215 #include "sysselect.h"
217 /* If we support a window system, turn on the code to poll periodically
218 to detect C-g. It isn't actually used when doing interrupt input. */
219 #ifdef HAVE_WINDOW_SYSTEM
220 #define POLL_FOR_INPUT
223 /* Mask of bits indicating the descriptors that we wait for input on. */
225 static SELECT_TYPE input_wait_mask
;
227 /* Mask that excludes keyboard input descriptor (s). */
229 static SELECT_TYPE non_keyboard_wait_mask
;
231 /* Mask that excludes process input descriptor (s). */
233 static SELECT_TYPE non_process_wait_mask
;
235 /* The largest descriptor currently in use for a process object. */
236 static int max_process_desc
;
238 /* The largest descriptor currently in use for keyboard input. */
239 static int max_keyboard_desc
;
241 /* Nonzero means delete a process right away if it exits. */
242 static int delete_exited_processes
;
244 /* Indexed by descriptor, gives the process (if any) for that descriptor */
245 Lisp_Object chan_process
[MAXDESC
];
247 /* Alist of elements (NAME . PROCESS) */
248 Lisp_Object Vprocess_alist
;
250 /* Buffered-ahead input char from process, indexed by channel.
251 -1 means empty (no char is buffered).
252 Used on sys V where the only way to tell if there is any
253 output from the process is to read at least one char.
254 Always -1 on systems that support FIONREAD. */
256 /* Don't make static; need to access externally. */
257 int proc_buffered_char
[MAXDESC
];
259 /* Table of `struct coding-system' for each process. */
260 static struct coding_system
*proc_decode_coding_system
[MAXDESC
];
261 static struct coding_system
*proc_encode_coding_system
[MAXDESC
];
263 static Lisp_Object
get_process ();
265 extern EMACS_TIME
timer_check ();
266 extern int timers_run
;
268 /* Maximum number of bytes to send to a pty without an eof. */
269 static int pty_max_bytes
;
271 extern Lisp_Object Vfile_name_coding_system
, Vdefault_file_name_coding_system
;
274 /* The file name of the pty opened by allocate_pty. */
276 static char pty_name
[24];
279 /* Compute the Lisp form of the process status, p->status, from
280 the numeric status that was returned by `wait'. */
282 Lisp_Object
status_convert ();
286 struct Lisp_Process
*p
;
288 union { int i
; WAITTYPE wt
; } u
;
289 u
.i
= XFASTINT (p
->raw_status_low
) + (XFASTINT (p
->raw_status_high
) << 16);
290 p
->status
= status_convert (u
.wt
);
291 p
->raw_status_low
= Qnil
;
292 p
->raw_status_high
= Qnil
;
295 /* Convert a process status word in Unix format to
296 the list that we use internally. */
303 return Fcons (Qstop
, Fcons (make_number (WSTOPSIG (w
)), Qnil
));
304 else if (WIFEXITED (w
))
305 return Fcons (Qexit
, Fcons (make_number (WRETCODE (w
)),
306 WCOREDUMP (w
) ? Qt
: Qnil
));
307 else if (WIFSIGNALED (w
))
308 return Fcons (Qsignal
, Fcons (make_number (WTERMSIG (w
)),
309 WCOREDUMP (w
) ? Qt
: Qnil
));
314 /* Given a status-list, extract the three pieces of information
315 and store them individually through the three pointers. */
318 decode_status (l
, symbol
, code
, coredump
)
336 *code
= XFASTINT (XCAR (tem
));
338 *coredump
= !NILP (tem
);
342 /* Return a string describing a process status list. */
345 status_message (status
)
350 Lisp_Object string
, string2
;
352 decode_status (status
, &symbol
, &code
, &coredump
);
354 if (EQ (symbol
, Qsignal
) || EQ (symbol
, Qstop
))
360 /* Cast to suppress warning if the table has const char *. */
361 signame
= (char *) sys_siglist
[code
];
363 signame
= sys_errlist
[code
];
368 string
= build_string (signame
);
369 string2
= build_string (coredump
? " (core dumped)\n" : "\n");
370 XSTRING (string
)->data
[0] = DOWNCASE (XSTRING (string
)->data
[0]);
371 return concat2 (string
, string2
);
373 else if (EQ (symbol
, Qexit
))
376 return build_string ("finished\n");
377 string
= Fnumber_to_string (make_number (code
));
378 string2
= build_string (coredump
? " (core dumped)\n" : "\n");
379 return concat2 (build_string ("exited abnormally with code "),
380 concat2 (string
, string2
));
383 return Fcopy_sequence (Fsymbol_name (symbol
));
388 /* Open an available pty, returning a file descriptor.
389 Return -1 on failure.
390 The file name of the terminal corresponding to the pty
391 is left in the variable pty_name. */
400 /* Some systems name their pseudoterminals so that there are gaps in
401 the usual sequence - for example, on HP9000/S700 systems, there
402 are no pseudoterminals with names ending in 'f'. So we wait for
403 three failures in a row before deciding that we've reached the
405 int failed_count
= 0;
410 for (c
= FIRST_PTY_LETTER
; c
<= 'z'; c
++)
411 for (i
= 0; i
< 16; i
++)
414 #ifdef PTY_NAME_SPRINTF
417 sprintf (pty_name
, "/dev/pty%c%x", c
, i
);
418 #endif /* no PTY_NAME_SPRINTF */
422 #else /* no PTY_OPEN */
424 /* Unusual IRIS code */
425 *ptyv
= open ("/dev/ptc", O_RDWR
| O_NDELAY
, 0);
428 if (fstat (fd
, &stb
) < 0)
431 if (stat (pty_name
, &stb
) < 0)
434 if (failed_count
>= 3)
440 fd
= open (pty_name
, O_RDWR
| O_NONBLOCK
, 0);
442 fd
= open (pty_name
, O_RDWR
| O_NDELAY
, 0);
444 #endif /* not IRIS */
445 #endif /* no PTY_OPEN */
449 /* check to make certain that both sides are available
450 this avoids a nasty yet stupid bug in rlogins */
451 #ifdef PTY_TTY_NAME_SPRINTF
454 sprintf (pty_name
, "/dev/tty%c%x", c
, i
);
455 #endif /* no PTY_TTY_NAME_SPRINTF */
457 if (access (pty_name
, 6) != 0)
460 #if !defined(IRIS) && !defined(__sgi)
466 #endif /* not UNIPLUS */
473 #endif /* HAVE_PTYS */
479 struct Lisp_Vector
*vec
;
480 register Lisp_Object val
, tem
, name1
;
481 register struct Lisp_Process
*p
;
485 vec
= allocate_vectorlike ((EMACS_INT
) VECSIZE (struct Lisp_Process
));
486 for (i
= 0; i
< VECSIZE (struct Lisp_Process
); i
++)
487 vec
->contents
[i
] = Qnil
;
488 vec
->size
= VECSIZE (struct Lisp_Process
);
489 p
= (struct Lisp_Process
*)vec
;
491 XSETINT (p
->infd
, -1);
492 XSETINT (p
->outfd
, -1);
493 XSETFASTINT (p
->pid
, 0);
494 XSETFASTINT (p
->tick
, 0);
495 XSETFASTINT (p
->update_tick
, 0);
496 p
->raw_status_low
= Qnil
;
497 p
->raw_status_high
= Qnil
;
499 p
->mark
= Fmake_marker ();
501 /* If name is already in use, modify it until it is unused. */
506 tem
= Fget_process (name1
);
507 if (NILP (tem
)) break;
508 sprintf (suffix
, "<%d>", i
);
509 name1
= concat2 (name
, build_string (suffix
));
513 XSETPROCESS (val
, p
);
514 Vprocess_alist
= Fcons (Fcons (name
, val
), Vprocess_alist
);
519 remove_process (proc
)
520 register Lisp_Object proc
;
522 register Lisp_Object pair
;
524 pair
= Frassq (proc
, Vprocess_alist
);
525 Vprocess_alist
= Fdelq (pair
, Vprocess_alist
);
527 deactivate_process (proc
);
530 DEFUN ("processp", Fprocessp
, Sprocessp
, 1, 1, 0,
531 "Return t if OBJECT is a process.")
535 return PROCESSP (object
) ? Qt
: Qnil
;
538 DEFUN ("get-process", Fget_process
, Sget_process
, 1, 1, 0,
539 "Return the process named NAME, or nil if there is none.")
541 register Lisp_Object name
;
545 CHECK_STRING (name
, 0);
546 return Fcdr (Fassoc (name
, Vprocess_alist
));
549 DEFUN ("get-buffer-process", Fget_buffer_process
, Sget_buffer_process
, 1, 1, 0,
550 "Return the (or a) process associated with BUFFER.\n\
551 BUFFER may be a buffer or the name of one.")
553 register Lisp_Object buffer
;
555 register Lisp_Object buf
, tail
, proc
;
557 if (NILP (buffer
)) return Qnil
;
558 buf
= Fget_buffer (buffer
);
559 if (NILP (buf
)) return Qnil
;
561 for (tail
= Vprocess_alist
; !NILP (tail
); tail
= Fcdr (tail
))
563 proc
= Fcdr (Fcar (tail
));
564 if (PROCESSP (proc
) && EQ (XPROCESS (proc
)->buffer
, buf
))
570 /* This is how commands for the user decode process arguments. It
571 accepts a process, a process name, a buffer, a buffer name, or nil.
572 Buffers denote the first process in the buffer, and nil denotes the
577 register Lisp_Object name
;
579 register Lisp_Object proc
, obj
;
582 obj
= Fget_process (name
);
584 obj
= Fget_buffer (name
);
586 error ("Process %s does not exist", XSTRING (name
)->data
);
588 else if (NILP (name
))
589 obj
= Fcurrent_buffer ();
593 /* Now obj should be either a buffer object or a process object.
597 proc
= Fget_buffer_process (obj
);
599 error ("Buffer %s has no process", XSTRING (XBUFFER (obj
)->name
)->data
);
603 CHECK_PROCESS (obj
, 0);
609 DEFUN ("delete-process", Fdelete_process
, Sdelete_process
, 1, 1, 0,
610 "Delete PROCESS: kill it and forget about it immediately.\n\
611 PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
612 nil, indicating the current buffer's process.")
614 register Lisp_Object process
;
616 process
= get_process (process
);
617 XPROCESS (process
)->raw_status_low
= Qnil
;
618 XPROCESS (process
)->raw_status_high
= Qnil
;
619 if (NETCONN_P (process
))
621 XPROCESS (process
)->status
= Fcons (Qexit
, Fcons (make_number (0), Qnil
));
622 XSETINT (XPROCESS (process
)->tick
, ++process_tick
);
624 else if (XINT (XPROCESS (process
)->infd
) >= 0)
626 Fkill_process (process
, Qnil
);
627 /* Do this now, since remove_process will make sigchld_handler do nothing. */
628 XPROCESS (process
)->status
629 = Fcons (Qsignal
, Fcons (make_number (SIGKILL
), Qnil
));
630 XSETINT (XPROCESS (process
)->tick
, ++process_tick
);
633 remove_process (process
);
637 DEFUN ("process-status", Fprocess_status
, Sprocess_status
, 1, 1, 0,
638 "Return the status of PROCESS.\n\
639 The returned value is one of the following symbols:\n\
640 run -- for a process that is running.\n\
641 stop -- for a process stopped but continuable.\n\
642 exit -- for a process that has exited.\n\
643 signal -- for a process that has got a fatal signal.\n\
644 open -- for a network stream connection that is open.\n\
645 closed -- for a network stream connection that is closed.\n\
646 nil -- if arg is a process name and no such process exists.\n\
647 PROCESS may be a process, a buffer, the name of a process, or\n\
648 nil, indicating the current buffer's process.")
650 register Lisp_Object process
;
652 register struct Lisp_Process
*p
;
653 register Lisp_Object status
;
655 if (STRINGP (process
))
656 process
= Fget_process (process
);
658 process
= get_process (process
);
663 p
= XPROCESS (process
);
664 if (!NILP (p
->raw_status_low
))
668 status
= XCAR (status
);
669 if (NETCONN_P (process
))
671 if (EQ (status
, Qrun
))
673 else if (EQ (status
, Qexit
))
679 DEFUN ("process-exit-status", Fprocess_exit_status
, Sprocess_exit_status
,
681 "Return the exit status of PROCESS or the signal number that killed it.\n\
682 If PROCESS has not yet exited or died, return 0.")
684 register Lisp_Object process
;
686 CHECK_PROCESS (process
, 0);
687 if (!NILP (XPROCESS (process
)->raw_status_low
))
688 update_status (XPROCESS (process
));
689 if (CONSP (XPROCESS (process
)->status
))
690 return XCAR (XCDR (XPROCESS (process
)->status
));
691 return make_number (0);
694 DEFUN ("process-id", Fprocess_id
, Sprocess_id
, 1, 1, 0,
695 "Return the process id of PROCESS.\n\
696 This is the pid of the Unix process which PROCESS uses or talks to.\n\
697 For a network connection, this value is nil.")
699 register Lisp_Object process
;
701 CHECK_PROCESS (process
, 0);
702 return XPROCESS (process
)->pid
;
705 DEFUN ("process-name", Fprocess_name
, Sprocess_name
, 1, 1, 0,
706 "Return the name of PROCESS, as a string.\n\
707 This is the name of the program invoked in PROCESS,\n\
708 possibly modified to make it unique among process names.")
710 register Lisp_Object process
;
712 CHECK_PROCESS (process
, 0);
713 return XPROCESS (process
)->name
;
716 DEFUN ("process-command", Fprocess_command
, Sprocess_command
, 1, 1, 0,
717 "Return the command that was executed to start PROCESS.\n\
718 This is a list of strings, the first string being the program executed\n\
719 and the rest of the strings being the arguments given to it.\n\
720 For a non-child channel, this is nil.")
722 register Lisp_Object process
;
724 CHECK_PROCESS (process
, 0);
725 return XPROCESS (process
)->command
;
728 DEFUN ("process-tty-name", Fprocess_tty_name
, Sprocess_tty_name
, 1, 1, 0,
729 "Return the name of the terminal PROCESS uses, or nil if none.\n\
730 This is the terminal that the process itself reads and writes on,\n\
731 not the name of the pty that Emacs uses to talk with that terminal.")
733 register Lisp_Object process
;
735 CHECK_PROCESS (process
, 0);
736 return XPROCESS (process
)->tty_name
;
739 DEFUN ("set-process-buffer", Fset_process_buffer
, Sset_process_buffer
,
741 "Set buffer associated with PROCESS to BUFFER (a buffer, or nil).")
743 register Lisp_Object process
, buffer
;
745 CHECK_PROCESS (process
, 0);
747 CHECK_BUFFER (buffer
, 1);
748 XPROCESS (process
)->buffer
= buffer
;
752 DEFUN ("process-buffer", Fprocess_buffer
, Sprocess_buffer
,
754 "Return the buffer PROCESS is associated with.\n\
755 Output from PROCESS is inserted in this buffer unless PROCESS has a filter.")
757 register Lisp_Object process
;
759 CHECK_PROCESS (process
, 0);
760 return XPROCESS (process
)->buffer
;
763 DEFUN ("process-mark", Fprocess_mark
, Sprocess_mark
,
765 "Return the marker for the end of the last output from PROCESS.")
767 register Lisp_Object process
;
769 CHECK_PROCESS (process
, 0);
770 return XPROCESS (process
)->mark
;
773 DEFUN ("set-process-filter", Fset_process_filter
, Sset_process_filter
,
775 "Give PROCESS the filter function FILTER; nil means no filter.\n\
776 t means stop accepting output from the process.\n\
777 When a process has a filter, each time it does output\n\
778 the entire string of output is passed to the filter.\n\
779 The filter gets two arguments: the process and the string of output.\n\
780 If the process has a filter, its buffer is not used for output.")
782 register Lisp_Object process
, filter
;
784 CHECK_PROCESS (process
, 0);
787 FD_CLR (XINT (XPROCESS (process
)->infd
), &input_wait_mask
);
788 FD_CLR (XINT (XPROCESS (process
)->infd
), &non_keyboard_wait_mask
);
790 else if (EQ (XPROCESS (process
)->filter
, Qt
))
792 FD_SET (XINT (XPROCESS (process
)->infd
), &input_wait_mask
);
793 FD_SET (XINT (XPROCESS (process
)->infd
), &non_keyboard_wait_mask
);
795 XPROCESS (process
)->filter
= filter
;
799 DEFUN ("process-filter", Fprocess_filter
, Sprocess_filter
,
801 "Returns the filter function of PROCESS; nil if none.\n\
802 See `set-process-filter' for more info on filter functions.")
804 register Lisp_Object process
;
806 CHECK_PROCESS (process
, 0);
807 return XPROCESS (process
)->filter
;
810 DEFUN ("set-process-sentinel", Fset_process_sentinel
, Sset_process_sentinel
,
812 "Give PROCESS the sentinel SENTINEL; nil for none.\n\
813 The sentinel is called as a function when the process changes state.\n\
814 It gets two arguments: the process, and a string describing the change.")
816 register Lisp_Object process
, sentinel
;
818 CHECK_PROCESS (process
, 0);
819 XPROCESS (process
)->sentinel
= sentinel
;
823 DEFUN ("process-sentinel", Fprocess_sentinel
, Sprocess_sentinel
,
825 "Return the sentinel of PROCESS; nil if none.\n\
826 See `set-process-sentinel' for more info on sentinels.")
828 register Lisp_Object process
;
830 CHECK_PROCESS (process
, 0);
831 return XPROCESS (process
)->sentinel
;
834 DEFUN ("set-process-window-size", Fset_process_window_size
,
835 Sset_process_window_size
, 3, 3, 0,
836 "Tell PROCESS that it has logical window size HEIGHT and WIDTH.")
837 (process
, height
, width
)
838 register Lisp_Object process
, height
, width
;
840 CHECK_PROCESS (process
, 0);
841 CHECK_NATNUM (height
, 0);
842 CHECK_NATNUM (width
, 0);
843 if (set_window_size (XINT (XPROCESS (process
)->infd
),
844 XINT (height
), XINT (width
)) <= 0)
850 DEFUN ("set-process-inherit-coding-system-flag",
851 Fset_process_inherit_coding_system_flag
,
852 Sset_process_inherit_coding_system_flag
, 2, 2, 0,
853 "Determine whether buffer of PROCESS will inherit coding-system.\n\
854 If the second argument FLAG is non-nil, then the variable\n\
855 `buffer-file-coding-system' of the buffer associated with PROCESS\n\
856 will be bound to the value of the coding system used to decode\n\
857 the process output.\n\
859 This is useful when the coding system specified for the process buffer\n\
860 leaves either the character code conversion or the end-of-line conversion\n\
861 unspecified, or if the coding system used to decode the process output\n\
862 is more appropriate for saving the process buffer.\n\
864 Binding the variable `inherit-process-coding-system' to non-nil before\n\
865 starting the process is an alternative way of setting the inherit flag\n\
866 for the process which will run.")
868 register Lisp_Object process
, flag
;
870 CHECK_PROCESS (process
, 0);
871 XPROCESS (process
)->inherit_coding_system_flag
= flag
;
875 DEFUN ("process-inherit-coding-system-flag",
876 Fprocess_inherit_coding_system_flag
, Sprocess_inherit_coding_system_flag
,
878 "Return the value of inherit-coding-system flag for PROCESS.\n\
879 If this flag is t, `buffer-file-coding-system' of the buffer\n\
880 associated with PROCESS will inherit the coding system used to decode\n\
881 the process output.")
883 register Lisp_Object process
;
885 CHECK_PROCESS (process
, 0);
886 return XPROCESS (process
)->inherit_coding_system_flag
;
889 DEFUN ("process-kill-without-query", Fprocess_kill_without_query
,
890 Sprocess_kill_without_query
, 1, 2, 0,
891 "Say no query needed if PROCESS is running when Emacs is exited.\n\
892 Optional second argument if non-nil says to require a query.\n\
893 Value is t if a query was formerly required.")
895 register Lisp_Object process
, value
;
899 CHECK_PROCESS (process
, 0);
900 tem
= XPROCESS (process
)->kill_without_query
;
901 XPROCESS (process
)->kill_without_query
= Fnull (value
);
906 DEFUN ("process-contact", Fprocess_contact
, Sprocess_contact
,
908 "Return the contact info of PROCESS; t for a real child.\n\
909 For a net connection, the value is a cons cell of the form (HOST SERVICE).")
911 register Lisp_Object process
;
913 CHECK_PROCESS (process
, 0);
914 return XPROCESS (process
)->childp
;
917 #if 0 /* Turned off because we don't currently record this info
918 in the process. Perhaps add it. */
919 DEFUN ("process-connection", Fprocess_connection
, Sprocess_connection
, 1, 1, 0,
920 "Return the connection type of PROCESS.\n\
921 The value is nil for a pipe, t or `pty' for a pty, or `stream' for\n\
922 a socket connection.")
926 return XPROCESS (process
)->type
;
933 register Lisp_Object tail
, tem
;
934 Lisp_Object proc
, minspace
, tem1
;
935 register struct buffer
*old
= current_buffer
;
936 register struct Lisp_Process
*p
;
940 XSETFASTINT (minspace
, 1);
942 set_buffer_internal (XBUFFER (Vstandard_output
));
943 Fbuffer_disable_undo (Vstandard_output
);
945 current_buffer
->truncate_lines
= Qt
;
948 Proc Status Buffer Tty Command\n\
949 ---- ------ ------ --- -------\n", -1);
951 for (tail
= Vprocess_alist
; !NILP (tail
); tail
= Fcdr (tail
))
955 proc
= Fcdr (Fcar (tail
));
957 if (NILP (p
->childp
))
960 Finsert (1, &p
->name
);
961 Findent_to (make_number (13), minspace
);
963 if (!NILP (p
->raw_status_low
))
966 if (CONSP (p
->status
))
967 symbol
= XCAR (p
->status
);
970 if (EQ (symbol
, Qsignal
))
973 tem
= Fcar (Fcdr (p
->status
));
975 if (XINT (tem
) < NSIG
)
976 write_string (sys_errlist
[XINT (tem
)], -1);
979 Fprinc (symbol
, Qnil
);
981 else if (NETCONN_P (proc
))
983 if (EQ (symbol
, Qrun
))
984 write_string ("open", -1);
985 else if (EQ (symbol
, Qexit
))
986 write_string ("closed", -1);
988 Fprinc (symbol
, Qnil
);
991 Fprinc (symbol
, Qnil
);
993 if (EQ (symbol
, Qexit
))
996 tem
= Fcar (Fcdr (p
->status
));
999 sprintf (tembuf
, " %d", (int) XFASTINT (tem
));
1000 write_string (tembuf
, -1);
1004 if (EQ (symbol
, Qsignal
) || EQ (symbol
, Qexit
))
1005 remove_process (proc
);
1007 Findent_to (make_number (22), minspace
);
1008 if (NILP (p
->buffer
))
1009 insert_string ("(none)");
1010 else if (NILP (XBUFFER (p
->buffer
)->name
))
1011 insert_string ("(Killed)");
1013 Finsert (1, &XBUFFER (p
->buffer
)->name
);
1015 Findent_to (make_number (37), minspace
);
1017 if (STRINGP (p
->tty_name
))
1018 Finsert (1, &p
->tty_name
);
1020 insert_string ("(none)");
1022 Findent_to (make_number (49), minspace
);
1024 if (NETCONN_P (proc
))
1026 sprintf (tembuf
, "(network stream connection to %s)\n",
1027 XSTRING (XCAR (p
->childp
))->data
);
1028 insert_string (tembuf
);
1040 insert_string (" ");
1042 insert_string ("\n");
1048 DEFUN ("list-processes", Flist_processes
, Slist_processes
, 0, 0, "",
1049 "Display a list of all processes.\n\
1050 Any process listed as exited or signaled is actually eliminated\n\
1051 after the listing is made.")
1054 internal_with_output_to_temp_buffer ("*Process List*",
1055 list_processes_1
, Qnil
);
1059 DEFUN ("process-list", Fprocess_list
, Sprocess_list
, 0, 0, 0,
1060 "Return a list of all processes.")
1063 return Fmapcar (Qcdr
, Vprocess_alist
);
1066 /* Starting asynchronous inferior processes. */
1068 static Lisp_Object
start_process_unwind ();
1070 DEFUN ("start-process", Fstart_process
, Sstart_process
, 3, MANY
, 0,
1071 "Start a program in a subprocess. Return the process object for it.\n\
1072 Args are NAME BUFFER PROGRAM &rest PROGRAM-ARGS\n\
1073 NAME is name for process. It is modified if necessary to make it unique.\n\
1074 BUFFER is the buffer or (buffer-name) to associate with the process.\n\
1075 Process output goes at end of that buffer, unless you specify\n\
1076 an output stream or filter function to handle the output.\n\
1077 BUFFER may be also nil, meaning that this process is not associated\n\
1079 Third arg is program file name. It is searched for in PATH.\n\
1080 Remaining arguments are strings to give program as arguments.")
1083 register Lisp_Object
*args
;
1085 Lisp_Object buffer
, name
, program
, proc
, current_dir
, tem
;
1087 register unsigned char *new_argv
;
1090 register unsigned char **new_argv
;
1093 int count
= specpdl_ptr
- specpdl
;
1097 buffer
= Fget_buffer_create (buffer
);
1099 /* Make sure that the child will be able to chdir to the current
1100 buffer's current directory, or its unhandled equivalent. We
1101 can't just have the child check for an error when it does the
1102 chdir, since it's in a vfork.
1104 We have to GCPRO around this because Fexpand_file_name and
1105 Funhandled_file_name_directory might call a file name handling
1106 function. The argument list is protected by the caller, so all
1107 we really have to worry about is buffer. */
1109 struct gcpro gcpro1
, gcpro2
;
1111 current_dir
= current_buffer
->directory
;
1113 GCPRO2 (buffer
, current_dir
);
1116 = expand_and_dir_to_file (Funhandled_file_name_directory (current_dir
),
1118 if (NILP (Ffile_accessible_directory_p (current_dir
)))
1119 report_file_error ("Setting current directory",
1120 Fcons (current_buffer
->directory
, Qnil
));
1126 CHECK_STRING (name
, 0);
1130 CHECK_STRING (program
, 2);
1133 /* Make a one member argv with all args concatenated
1134 together separated by a blank. */
1135 len
= STRING_BYTES (XSTRING (program
)) + 2;
1136 for (i
= 3; i
< nargs
; i
++)
1139 CHECK_STRING (tem
, i
);
1140 len
+= STRING_BYTES (XSTRING (tem
)) + 1; /* count the blank */
1142 new_argv
= (unsigned char *) alloca (len
);
1143 strcpy (new_argv
, XSTRING (program
)->data
);
1144 for (i
= 3; i
< nargs
; i
++)
1147 CHECK_STRING (tem
, i
);
1148 strcat (new_argv
, " ");
1149 strcat (new_argv
, XSTRING (tem
)->data
);
1151 /* Need to add code here to check for program existence on VMS */
1154 new_argv
= (unsigned char **) alloca ((nargs
- 1) * sizeof (char *));
1156 /* If program file name is not absolute, search our path for it */
1157 if (!IS_DIRECTORY_SEP (XSTRING (program
)->data
[0])
1158 && !(XSTRING (program
)->size
> 1
1159 && IS_DEVICE_SEP (XSTRING (program
)->data
[1])))
1161 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1164 GCPRO4 (name
, program
, buffer
, current_dir
);
1165 openp (Vexec_path
, program
, EXEC_SUFFIXES
, &tem
, 1);
1168 report_file_error ("Searching for program", Fcons (program
, Qnil
));
1169 tem
= Fexpand_file_name (tem
, Qnil
);
1170 new_argv
[0] = XSTRING (tem
)->data
;
1174 if (!NILP (Ffile_directory_p (program
)))
1175 error ("Specified program for new process is a directory");
1177 new_argv
[0] = XSTRING (program
)->data
;
1180 for (i
= 3; i
< nargs
; i
++)
1183 CHECK_STRING (tem
, i
);
1184 new_argv
[i
- 2] = XSTRING (tem
)->data
;
1186 new_argv
[i
- 2] = 0;
1187 #endif /* not VMS */
1189 proc
= make_process (name
);
1190 /* If an error occurs and we can't start the process, we want to
1191 remove it from the process list. This means that each error
1192 check in create_process doesn't need to call remove_process
1193 itself; it's all taken care of here. */
1194 record_unwind_protect (start_process_unwind
, proc
);
1196 XPROCESS (proc
)->childp
= Qt
;
1197 XPROCESS (proc
)->command_channel_p
= Qnil
;
1198 XPROCESS (proc
)->buffer
= buffer
;
1199 XPROCESS (proc
)->sentinel
= Qnil
;
1200 XPROCESS (proc
)->filter
= Qnil
;
1201 XPROCESS (proc
)->command
= Flist (nargs
- 2, args
+ 2);
1203 /* Make the process marker point into the process buffer (if any). */
1205 set_marker_both (XPROCESS (proc
)->mark
, buffer
,
1206 BUF_ZV (XBUFFER (buffer
)),
1207 BUF_ZV_BYTE (XBUFFER (buffer
)));
1210 /* Decide coding systems for communicating with the process. Here
1211 we don't setup the structure coding_system nor pay attention to
1212 unibyte mode. They are done in create_process. */
1214 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
1215 Lisp_Object coding_systems
= Qt
;
1216 Lisp_Object val
, *args2
;
1217 struct gcpro gcpro1
;
1219 val
= Vcoding_system_for_read
;
1222 args2
= (Lisp_Object
*) alloca ((nargs
+ 1) * sizeof *args2
);
1223 args2
[0] = Qstart_process
;
1224 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
1226 coding_systems
= Ffind_operation_coding_system (nargs
+ 1, args2
);
1228 if (CONSP (coding_systems
))
1229 val
= XCAR (coding_systems
);
1230 else if (CONSP (Vdefault_process_coding_system
))
1231 val
= XCAR (Vdefault_process_coding_system
);
1233 XPROCESS (proc
)->decode_coding_system
= val
;
1235 val
= Vcoding_system_for_write
;
1238 if (EQ (coding_systems
, Qt
))
1240 args2
= (Lisp_Object
*) alloca ((nargs
+ 1) * sizeof args2
);
1241 args2
[0] = Qstart_process
;
1242 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
1244 coding_systems
= Ffind_operation_coding_system (nargs
+ 1, args2
);
1247 if (CONSP (coding_systems
))
1248 val
= XCDR (coding_systems
);
1249 else if (CONSP (Vdefault_process_coding_system
))
1250 val
= XCDR (Vdefault_process_coding_system
);
1252 XPROCESS (proc
)->encode_coding_system
= val
;
1255 XPROCESS (proc
)->decoding_buf
= make_uninit_string (0);
1256 XPROCESS (proc
)->decoding_carryover
= make_number (0);
1257 XPROCESS (proc
)->encoding_buf
= make_uninit_string (0);
1258 XPROCESS (proc
)->encoding_carryover
= make_number (0);
1260 XPROCESS (proc
)->inherit_coding_system_flag
1261 = (NILP (buffer
) || !inherit_process_coding_system
1264 create_process (proc
, (char **) new_argv
, current_dir
);
1266 return unbind_to (count
, proc
);
1269 /* This function is the unwind_protect form for Fstart_process. If
1270 PROC doesn't have its pid set, then we know someone has signaled
1271 an error and the process wasn't started successfully, so we should
1272 remove it from the process list. */
1274 start_process_unwind (proc
)
1277 if (!PROCESSP (proc
))
1280 /* Was PROC started successfully? */
1281 if (XINT (XPROCESS (proc
)->pid
) <= 0)
1282 remove_process (proc
);
1289 create_process_1 (signo
)
1292 #if defined (USG) && !defined (POSIX_SIGNALS)
1293 /* USG systems forget handlers when they are used;
1294 must reestablish each time */
1295 signal (signo
, create_process_1
);
1299 #if 0 /* This doesn't work; see the note before sigchld_handler. */
1302 /* Mimic blocking of signals on system V, which doesn't really have it. */
1304 /* Nonzero means we got a SIGCHLD when it was supposed to be blocked. */
1305 int sigchld_deferred
;
1308 create_process_sigchld ()
1310 signal (SIGCHLD
, create_process_sigchld
);
1312 sigchld_deferred
= 1;
1318 #ifndef VMS /* VMS version of this function is in vmsproc.c. */
1320 create_process (process
, new_argv
, current_dir
)
1321 Lisp_Object process
;
1323 Lisp_Object current_dir
;
1325 int pid
, inchannel
, outchannel
;
1327 #ifdef POSIX_SIGNALS
1330 struct sigaction sigint_action
;
1331 struct sigaction sigquit_action
;
1333 struct sigaction sighup_action
;
1335 #else /* !POSIX_SIGNALS */
1337 SIGTYPE (*sigchld
)();
1339 #endif /* !POSIX_SIGNALS */
1340 /* Use volatile to protect variables from being clobbered by longjmp. */
1341 volatile int forkin
, forkout
;
1342 volatile int pty_flag
= 0;
1343 extern char **environ
;
1344 Lisp_Object buffer
= XPROCESS (process
)->buffer
;
1346 inchannel
= outchannel
= -1;
1349 if (!NILP (Vprocess_connection_type
))
1350 outchannel
= inchannel
= allocate_pty ();
1355 /* On USG systems it does not work to open the pty's tty here
1356 and then close and reopen it in the child. */
1358 /* Don't let this terminal become our controlling terminal
1359 (in case we don't have one). */
1360 forkout
= forkin
= open (pty_name
, O_RDWR
| O_NOCTTY
, 0);
1362 forkout
= forkin
= open (pty_name
, O_RDWR
, 0);
1365 report_file_error ("Opening pty", Qnil
);
1367 forkin
= forkout
= -1;
1368 #endif /* not USG */
1372 #endif /* HAVE_PTYS */
1375 if (socketpair (AF_UNIX
, SOCK_STREAM
, 0, sv
) < 0)
1376 report_file_error ("Opening socketpair", Qnil
);
1377 outchannel
= inchannel
= sv
[0];
1378 forkout
= forkin
= sv
[1];
1380 #else /* not SKTPAIR */
1385 report_file_error ("Creating pipe", Qnil
);
1393 report_file_error ("Creating pipe", Qnil
);
1398 #endif /* not SKTPAIR */
1401 /* Replaced by close_process_descs */
1402 set_exclusive_use (inchannel
);
1403 set_exclusive_use (outchannel
);
1406 /* Stride people say it's a mystery why this is needed
1407 as well as the O_NDELAY, but that it fails without this. */
1408 #if defined (STRIDE) || (defined (pfa) && defined (HAVE_PTYS))
1411 ioctl (inchannel
, FIONBIO
, &one
);
1416 fcntl (inchannel
, F_SETFL
, O_NONBLOCK
);
1417 fcntl (outchannel
, F_SETFL
, O_NONBLOCK
);
1420 fcntl (inchannel
, F_SETFL
, O_NDELAY
);
1421 fcntl (outchannel
, F_SETFL
, O_NDELAY
);
1425 /* Record this as an active process, with its channels.
1426 As a result, child_setup will close Emacs's side of the pipes. */
1427 chan_process
[inchannel
] = process
;
1428 XSETINT (XPROCESS (process
)->infd
, inchannel
);
1429 XSETINT (XPROCESS (process
)->outfd
, outchannel
);
1430 /* Record the tty descriptor used in the subprocess. */
1432 XPROCESS (process
)->subtty
= Qnil
;
1434 XSETFASTINT (XPROCESS (process
)->subtty
, forkin
);
1435 XPROCESS (process
)->pty_flag
= (pty_flag
? Qt
: Qnil
);
1436 XPROCESS (process
)->status
= Qrun
;
1437 if (!proc_decode_coding_system
[inchannel
])
1438 proc_decode_coding_system
[inchannel
]
1439 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
1440 setup_coding_system (XPROCESS (process
)->decode_coding_system
,
1441 proc_decode_coding_system
[inchannel
]);
1442 if (!proc_encode_coding_system
[outchannel
])
1443 proc_encode_coding_system
[outchannel
]
1444 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
1445 setup_coding_system (XPROCESS (process
)->encode_coding_system
,
1446 proc_encode_coding_system
[outchannel
]);
1448 if (!NILP (buffer
) && NILP (XBUFFER (buffer
)->enable_multibyte_characters
)
1449 || (NILP (buffer
) && NILP (buffer_defaults
.enable_multibyte_characters
)))
1451 /* In unibyte mode, character code conversion should not take
1452 place but EOL conversion should. So, setup raw-text or one
1453 of the subsidiary according to the information just setup. */
1454 if (!NILP (XPROCESS (process
)->decode_coding_system
))
1455 setup_raw_text_coding_system (proc_decode_coding_system
[inchannel
]);
1456 if (!NILP (XPROCESS (process
)->encode_coding_system
))
1457 setup_raw_text_coding_system (proc_encode_coding_system
[outchannel
]);
1460 if (CODING_REQUIRE_ENCODING (proc_encode_coding_system
[outchannel
]))
1462 /* Here we encode arguments by the coding system used for
1463 sending data to the process. We don't support using
1464 different coding systems for encoding arguments and for
1465 encoding data sent to the process. */
1466 struct gcpro gcpro1
;
1468 struct coding_system
*coding
= proc_encode_coding_system
[outchannel
];
1470 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
1472 while (new_argv
[i
] != 0)
1474 int len
= strlen (new_argv
[i
]);
1475 int size
= encoding_buffer_size (coding
, len
);
1476 unsigned char *buf
= (unsigned char *) alloca (size
);
1478 encode_coding (coding
, (unsigned char *)new_argv
[i
], buf
, len
, size
);
1479 buf
[coding
->produced
] = 0;
1480 /* We don't have to free new_argv[i] because it points to a
1481 Lisp string given as an argument to `start-process'. */
1482 new_argv
[i
++] = (char *) buf
;
1485 coding
->mode
&= ~CODING_MODE_LAST_BLOCK
;
1488 /* Delay interrupts until we have a chance to store
1489 the new fork's pid in its process structure */
1490 #ifdef POSIX_SIGNALS
1491 sigemptyset (&blocked
);
1493 sigaddset (&blocked
, SIGCHLD
);
1496 /* On many hosts (e.g. Solaris 2.4), if a vforked child calls `signal',
1497 this sets the parent's signal handlers as well as the child's.
1498 So delay all interrupts whose handlers the child might munge,
1499 and record the current handlers so they can be restored later. */
1500 sigaddset (&blocked
, SIGINT
); sigaction (SIGINT
, 0, &sigint_action
);
1501 sigaddset (&blocked
, SIGQUIT
); sigaction (SIGQUIT
, 0, &sigquit_action
);
1503 sigaddset (&blocked
, SIGHUP
); sigaction (SIGHUP
, 0, &sighup_action
);
1505 #endif /* HAVE_VFORK */
1506 sigprocmask (SIG_BLOCK
, &blocked
, &procmask
);
1507 #else /* !POSIX_SIGNALS */
1511 #else /* not BSD4_1 */
1512 #if defined (BSD_SYSTEM) || defined (UNIPLUS) || defined (HPUX)
1513 sigsetmask (sigmask (SIGCHLD
));
1514 #else /* ordinary USG */
1516 sigchld_deferred
= 0;
1517 sigchld
= signal (SIGCHLD
, create_process_sigchld
);
1519 #endif /* ordinary USG */
1520 #endif /* not BSD4_1 */
1521 #endif /* SIGCHLD */
1522 #endif /* !POSIX_SIGNALS */
1524 FD_SET (inchannel
, &input_wait_mask
);
1525 FD_SET (inchannel
, &non_keyboard_wait_mask
);
1526 if (inchannel
> max_process_desc
)
1527 max_process_desc
= inchannel
;
1529 /* Until we store the proper pid, enable sigchld_handler
1530 to recognize an unknown pid as standing for this process.
1531 It is very important not to let this `marker' value stay
1532 in the table after this function has returned; if it does
1533 it might cause call-process to hang and subsequent asynchronous
1534 processes to get their return values scrambled. */
1535 XSETINT (XPROCESS (process
)->pid
, -1);
1540 /* child_setup must clobber environ on systems with true vfork.
1541 Protect it from permanent change. */
1542 char **save_environ
= environ
;
1544 current_dir
= ENCODE_FILE (current_dir
);
1549 #endif /* not WINDOWSNT */
1551 int xforkin
= forkin
;
1552 int xforkout
= forkout
;
1554 #if 0 /* This was probably a mistake--it duplicates code later on,
1555 but fails to handle all the cases. */
1556 /* Make sure SIGCHLD is not blocked in the child. */
1557 sigsetmask (SIGEMPTYMASK
);
1560 /* Make the pty be the controlling terminal of the process. */
1562 /* First, disconnect its current controlling terminal. */
1564 /* We tried doing setsid only if pty_flag, but it caused
1565 process_set_signal to fail on SGI when using a pipe. */
1567 /* Make the pty's terminal the controlling terminal. */
1571 /* We ignore the return value
1572 because faith@cs.unc.edu says that is necessary on Linux. */
1573 ioctl (xforkin
, TIOCSCTTY
, 0);
1576 #else /* not HAVE_SETSID */
1578 /* It's very important to call setpgrp here and no time
1579 afterwards. Otherwise, we lose our controlling tty which
1580 is set when we open the pty. */
1583 #endif /* not HAVE_SETSID */
1584 #if defined (HAVE_TERMIOS) && defined (LDISC1)
1585 if (pty_flag
&& xforkin
>= 0)
1588 tcgetattr (xforkin
, &t
);
1590 if (tcsetattr (xforkin
, TCSANOW
, &t
) < 0)
1591 write (1, "create_process/tcsetattr LDISC1 failed\n", 39);
1594 #if defined (NTTYDISC) && defined (TIOCSETD)
1595 if (pty_flag
&& xforkin
>= 0)
1597 /* Use new line discipline. */
1598 int ldisc
= NTTYDISC
;
1599 ioctl (xforkin
, TIOCSETD
, &ldisc
);
1604 /* In 4.3BSD, the TIOCSPGRP bug has been fixed, and now you
1605 can do TIOCSPGRP only to the process's controlling tty. */
1608 /* I wonder: would just ioctl (0, TIOCNOTTY, 0) work here?
1609 I can't test it since I don't have 4.3. */
1610 int j
= open ("/dev/tty", O_RDWR
, 0);
1611 ioctl (j
, TIOCNOTTY
, 0);
1614 /* In order to get a controlling terminal on some versions
1615 of BSD, it is necessary to put the process in pgrp 0
1616 before it opens the terminal. */
1624 #endif /* TIOCNOTTY */
1626 #if !defined (RTU) && !defined (UNIPLUS) && !defined (DONT_REOPEN_PTY)
1627 /*** There is a suggestion that this ought to be a
1628 conditional on TIOCSPGRP,
1629 or !(defined (HAVE_SETSID) && defined (TIOCSCTTY)).
1630 Trying the latter gave the wrong results on Debian GNU/Linux 1.1;
1631 that system does seem to need this code, even though
1632 both HAVE_SETSID and TIOCSCTTY are defined. */
1633 /* Now close the pty (if we had it open) and reopen it.
1634 This makes the pty the controlling terminal of the subprocess. */
1637 #ifdef SET_CHILD_PTY_PGRP
1638 int pgrp
= getpid ();
1641 /* I wonder if close (open (pty_name, ...)) would work? */
1644 xforkout
= xforkin
= open (pty_name
, O_RDWR
, 0);
1648 write (1, "Couldn't open the pty terminal ", 31);
1649 write (1, pty_name
, strlen (pty_name
));
1654 #ifdef SET_CHILD_PTY_PGRP
1655 ioctl (xforkin
, TIOCSPGRP
, &pgrp
);
1656 ioctl (xforkout
, TIOCSPGRP
, &pgrp
);
1659 #endif /* not UNIPLUS and not RTU and not DONT_REOPEN_PTY */
1661 #ifdef SETUP_SLAVE_PTY
1666 #endif /* SETUP_SLAVE_PTY */
1668 /* On AIX, we've disabled SIGHUP above once we start a child on a pty.
1669 Now reenable it in the child, so it will die when we want it to. */
1671 signal (SIGHUP
, SIG_DFL
);
1673 #endif /* HAVE_PTYS */
1675 signal (SIGINT
, SIG_DFL
);
1676 signal (SIGQUIT
, SIG_DFL
);
1678 /* Stop blocking signals in the child. */
1679 #ifdef POSIX_SIGNALS
1680 sigprocmask (SIG_SETMASK
, &procmask
, 0);
1681 #else /* !POSIX_SIGNALS */
1685 #else /* not BSD4_1 */
1686 #if defined (BSD_SYSTEM) || defined (UNIPLUS) || defined (HPUX)
1687 sigsetmask (SIGEMPTYMASK
);
1688 #else /* ordinary USG */
1690 signal (SIGCHLD
, sigchld
);
1692 #endif /* ordinary USG */
1693 #endif /* not BSD4_1 */
1694 #endif /* SIGCHLD */
1695 #endif /* !POSIX_SIGNALS */
1698 child_setup_tty (xforkout
);
1700 pid
= child_setup (xforkin
, xforkout
, xforkout
,
1701 new_argv
, 1, current_dir
);
1702 #else /* not WINDOWSNT */
1703 child_setup (xforkin
, xforkout
, xforkout
,
1704 new_argv
, 1, current_dir
);
1705 #endif /* not WINDOWSNT */
1707 environ
= save_environ
;
1712 /* This runs in the Emacs process. */
1717 if (forkin
!= forkout
&& forkout
>= 0)
1722 /* vfork succeeded. */
1723 XSETFASTINT (XPROCESS (process
)->pid
, pid
);
1726 register_child (pid
, inchannel
);
1727 #endif /* WINDOWSNT */
1729 /* If the subfork execv fails, and it exits,
1730 this close hangs. I don't know why.
1731 So have an interrupt jar it loose. */
1733 signal (SIGALRM
, create_process_1
);
1735 XPROCESS (process
)->subtty
= Qnil
;
1740 if (forkin
!= forkout
&& forkout
>= 0)
1745 XPROCESS (process
)->tty_name
= build_string (pty_name
);
1748 XPROCESS (process
)->tty_name
= Qnil
;
1751 /* Restore the signal state whether vfork succeeded or not.
1752 (We will signal an error, below, if it failed.) */
1753 #ifdef POSIX_SIGNALS
1755 /* Restore the parent's signal handlers. */
1756 sigaction (SIGINT
, &sigint_action
, 0);
1757 sigaction (SIGQUIT
, &sigquit_action
, 0);
1759 sigaction (SIGHUP
, &sighup_action
, 0);
1761 #endif /* HAVE_VFORK */
1762 /* Stop blocking signals in the parent. */
1763 sigprocmask (SIG_SETMASK
, &procmask
, 0);
1764 #else /* !POSIX_SIGNALS */
1768 #else /* not BSD4_1 */
1769 #if defined (BSD_SYSTEM) || defined (UNIPLUS) || defined (HPUX)
1770 sigsetmask (SIGEMPTYMASK
);
1771 #else /* ordinary USG */
1773 signal (SIGCHLD
, sigchld
);
1774 /* Now really handle any of these signals
1775 that came in during this function. */
1776 if (sigchld_deferred
)
1777 kill (getpid (), SIGCHLD
);
1779 #endif /* ordinary USG */
1780 #endif /* not BSD4_1 */
1781 #endif /* SIGCHLD */
1782 #endif /* !POSIX_SIGNALS */
1784 /* Now generate the error if vfork failed. */
1786 report_file_error ("Doing vfork", Qnil
);
1788 #endif /* not VMS */
1792 /* open a TCP network connection to a given HOST/SERVICE. Treated
1793 exactly like a normal process when reading and writing. Only
1794 differences are in status display and process deletion. A network
1795 connection has no PID; you cannot signal it. All you can do is
1796 deactivate and close it via delete-process */
1798 DEFUN ("open-network-stream", Fopen_network_stream
, Sopen_network_stream
,
1800 "Open a TCP connection for a service to a host.\n\
1801 Returns a subprocess-object to represent the connection.\n\
1802 Input and output work as for subprocesses; `delete-process' closes it.\n\
1803 Args are NAME BUFFER HOST SERVICE.\n\
1804 NAME is name for process. It is modified if necessary to make it unique.\n\
1805 BUFFER is the buffer (or buffer-name) to associate with the process.\n\
1806 Process output goes at end of that buffer, unless you specify\n\
1807 an output stream or filter function to handle the output.\n\
1808 BUFFER may be also nil, meaning that this process is not associated\n\
1810 Third arg is name of the host to connect to, or its IP address.\n\
1811 Fourth arg SERVICE is name of the service desired, or an integer\n\
1812 specifying a port number to connect to.")
1813 (name
, buffer
, host
, service
)
1814 Lisp_Object name
, buffer
, host
, service
;
1819 #ifndef HAVE_GETADDRINFO
1820 struct sockaddr_in address
;
1821 struct servent
*svc_info
;
1822 struct hostent
*host_info_ptr
, host_info
;
1823 char *(addr_list
[2]);
1824 IN_ADDR numeric_addr
;
1825 struct hostent host_info_fixed
;
1827 #else /* HAVE_GETADDRINFO */
1828 struct addrinfo hints
, *res
, *lres
;
1831 char *portstring
, portbuf
[128];
1832 #endif /* HAVE_GETADDRINFO */
1833 int s
= -1, outch
, inch
;
1834 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1836 int count
= specpdl_ptr
- specpdl
;
1840 /* Ensure socket support is loaded if available. */
1841 init_winsock (TRUE
);
1844 GCPRO4 (name
, buffer
, host
, service
);
1845 CHECK_STRING (name
, 0);
1846 CHECK_STRING (host
, 0);
1848 #ifdef HAVE_GETADDRINFO
1850 * SERVICE can either be a string or int.
1851 * Convert to a C string for later use by getaddrinfo.
1853 if (INTEGERP (service
))
1855 sprintf (portbuf
, "%d", XINT (service
));
1856 portstring
= portbuf
;
1860 CHECK_STRING (service
, 0);
1861 portstring
= XSTRING (service
)->data
;
1863 #else /* ! HAVE_GETADDRINFO */
1864 if (INTEGERP (service
))
1865 port
= htons ((unsigned short) XINT (service
));
1868 CHECK_STRING (service
, 0);
1869 svc_info
= getservbyname (XSTRING (service
)->data
, "tcp");
1871 error ("Unknown service \"%s\"", XSTRING (service
)->data
);
1872 port
= svc_info
->s_port
;
1874 #endif /* ! HAVE_GETADDRINFO */
1877 /* Slow down polling to every ten seconds.
1878 Some kernels have a bug which causes retrying connect to fail
1879 after a connect. Polling can interfere with gethostbyname too. */
1880 #ifdef POLL_FOR_INPUT
1881 bind_polling_period (10);
1885 #ifdef HAVE_GETADDRINFO
1889 memset (&hints
, 0, sizeof (hints
));
1891 hints
.ai_family
= AF_UNSPEC
;
1892 hints
.ai_socktype
= SOCK_STREAM
;
1893 hints
.ai_protocol
= 0;
1894 ret
= getaddrinfo (XSTRING (host
)->data
, portstring
, &hints
, &res
);
1897 error ("%s/%s %s", XSTRING (host
)->data
, portstring
,
1904 count1
= specpdl_ptr
- specpdl
;
1905 record_unwind_protect (close_file_unwind
, make_number (s
));
1907 for (lres
= res
; lres
; lres
= lres
->ai_next
)
1909 s
= socket (lres
->ai_family
, lres
->ai_socktype
, lres
->ai_protocol
);
1913 /* Kernel bugs (on Ultrix at least) cause lossage (not just EINTR)
1914 when connect is interrupted. So let's not let it get interrupted.
1915 Note we do not turn off polling, because polling is only used
1916 when not interrupt_input, and thus not normally used on the systems
1917 which have this bug. On systems which use polling, there's no way
1918 to quit if polling is turned off. */
1919 if (interrupt_input
)
1925 ret
= connect (s
, lres
->ai_addr
, lres
->ai_addrlen
);
1935 if (interrupt_input
)
1939 report_file_error ("connection failed",
1940 Fcons (host
, Fcons (name
, Qnil
)));
1942 #else /* ! HAVE_GETADDRINFO */
1951 host_info_ptr
= gethostbyname (XSTRING (host
)->data
);
1954 if (! (host_info_ptr
== 0 && h_errno
== TRY_AGAIN
))
1957 Fsleep_for (make_number (1), Qnil
);
1959 if (host_info_ptr
== 0)
1960 /* Attempt to interpret host as numeric inet address */
1962 numeric_addr
= inet_addr ((char *) XSTRING (host
)->data
);
1963 if (NUMERIC_ADDR_ERROR
)
1964 error ("Unknown host \"%s\"", XSTRING (host
)->data
);
1966 host_info_ptr
= &host_info
;
1967 host_info
.h_name
= 0;
1968 host_info
.h_aliases
= 0;
1969 host_info
.h_addrtype
= AF_INET
;
1971 /* Older machines have only one address slot called h_addr.
1972 Newer machines have h_addr_list, but #define h_addr to
1973 be its first element. */
1974 host_info
.h_addr_list
= &(addr_list
[0]);
1976 host_info
.h_addr
= (char*)(&numeric_addr
);
1978 /* numeric_addr isn't null-terminated; it has fixed length. */
1979 host_info
.h_length
= sizeof (numeric_addr
);
1982 bzero (&address
, sizeof address
);
1983 bcopy (host_info_ptr
->h_addr
, (char *) &address
.sin_addr
,
1984 host_info_ptr
->h_length
);
1985 address
.sin_family
= host_info_ptr
->h_addrtype
;
1986 address
.sin_port
= port
;
1988 s
= socket (host_info_ptr
->h_addrtype
, SOCK_STREAM
, 0);
1990 report_file_error ("error creating socket", Fcons (name
, Qnil
));
1992 count1
= specpdl_ptr
- specpdl
;
1993 record_unwind_protect (close_file_unwind
, make_number (s
));
1995 /* Kernel bugs (on Ultrix at least) cause lossage (not just EINTR)
1996 when connect is interrupted. So let's not let it get interrupted.
1997 Note we do not turn off polling, because polling is only used
1998 when not interrupt_input, and thus not normally used on the systems
1999 which have this bug. On systems which use polling, there's no way
2000 to quit if polling is turned off. */
2001 if (interrupt_input
)
2009 if (connect (s
, (struct sockaddr
*) &address
, sizeof address
) == -1
2010 && errno
!= EISCONN
)
2018 if (errno
== EADDRINUSE
&& retry
< 20)
2020 /* A delay here is needed on some FreeBSD systems,
2021 and it is harmless, since this retrying takes time anyway
2022 and should be infrequent. */
2023 Fsleep_for (make_number (1), Qnil
);
2028 /* Discard the unwind protect. */
2029 specpdl_ptr
= specpdl
+ count1
;
2033 if (interrupt_input
)
2037 report_file_error ("connection failed",
2038 Fcons (host
, Fcons (name
, Qnil
)));
2040 #endif /* ! HAVE_GETADDRINFO */
2044 /* Discard the unwind protect. */
2045 specpdl_ptr
= specpdl
+ count1
;
2047 #ifdef POLL_FOR_INPUT
2048 unbind_to (count
, Qnil
);
2051 if (interrupt_input
)
2055 s
= connect_server (0);
2057 report_file_error ("error creating socket", Fcons (name
, Qnil
));
2058 send_command (s
, C_PORT
, 0, "%s:%d", XSTRING (host
)->data
, ntohs (port
));
2059 send_command (s
, C_DUMB
, 1, 0);
2066 buffer
= Fget_buffer_create (buffer
);
2067 proc
= make_process (name
);
2069 chan_process
[inch
] = proc
;
2072 fcntl (inch
, F_SETFL
, O_NONBLOCK
);
2075 fcntl (inch
, F_SETFL
, O_NDELAY
);
2079 XPROCESS (proc
)->childp
= Fcons (host
, Fcons (service
, Qnil
));
2080 XPROCESS (proc
)->command_channel_p
= Qnil
;
2081 XPROCESS (proc
)->buffer
= buffer
;
2082 XPROCESS (proc
)->sentinel
= Qnil
;
2083 XPROCESS (proc
)->filter
= Qnil
;
2084 XPROCESS (proc
)->command
= Qnil
;
2085 XPROCESS (proc
)->pid
= Qnil
;
2086 XSETINT (XPROCESS (proc
)->infd
, inch
);
2087 XSETINT (XPROCESS (proc
)->outfd
, outch
);
2088 XPROCESS (proc
)->status
= Qrun
;
2089 FD_SET (inch
, &input_wait_mask
);
2090 FD_SET (inch
, &non_keyboard_wait_mask
);
2091 if (inch
> max_process_desc
)
2092 max_process_desc
= inch
;
2095 /* Setup coding systems for communicating with the network stream. */
2096 struct gcpro gcpro1
;
2097 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
2098 Lisp_Object coding_systems
= Qt
;
2099 Lisp_Object args
[5], val
;
2101 if (!NILP (Vcoding_system_for_read
))
2102 val
= Vcoding_system_for_read
;
2103 else if (!NILP (buffer
) && NILP (XBUFFER (buffer
)->enable_multibyte_characters
)
2104 || NILP (buffer
) && NILP (buffer_defaults
.enable_multibyte_characters
))
2105 /* We dare not decode end-of-line format by setting VAL to
2106 Qraw_text, because the existing Emacs Lisp libraries
2107 assume that they receive bare code including a sequene of
2112 args
[0] = Qopen_network_stream
, args
[1] = name
,
2113 args
[2] = buffer
, args
[3] = host
, args
[4] = service
;
2115 coding_systems
= Ffind_operation_coding_system (5, args
);
2117 if (CONSP (coding_systems
))
2118 val
= XCAR (coding_systems
);
2119 else if (CONSP (Vdefault_process_coding_system
))
2120 val
= XCAR (Vdefault_process_coding_system
);
2124 XPROCESS (proc
)->decode_coding_system
= val
;
2126 if (!NILP (Vcoding_system_for_write
))
2127 val
= Vcoding_system_for_write
;
2128 else if (NILP (current_buffer
->enable_multibyte_characters
))
2132 if (EQ (coding_systems
, Qt
))
2134 args
[0] = Qopen_network_stream
, args
[1] = name
,
2135 args
[2] = buffer
, args
[3] = host
, args
[4] = service
;
2137 coding_systems
= Ffind_operation_coding_system (5, args
);
2140 if (CONSP (coding_systems
))
2141 val
= XCDR (coding_systems
);
2142 else if (CONSP (Vdefault_process_coding_system
))
2143 val
= XCDR (Vdefault_process_coding_system
);
2147 XPROCESS (proc
)->encode_coding_system
= val
;
2150 if (!proc_decode_coding_system
[inch
])
2151 proc_decode_coding_system
[inch
]
2152 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
2153 setup_coding_system (XPROCESS (proc
)->decode_coding_system
,
2154 proc_decode_coding_system
[inch
]);
2155 if (!proc_encode_coding_system
[outch
])
2156 proc_encode_coding_system
[outch
]
2157 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
2158 setup_coding_system (XPROCESS (proc
)->encode_coding_system
,
2159 proc_encode_coding_system
[outch
]);
2161 XPROCESS (proc
)->decoding_buf
= make_uninit_string (0);
2162 XPROCESS (proc
)->decoding_carryover
= make_number (0);
2163 XPROCESS (proc
)->encoding_buf
= make_uninit_string (0);
2164 XPROCESS (proc
)->encoding_carryover
= make_number (0);
2166 XPROCESS (proc
)->inherit_coding_system_flag
2167 = (NILP (buffer
) || !inherit_process_coding_system
2173 #endif /* HAVE_SOCKETS */
2176 deactivate_process (proc
)
2179 register int inchannel
, outchannel
;
2180 register struct Lisp_Process
*p
= XPROCESS (proc
);
2182 inchannel
= XINT (p
->infd
);
2183 outchannel
= XINT (p
->outfd
);
2187 /* Beware SIGCHLD hereabouts. */
2188 flush_pending_output (inchannel
);
2191 VMS_PROC_STUFF
*get_vms_process_pointer (), *vs
;
2192 sys$
dassgn (outchannel
);
2193 vs
= get_vms_process_pointer (p
->pid
);
2195 give_back_vms_process_stuff (vs
);
2199 if (outchannel
>= 0 && outchannel
!= inchannel
)
2203 XSETINT (p
->infd
, -1);
2204 XSETINT (p
->outfd
, -1);
2205 chan_process
[inchannel
] = Qnil
;
2206 FD_CLR (inchannel
, &input_wait_mask
);
2207 FD_CLR (inchannel
, &non_keyboard_wait_mask
);
2208 if (inchannel
== max_process_desc
)
2211 /* We just closed the highest-numbered process input descriptor,
2212 so recompute the highest-numbered one now. */
2213 max_process_desc
= 0;
2214 for (i
= 0; i
< MAXDESC
; i
++)
2215 if (!NILP (chan_process
[i
]))
2216 max_process_desc
= i
;
2221 /* Close all descriptors currently in use for communication
2222 with subprocess. This is used in a newly-forked subprocess
2223 to get rid of irrelevant descriptors. */
2226 close_process_descs ()
2230 for (i
= 0; i
< MAXDESC
; i
++)
2232 Lisp_Object process
;
2233 process
= chan_process
[i
];
2234 if (!NILP (process
))
2236 int in
= XINT (XPROCESS (process
)->infd
);
2237 int out
= XINT (XPROCESS (process
)->outfd
);
2240 if (out
>= 0 && in
!= out
)
2247 DEFUN ("accept-process-output", Faccept_process_output
, Saccept_process_output
,
2249 "Allow any pending output from subprocesses to be read by Emacs.\n\
2250 It is read into the process' buffers or given to their filter functions.\n\
2251 Non-nil arg PROCESS means do not return until some output has been received\n\
2253 Non-nil second arg TIMEOUT and third arg TIMEOUT-MSECS are number of\n\
2254 seconds and microseconds to wait; return after that much time whether\n\
2255 or not there is input.\n\
2256 Return non-nil iff we received any output before the timeout expired.")
2257 (process
, timeout
, timeout_msecs
)
2258 register Lisp_Object process
, timeout
, timeout_msecs
;
2263 if (! NILP (process
))
2264 CHECK_PROCESS (process
, 0);
2266 if (! NILP (timeout_msecs
))
2268 CHECK_NUMBER (timeout_msecs
, 2);
2269 useconds
= XINT (timeout_msecs
);
2270 if (!INTEGERP (timeout
))
2271 XSETINT (timeout
, 0);
2274 int carry
= useconds
/ 1000000;
2276 XSETINT (timeout
, XINT (timeout
) + carry
);
2277 useconds
-= carry
* 1000000;
2279 /* I think this clause is necessary because C doesn't
2280 guarantee a particular rounding direction for negative
2284 XSETINT (timeout
, XINT (timeout
) - 1);
2285 useconds
+= 1000000;
2292 if (! NILP (timeout
))
2294 CHECK_NUMBER (timeout
, 1);
2295 seconds
= XINT (timeout
);
2296 if (seconds
< 0 || (seconds
== 0 && useconds
== 0))
2308 XSETFASTINT (process
, 0);
2311 (wait_reading_process_input (seconds
, useconds
, process
, 0)
2315 /* This variable is different from waiting_for_input in keyboard.c.
2316 It is used to communicate to a lisp process-filter/sentinel (via the
2317 function Fwaiting_for_user_input_p below) whether emacs was waiting
2318 for user-input when that process-filter was called.
2319 waiting_for_input cannot be used as that is by definition 0 when
2320 lisp code is being evalled.
2321 This is also used in record_asynch_buffer_change.
2322 For that purpose, this must be 0
2323 when not inside wait_reading_process_input. */
2324 static int waiting_for_user_input_p
;
2326 /* This is here so breakpoints can be put on it. */
2328 wait_reading_process_input_1 ()
2332 /* Read and dispose of subprocess output while waiting for timeout to
2333 elapse and/or keyboard input to be available.
2336 timeout in seconds, or
2337 zero for no limit, or
2338 -1 means gobble data immediately available but don't wait for any.
2341 an additional duration to wait, measured in microseconds.
2342 If this is nonzero and time_limit is 0, then the timeout
2343 consists of MICROSECS only.
2345 READ_KBD is a lisp value:
2346 0 to ignore keyboard input, or
2347 1 to return when input is available, or
2348 -1 meaning caller will actually read the input, so don't throw to
2349 the quit handler, or
2350 a cons cell, meaning wait until its car is non-nil
2351 (and gobble terminal input into the buffer if any arrives), or
2352 a process object, meaning wait until something arrives from that
2353 process. The return value is true iff we read some input from
2356 DO_DISPLAY != 0 means redisplay should be done to show subprocess
2357 output that arrives.
2359 If READ_KBD is a pointer to a struct Lisp_Process, then the
2360 function returns true iff we received input from that process
2361 before the timeout elapsed.
2362 Otherwise, return true iff we received input from any process. */
2365 wait_reading_process_input (time_limit
, microsecs
, read_kbd
, do_display
)
2366 int time_limit
, microsecs
;
2367 Lisp_Object read_kbd
;
2370 register int channel
, nfds
, m
;
2371 static SELECT_TYPE Available
;
2374 EMACS_TIME timeout
, end_time
, garbage
;
2376 int wait_channel
= -1;
2377 struct Lisp_Process
*wait_proc
= 0;
2378 int got_some_input
= 0;
2379 Lisp_Object
*wait_for_cell
= 0;
2381 FD_ZERO (&Available
);
2383 /* If read_kbd is a process to watch, set wait_proc and wait_channel
2385 if (PROCESSP (read_kbd
))
2387 wait_proc
= XPROCESS (read_kbd
);
2388 wait_channel
= XINT (wait_proc
->infd
);
2389 XSETFASTINT (read_kbd
, 0);
2392 /* If waiting for non-nil in a cell, record where. */
2393 if (CONSP (read_kbd
))
2395 wait_for_cell
= &XCAR (read_kbd
);
2396 XSETFASTINT (read_kbd
, 0);
2399 waiting_for_user_input_p
= XINT (read_kbd
);
2401 /* Since we may need to wait several times,
2402 compute the absolute time to return at. */
2403 if (time_limit
|| microsecs
)
2405 EMACS_GET_TIME (end_time
);
2406 EMACS_SET_SECS_USECS (timeout
, time_limit
, microsecs
);
2407 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
2410 /* AlainF 5-Jul-1996
2411 HP-UX 10.10 seem to have problems with signals coming in
2412 Causes "poll: interrupted system call" messages when Emacs is run
2414 Turn off periodic alarms (in case they are in use) */
2420 int timeout_reduced_for_timers
= 0;
2422 #ifdef HAVE_X_WINDOWS
2423 if (display_busy_cursor_p
)
2424 Fx_hide_busy_cursor (Qnil
);
2427 /* If calling from keyboard input, do not quit
2428 since we want to return C-g as an input character.
2429 Otherwise, do pending quit if requested. */
2430 if (XINT (read_kbd
) >= 0)
2433 /* Exit now if the cell we're waiting for became non-nil. */
2434 if (wait_for_cell
&& ! NILP (*wait_for_cell
))
2437 /* Compute time from now till when time limit is up */
2438 /* Exit if already run out */
2439 if (time_limit
== -1)
2441 /* -1 specified for timeout means
2442 gobble output available now
2443 but don't wait at all. */
2445 EMACS_SET_SECS_USECS (timeout
, 0, 0);
2447 else if (time_limit
|| microsecs
)
2449 EMACS_GET_TIME (timeout
);
2450 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
2451 if (EMACS_TIME_NEG_P (timeout
))
2456 EMACS_SET_SECS_USECS (timeout
, 100000, 0);
2459 /* Normally we run timers here.
2460 But not if wait_for_cell; in those cases,
2461 the wait is supposed to be short,
2462 and those callers cannot handle running arbitrary Lisp code here. */
2463 if (! wait_for_cell
)
2465 EMACS_TIME timer_delay
;
2469 old_timers_run
= timers_run
;
2470 timer_delay
= timer_check (1);
2471 if (timers_run
!= old_timers_run
&& do_display
)
2473 redisplay_preserve_echo_area ();
2474 /* We must retry, since a timer may have requeued itself
2475 and that could alter the time_delay. */
2479 /* If there is unread keyboard input, also return. */
2480 if (XINT (read_kbd
) != 0
2481 && requeued_events_pending_p ())
2484 if (! EMACS_TIME_NEG_P (timer_delay
) && time_limit
!= -1)
2486 EMACS_TIME difference
;
2487 EMACS_SUB_TIME (difference
, timer_delay
, timeout
);
2488 if (EMACS_TIME_NEG_P (difference
))
2490 timeout
= timer_delay
;
2491 timeout_reduced_for_timers
= 1;
2494 /* If time_limit is -1, we are not going to wait at all. */
2495 else if (time_limit
!= -1)
2497 /* This is so a breakpoint can be put here. */
2498 wait_reading_process_input_1 ();
2502 /* Cause C-g and alarm signals to take immediate action,
2503 and cause input available signals to zero out timeout.
2505 It is important that we do this before checking for process
2506 activity. If we get a SIGCHLD after the explicit checks for
2507 process activity, timeout is the only way we will know. */
2508 if (XINT (read_kbd
) < 0)
2509 set_waiting_for_input (&timeout
);
2511 /* If status of something has changed, and no input is
2512 available, notify the user of the change right away. After
2513 this explicit check, we'll let the SIGCHLD handler zap
2514 timeout to get our attention. */
2515 if (update_tick
!= process_tick
&& do_display
)
2517 Atemp
= input_wait_mask
;
2518 EMACS_SET_SECS_USECS (timeout
, 0, 0);
2519 if ((select (max (max_process_desc
, max_keyboard_desc
) + 1,
2520 &Atemp
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0,
2524 /* It's okay for us to do this and then continue with
2525 the loop, since timeout has already been zeroed out. */
2526 clear_waiting_for_input ();
2531 /* Don't wait for output from a non-running process. */
2532 if (wait_proc
!= 0 && !NILP (wait_proc
->raw_status_low
))
2533 update_status (wait_proc
);
2535 && ! EQ (wait_proc
->status
, Qrun
))
2537 int nread
, total_nread
= 0;
2539 clear_waiting_for_input ();
2540 XSETPROCESS (proc
, wait_proc
);
2542 /* Read data from the process, until we exhaust it. */
2543 while (XINT (wait_proc
->infd
) >= 0
2545 = read_process_output (proc
, XINT (wait_proc
->infd
))))
2548 total_nread
+= nread
;
2550 else if (nread
== -1 && EIO
== errno
)
2554 if (total_nread
> 0 && do_display
)
2555 redisplay_preserve_echo_area ();
2560 /* Wait till there is something to do */
2563 Available
= non_process_wait_mask
;
2564 else if (! XINT (read_kbd
))
2565 Available
= non_keyboard_wait_mask
;
2567 Available
= input_wait_mask
;
2569 /* If frame size has changed or the window is newly mapped,
2570 redisplay now, before we start to wait. There is a race
2571 condition here; if a SIGIO arrives between now and the select
2572 and indicates that a frame is trashed, the select may block
2573 displaying a trashed screen. */
2574 if (frame_garbaged
&& do_display
)
2576 clear_waiting_for_input ();
2577 redisplay_preserve_echo_area ();
2578 if (XINT (read_kbd
) < 0)
2579 set_waiting_for_input (&timeout
);
2582 if (XINT (read_kbd
) && detect_input_pending ())
2585 FD_ZERO (&Available
);
2588 nfds
= select (max (max_process_desc
, max_keyboard_desc
) + 1,
2589 &Available
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0,
2594 /* Make C-g and alarm signals set flags again */
2595 clear_waiting_for_input ();
2597 /* If we woke up due to SIGWINCH, actually change size now. */
2598 do_pending_window_change (0);
2600 if (time_limit
&& nfds
== 0 && ! timeout_reduced_for_timers
)
2601 /* We wanted the full specified time, so return now. */
2605 if (xerrno
== EINTR
)
2606 FD_ZERO (&Available
);
2608 /* Ultrix select seems to return ENOMEM when it is
2609 interrupted. Treat it just like EINTR. Bleah. Note
2610 that we want to test for the "ultrix" CPP symbol, not
2611 "__ultrix__"; the latter is only defined under GCC, but
2612 not by DEC's bundled CC. -JimB */
2613 else if (xerrno
== ENOMEM
)
2614 FD_ZERO (&Available
);
2617 /* This happens for no known reason on ALLIANT.
2618 I am guessing that this is the right response. -- RMS. */
2619 else if (xerrno
== EFAULT
)
2620 FD_ZERO (&Available
);
2622 else if (xerrno
== EBADF
)
2625 /* AIX doesn't handle PTY closure the same way BSD does. On AIX,
2626 the child's closure of the pts gives the parent a SIGHUP, and
2627 the ptc file descriptor is automatically closed,
2628 yielding EBADF here or at select() call above.
2629 So, SIGHUP is ignored (see def of PTY_TTY_NAME_SPRINTF
2630 in m/ibmrt-aix.h), and here we just ignore the select error.
2631 Cleanup occurs c/o status_notify after SIGCLD. */
2632 FD_ZERO (&Available
); /* Cannot depend on values returned */
2638 error ("select error: %s", strerror (xerrno
));
2640 #if defined(sun) && !defined(USG5_4)
2641 else if (nfds
> 0 && keyboard_bit_set (&Available
)
2643 /* System sometimes fails to deliver SIGIO.
2645 David J. Mackenzie says that Emacs doesn't compile under
2646 Solaris if this code is enabled, thus the USG5_4 in the CPP
2647 conditional. "I haven't noticed any ill effects so far.
2648 If you find a Solaris expert somewhere, they might know
2650 kill (getpid (), SIGIO
);
2653 #if 0 /* When polling is used, interrupt_input is 0,
2654 so get_input_pending should read the input.
2655 So this should not be needed. */
2656 /* If we are using polling for input,
2657 and we see input available, make it get read now.
2658 Otherwise it might not actually get read for a second.
2659 And on hpux, since we turn off polling in wait_reading_process_input,
2660 it might never get read at all if we don't spend much time
2661 outside of wait_reading_process_input. */
2662 if (XINT (read_kbd
) && interrupt_input
2663 && keyboard_bit_set (&Available
)
2664 && input_polling_used ())
2665 kill (getpid (), SIGALRM
);
2668 /* Check for keyboard input */
2669 /* If there is any, return immediately
2670 to give it higher priority than subprocesses */
2672 if (XINT (read_kbd
) != 0
2673 && detect_input_pending_run_timers (do_display
))
2675 swallow_events (do_display
);
2676 if (detect_input_pending_run_timers (do_display
))
2680 /* If there is unread keyboard input, also return. */
2681 if (XINT (read_kbd
) != 0
2682 && requeued_events_pending_p ())
2685 /* If we are not checking for keyboard input now,
2686 do process events (but don't run any timers).
2687 This is so that X events will be processed.
2688 Otherwise they may have to wait until polling takes place.
2689 That would causes delays in pasting selections, for example.
2691 (We used to do this only if wait_for_cell.) */
2692 if (XINT (read_kbd
) == 0 && detect_input_pending ())
2694 swallow_events (do_display
);
2695 #if 0 /* Exiting when read_kbd doesn't request that seems wrong, though. */
2696 if (detect_input_pending ())
2701 /* Exit now if the cell we're waiting for became non-nil. */
2702 if (wait_for_cell
&& ! NILP (*wait_for_cell
))
2706 /* If we think we have keyboard input waiting, but didn't get SIGIO,
2707 go read it. This can happen with X on BSD after logging out.
2708 In that case, there really is no input and no SIGIO,
2709 but select says there is input. */
2711 if (XINT (read_kbd
) && interrupt_input
2712 && keyboard_bit_set (&Available
))
2713 kill (getpid (), SIGIO
);
2717 got_some_input
|= nfds
> 0;
2719 /* If checking input just got us a size-change event from X,
2720 obey it now if we should. */
2721 if (XINT (read_kbd
) || wait_for_cell
)
2722 do_pending_window_change (0);
2724 /* Check for data from a process. */
2725 /* Really FIRST_PROC_DESC should be 0 on Unix,
2726 but this is safer in the short run. */
2727 for (channel
= 0; channel
<= max_process_desc
; channel
++)
2729 if (FD_ISSET (channel
, &Available
)
2730 && FD_ISSET (channel
, &non_keyboard_wait_mask
))
2734 /* If waiting for this channel, arrange to return as
2735 soon as no more input to be processed. No more
2737 if (wait_channel
== channel
)
2743 proc
= chan_process
[channel
];
2747 /* Read data from the process, starting with our
2748 buffered-ahead character if we have one. */
2750 nread
= read_process_output (proc
, channel
);
2753 /* Since read_process_output can run a filter,
2754 which can call accept-process-output,
2755 don't try to read from any other processes
2756 before doing the select again. */
2757 FD_ZERO (&Available
);
2760 redisplay_preserve_echo_area ();
2763 else if (nread
== -1 && errno
== EWOULDBLOCK
)
2766 /* ISC 4.1 defines both EWOULDBLOCK and O_NONBLOCK,
2767 and Emacs uses O_NONBLOCK, so what we get is EAGAIN. */
2769 else if (nread
== -1 && errno
== EAGAIN
)
2773 else if (nread
== -1 && errno
== EAGAIN
)
2775 /* Note that we cannot distinguish between no input
2776 available now and a closed pipe.
2777 With luck, a closed pipe will be accompanied by
2778 subprocess termination and SIGCHLD. */
2779 else if (nread
== 0 && !NETCONN_P (proc
))
2781 #endif /* O_NDELAY */
2782 #endif /* O_NONBLOCK */
2784 /* On some OSs with ptys, when the process on one end of
2785 a pty exits, the other end gets an error reading with
2786 errno = EIO instead of getting an EOF (0 bytes read).
2787 Therefore, if we get an error reading and errno =
2788 EIO, just continue, because the child process has
2789 exited and should clean itself up soon (e.g. when we
2792 However, it has been known to happen that the SIGCHLD
2793 got lost. So raise the signl again just in case.
2795 else if (nread
== -1 && errno
== EIO
)
2796 kill (getpid (), SIGCHLD
);
2797 #endif /* HAVE_PTYS */
2798 /* If we can detect process termination, don't consider the process
2799 gone just because its pipe is closed. */
2801 else if (nread
== 0 && !NETCONN_P (proc
))
2806 /* Preserve status of processes already terminated. */
2807 XSETINT (XPROCESS (proc
)->tick
, ++process_tick
);
2808 deactivate_process (proc
);
2809 if (!NILP (XPROCESS (proc
)->raw_status_low
))
2810 update_status (XPROCESS (proc
));
2811 if (EQ (XPROCESS (proc
)->status
, Qrun
))
2812 XPROCESS (proc
)->status
2813 = Fcons (Qexit
, Fcons (make_number (256), Qnil
));
2816 } /* end for each file descriptor */
2817 } /* end while exit conditions not met */
2819 waiting_for_user_input_p
= 0;
2821 /* If calling from keyboard input, do not quit
2822 since we want to return C-g as an input character.
2823 Otherwise, do pending quit if requested. */
2824 if (XINT (read_kbd
) >= 0)
2826 /* Prevent input_pending from remaining set if we quit. */
2827 clear_input_pending ();
2831 /* AlainF 5-Jul-1996
2832 HP-UX 10.10 seems to have problems with signals coming in
2833 Causes "poll: interrupted system call" messages when Emacs is run
2835 Turn periodic alarms back on */
2839 #ifdef HAVE_X_WINDOWS
2840 if (display_busy_cursor_p
)
2841 if (!inhibit_busy_cursor
)
2842 Fx_show_busy_cursor ();
2845 return got_some_input
;
2848 /* Given a list (FUNCTION ARGS...), apply FUNCTION to the ARGS. */
2851 read_process_output_call (fun_and_args
)
2852 Lisp_Object fun_and_args
;
2854 return apply1 (XCAR (fun_and_args
), XCDR (fun_and_args
));
2858 read_process_output_error_handler (error
)
2861 cmd_error_internal (error
, "error in process filter: ");
2863 update_echo_area ();
2864 Fsleep_for (make_number (2), Qnil
);
2867 /* Read pending output from the process channel,
2868 starting with our buffered-ahead character if we have one.
2869 Yield number of decoded characters read.
2871 This function reads at most 1024 characters.
2872 If you want to read all available subprocess output,
2873 you must call it repeatedly until it returns zero.
2875 The characters read are decoded according to PROC's coding-system
2879 read_process_output (proc
, channel
)
2881 register int channel
;
2883 register int nchars
, nbytes
;
2886 int chars_allocated
= 0; /* If 1, `chars' should be freed later. */
2890 register Lisp_Object outstream
;
2891 register struct buffer
*old
= current_buffer
;
2892 register struct Lisp_Process
*p
= XPROCESS (proc
);
2893 register int opoint
;
2894 struct coding_system
*coding
= proc_decode_coding_system
[channel
];
2895 int chars_in_decoding_buf
= 0; /* If 1, `chars' points
2896 XSTRING (p->decoding_buf)->data. */
2897 int carryover
= XINT (p
->decoding_carryover
);
2900 VMS_PROC_STUFF
*vs
, *get_vms_process_pointer();
2902 vs
= get_vms_process_pointer (p
->pid
);
2906 return (0); /* Really weird if it does this */
2907 if (!(vs
->iosb
[0] & 1))
2908 return -1; /* I/O error */
2911 error ("Could not get VMS process pointer");
2912 chars
= vs
->inputBuffer
;
2913 nbytes
= clean_vms_buffer (chars
, vs
->iosb
[1]);
2916 start_vms_process_read (vs
); /* Crank up the next read on the process */
2917 return 1; /* Nothing worth printing, say we got 1 */
2921 /* The data carried over in the previous decoding (which are at
2922 the tail of decoding buffer) should be prepended to the new
2923 data read to decode all together. */
2924 char *buf
= (char *) xmalloc (nbytes
+ carryover
);
2926 bcopy (XSTRING (p
->decoding_buf
)->data
2927 + STRING_BYTES (XSTRING (p
->decoding_buf
)) - carryover
,
2929 bcopy (chars
, buf
+ carryover
, nbytes
);
2931 chars_allocated
= 1;
2936 /* See the comment above. */
2937 bcopy (XSTRING (p
->decoding_buf
)->data
2938 + STRING_BYTES (XSTRING (p
->decoding_buf
)) - carryover
,
2941 if (proc_buffered_char
[channel
] < 0)
2942 nbytes
= read (channel
, buf
+ carryover
, (sizeof buf
) - carryover
);
2945 buf
[carryover
] = proc_buffered_char
[channel
];
2946 proc_buffered_char
[channel
] = -1;
2947 nbytes
= read (channel
, buf
+ carryover
+ 1,
2948 (sizeof buf
) - carryover
- 1);
2952 nbytes
= nbytes
+ 1;
2955 #endif /* not VMS */
2957 XSETINT (p
->decoding_carryover
, 0);
2959 /* At this point, NBYTES holds number of characters just received
2960 (including the one in proc_buffered_char[channel]). */
2963 if (nbytes
< 0 || coding
->mode
& CODING_MODE_LAST_BLOCK
)
2965 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
2968 /* Now set NBYTES how many bytes we must decode. */
2969 nbytes
+= carryover
;
2972 if (CODING_MAY_REQUIRE_DECODING (coding
))
2974 int require
= decoding_buffer_size (coding
, nbytes
);
2977 if (STRING_BYTES (XSTRING (p
->decoding_buf
)) < require
)
2978 p
->decoding_buf
= make_uninit_string (require
);
2979 result
= decode_coding (coding
, chars
, XSTRING (p
->decoding_buf
)->data
,
2980 nbytes
, STRING_BYTES (XSTRING (p
->decoding_buf
)));
2981 carryover
= nbytes
- coding
->consumed
;
2984 /* Copy the carryover bytes to the end of p->decoding_buf, to
2985 be processed on the next read. Since decoding_buffer_size
2986 asks for an extra amount of space beyond the maximum
2987 expected for the output, there should always be sufficient
2988 space for the carryover (which is by definition a sequence
2989 of bytes that was not long enough to be decoded, and thus
2990 has a bounded length). */
2991 if (STRING_BYTES (XSTRING (p
->decoding_buf
))
2992 < coding
->produced
+ carryover
)
2994 bcopy (chars
+ coding
->consumed
,
2995 XSTRING (p
->decoding_buf
)->data
2996 + STRING_BYTES (XSTRING (p
->decoding_buf
)) - carryover
,
2998 XSETINT (p
->decoding_carryover
, carryover
);
3001 /* A new coding system might be found by `decode_coding'. */
3002 if (!EQ (p
->decode_coding_system
, coding
->symbol
))
3004 p
->decode_coding_system
= coding
->symbol
;
3006 /* Don't call setup_coding_system for
3007 proc_decode_coding_system[channel] here. It is done in
3008 detect_coding called via decode_coding above. */
3010 /* If a coding system for encoding is not yet decided, we set
3011 it as the same as coding-system for decoding.
3013 But, before doing that we must check if
3014 proc_encode_coding_system[p->outfd] surely points to a
3015 valid memory because p->outfd will be changed once EOF is
3016 sent to the process. */
3017 if (NILP (p
->encode_coding_system
)
3018 && proc_encode_coding_system
[XINT (p
->outfd
)])
3020 p
->encode_coding_system
= coding
->symbol
;
3021 setup_coding_system (coding
->symbol
,
3022 proc_encode_coding_system
[XINT (p
->outfd
)]);
3027 /* Now we don't need the contents of `chars'. */
3028 if (chars_allocated
)
3031 if (coding
->produced
== 0)
3033 chars
= (char *) XSTRING (p
->decoding_buf
)->data
;
3034 nbytes
= coding
->produced
;
3035 nchars
= (coding
->fake_multibyte
3036 ? multibyte_chars_in_text (chars
, nbytes
)
3037 : coding
->produced_char
);
3038 chars_in_decoding_buf
= 1;
3043 if (chars_allocated
)
3045 /* Although we don't have to decode the received data, we
3046 must move it to an area which we don't have to free. */
3047 if (! STRINGP (p
->decoding_buf
)
3048 || STRING_BYTES (XSTRING (p
->decoding_buf
)) < nbytes
)
3049 p
->decoding_buf
= make_uninit_string (nbytes
);
3050 bcopy (chars
, XSTRING (p
->decoding_buf
)->data
, nbytes
);
3052 chars
= XSTRING (p
->decoding_buf
)->data
;
3053 chars_in_decoding_buf
= 1;
3056 nchars
= multibyte_chars_in_text (chars
, nbytes
);
3059 Vlast_coding_system_used
= coding
->symbol
;
3061 /* If the caller required, let the process associated buffer
3062 inherit the coding-system used to decode the process output. */
3063 if (! NILP (p
->inherit_coding_system_flag
)
3064 && !NILP (p
->buffer
) && !NILP (XBUFFER (p
->buffer
)->name
))
3066 struct buffer
*prev_buf
= current_buffer
;
3068 Fset_buffer (p
->buffer
);
3069 call1 (intern ("after-insert-file-set-buffer-file-coding-system"),
3070 make_number (nbytes
));
3071 set_buffer_internal (prev_buf
);
3074 /* Read and dispose of the process output. */
3075 outstream
= p
->filter
;
3076 if (!NILP (outstream
))
3078 /* We inhibit quit here instead of just catching it so that
3079 hitting ^G when a filter happens to be running won't screw
3081 int count
= specpdl_ptr
- specpdl
;
3082 Lisp_Object odeactivate
;
3083 Lisp_Object obuffer
, okeymap
;
3085 int outer_running_asynch_code
= running_asynch_code
;
3086 int waiting
= waiting_for_user_input_p
;
3088 /* No need to gcpro these, because all we do with them later
3089 is test them for EQness, and none of them should be a string. */
3090 odeactivate
= Vdeactivate_mark
;
3091 XSETBUFFER (obuffer
, current_buffer
);
3092 okeymap
= current_buffer
->keymap
;
3094 specbind (Qinhibit_quit
, Qt
);
3095 specbind (Qlast_nonmenu_event
, Qt
);
3097 /* In case we get recursively called,
3098 and we already saved the match data nonrecursively,
3099 save the same match data in safely recursive fashion. */
3100 if (outer_running_asynch_code
)
3103 /* Don't clobber the CURRENT match data, either! */
3104 tem
= Fmatch_data (Qnil
, Qnil
);
3105 restore_match_data ();
3106 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
3107 Fset_match_data (tem
);
3110 /* For speed, if a search happens within this code,
3111 save the match data in a special nonrecursive fashion. */
3112 running_asynch_code
= 1;
3114 /* The multibyteness of a string given to the filter is decided
3115 by which coding system we used for decoding. */
3116 if (coding
->type
== coding_type_no_conversion
3117 || coding
->type
== coding_type_raw_text
)
3118 text
= make_unibyte_string (chars
, nbytes
);
3120 text
= make_multibyte_string (chars
, nchars
, nbytes
);
3122 internal_condition_case_1 (read_process_output_call
,
3124 Fcons (proc
, Fcons (text
, Qnil
))),
3125 !NILP (Vdebug_on_error
) ? Qnil
: Qerror
,
3126 read_process_output_error_handler
);
3128 /* If we saved the match data nonrecursively, restore it now. */
3129 restore_match_data ();
3130 running_asynch_code
= outer_running_asynch_code
;
3132 /* Handling the process output should not deactivate the mark. */
3133 Vdeactivate_mark
= odeactivate
;
3135 /* Restore waiting_for_user_input_p as it was
3136 when we were called, in case the filter clobbered it. */
3137 waiting_for_user_input_p
= waiting
;
3139 #if 0 /* Call record_asynch_buffer_change unconditionally,
3140 because we might have changed minor modes or other things
3141 that affect key bindings. */
3142 if (! EQ (Fcurrent_buffer (), obuffer
)
3143 || ! EQ (current_buffer
->keymap
, okeymap
))
3145 /* But do it only if the caller is actually going to read events.
3146 Otherwise there's no need to make him wake up, and it could
3147 cause trouble (for example it would make Fsit_for return). */
3148 if (waiting_for_user_input_p
== -1)
3149 record_asynch_buffer_change ();
3152 start_vms_process_read (vs
);
3154 unbind_to (count
, Qnil
);
3158 /* If no filter, write into buffer if it isn't dead. */
3159 if (!NILP (p
->buffer
) && !NILP (XBUFFER (p
->buffer
)->name
))
3161 Lisp_Object old_read_only
;
3162 int old_begv
, old_zv
;
3163 int old_begv_byte
, old_zv_byte
;
3164 Lisp_Object odeactivate
;
3165 int before
, before_byte
;
3168 odeactivate
= Vdeactivate_mark
;
3170 Fset_buffer (p
->buffer
);
3172 opoint_byte
= PT_BYTE
;
3173 old_read_only
= current_buffer
->read_only
;
3176 old_begv_byte
= BEGV_BYTE
;
3177 old_zv_byte
= ZV_BYTE
;
3179 current_buffer
->read_only
= Qnil
;
3181 /* Insert new output into buffer
3182 at the current end-of-output marker,
3183 thus preserving logical ordering of input and output. */
3184 if (XMARKER (p
->mark
)->buffer
)
3185 SET_PT_BOTH (clip_to_bounds (BEGV
, marker_position (p
->mark
), ZV
),
3186 clip_to_bounds (BEGV_BYTE
, marker_byte_position (p
->mark
),
3189 SET_PT_BOTH (ZV
, ZV_BYTE
);
3191 before_byte
= PT_BYTE
;
3193 /* If the output marker is outside of the visible region, save
3194 the restriction and widen. */
3195 if (! (BEGV
<= PT
&& PT
<= ZV
))
3198 if (NILP (current_buffer
->enable_multibyte_characters
))
3201 /* Insert before markers in case we are inserting where
3202 the buffer's mark is, and the user's next command is Meta-y. */
3203 if (chars_in_decoding_buf
)
3205 /* Since multibyteness of p->docoding_buf is corrupted, we
3206 can't use insert_from_string_before_markers. */
3209 temp_buf
= (char *) alloca (nbytes
);
3210 bcopy (XSTRING (p
->decoding_buf
)->data
, temp_buf
, nbytes
);
3211 insert_before_markers (temp_buf
, nbytes
);
3215 insert_1_both (chars
, nchars
, nbytes
, 0, 1, 1);
3216 signal_after_change (opoint
, 0, PT
- opoint
);
3218 set_marker_both (p
->mark
, p
->buffer
, PT
, PT_BYTE
);
3220 update_mode_lines
++;
3222 /* Make sure opoint and the old restrictions
3223 float ahead of any new text just as point would. */
3224 if (opoint
>= before
)
3226 opoint
+= PT
- before
;
3227 opoint_byte
+= PT_BYTE
- before_byte
;
3229 if (old_begv
> before
)
3231 old_begv
+= PT
- before
;
3232 old_begv_byte
+= PT_BYTE
- before_byte
;
3234 if (old_zv
>= before
)
3236 old_zv
+= PT
- before
;
3237 old_zv_byte
+= PT_BYTE
- before_byte
;
3240 /* If the restriction isn't what it should be, set it. */
3241 if (old_begv
!= BEGV
|| old_zv
!= ZV
)
3242 Fnarrow_to_region (make_number (old_begv
), make_number (old_zv
));
3244 /* Handling the process output should not deactivate the mark. */
3245 Vdeactivate_mark
= odeactivate
;
3247 current_buffer
->read_only
= old_read_only
;
3248 SET_PT_BOTH (opoint
, opoint_byte
);
3249 set_buffer_internal (old
);
3252 start_vms_process_read (vs
);
3257 DEFUN ("waiting-for-user-input-p", Fwaiting_for_user_input_p
, Swaiting_for_user_input_p
,
3259 "Returns non-nil if emacs is waiting for input from the user.\n\
3260 This is intended for use by asynchronous process output filters and sentinels.")
3263 return (waiting_for_user_input_p
? Qt
: Qnil
);
3266 /* Sending data to subprocess */
3268 jmp_buf send_process_frame
;
3271 send_process_trap ()
3277 longjmp (send_process_frame
, 1);
3280 /* Send some data to process PROC.
3281 BUF is the beginning of the data; LEN is the number of characters.
3282 OBJECT is the Lisp object that the data comes from.
3284 The data is encoded by PROC's coding-system for encoding before it
3285 is sent. But if the data ends at the middle of multi-byte
3286 representation, that incomplete sequence of bytes are sent without
3287 being encoded. Should we store them in a buffer to prepend them to
3288 the data send later? */
3291 send_process (proc
, buf
, len
, object
)
3292 volatile Lisp_Object proc
;
3297 /* Use volatile to protect variables from being clobbered by longjmp. */
3299 volatile unsigned char *procname
= XSTRING (XPROCESS (proc
)->name
)->data
;
3300 struct coding_system
*coding
;
3301 struct gcpro gcpro1
;
3302 int carryover
= XINT (XPROCESS (proc
)->encoding_carryover
);
3307 struct Lisp_Process
*p
= XPROCESS (proc
);
3308 VMS_PROC_STUFF
*vs
, *get_vms_process_pointer();
3311 if (! NILP (XPROCESS (proc
)->raw_status_low
))
3312 update_status (XPROCESS (proc
));
3313 if (! EQ (XPROCESS (proc
)->status
, Qrun
))
3314 error ("Process %s not running", procname
);
3315 if (XINT (XPROCESS (proc
)->outfd
) < 0)
3316 error ("Output file descriptor of %s is closed", procname
);
3318 coding
= proc_encode_coding_system
[XINT (XPROCESS (proc
)->outfd
)];
3319 Vlast_coding_system_used
= coding
->symbol
;
3321 if (CODING_REQUIRE_ENCODING (coding
))
3323 int require
= encoding_buffer_size (coding
, len
);
3325 unsigned char *temp_buf
= NULL
;
3327 /* Remember the offset of data because a string or a buffer may
3328 be relocated. Setting OFFSET to -1 means we don't have to
3329 care about relocation. */
3330 offset
= (BUFFERP (object
)
3331 ? BUF_PTR_BYTE_POS (XBUFFER (object
), buf
)
3333 ? buf
- XSTRING (object
)->data
3338 temp_buf
= (unsigned char *) xmalloc (len
+ carryover
);
3342 if (BUFFERP (object
))
3343 buf
= BUF_BYTE_ADDRESS (XBUFFER (object
), offset
);
3344 else if (STRINGP (object
))
3345 buf
= offset
+ XSTRING (object
)->data
;
3346 /* Now we don't have to care about relocation. */
3349 bcopy ((XSTRING (XPROCESS (proc
)->encoding_buf
)->data
3350 + STRING_BYTES (XSTRING (XPROCESS (proc
)->encoding_buf
))
3354 bcopy (buf
, temp_buf
+ carryover
, len
);
3358 if (STRING_BYTES (XSTRING (XPROCESS (proc
)->encoding_buf
)) < require
)
3360 XPROCESS (proc
)->encoding_buf
= make_uninit_string (require
);
3364 if (BUFFERP (object
))
3365 buf
= BUF_BYTE_ADDRESS (XBUFFER (object
), offset
);
3366 else if (STRINGP (object
))
3367 buf
= offset
+ XSTRING (object
)->data
;
3370 object
= XPROCESS (proc
)->encoding_buf
;
3371 encode_coding (coding
, buf
, XSTRING (object
)->data
,
3372 len
, STRING_BYTES (XSTRING (object
)));
3373 len
= coding
->produced
;
3374 buf
= XSTRING (object
)->data
;
3380 vs
= get_vms_process_pointer (p
->pid
);
3382 error ("Could not find this process: %x", p
->pid
);
3383 else if (write_to_vms_process (vs
, buf
, len
))
3387 if (pty_max_bytes
== 0)
3389 #if defined (HAVE_FPATHCONF) && defined (_PC_MAX_CANON)
3390 pty_max_bytes
= fpathconf (XFASTINT (XPROCESS (proc
)->outfd
),
3392 if (pty_max_bytes
< 0)
3393 pty_max_bytes
= 250;
3395 pty_max_bytes
= 250;
3397 /* Deduct one, to leave space for the eof. */
3401 if (!setjmp (send_process_frame
))
3405 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 */