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