1 /* Asynchronous subprocess control for GNU Emacs.
2 Copyright (C) 1985, 86, 87, 88, 93, 94, 95, 96, 98, 1999
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. */
23 #define _GNU_SOURCE /* to get strsignal declared with glibc 2 */
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 */
47 #if defined(WINDOWSNT) || defined(UNIX98_PTYS)
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 GNU/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"
111 #include "composite.h"
114 #define max(a, b) ((a) > (b) ? (a) : (b))
116 Lisp_Object Qprocessp
;
117 Lisp_Object Qrun
, Qstop
, Qsignal
, Qopen
, Qclosed
;
118 Lisp_Object Qlast_nonmenu_event
;
119 /* Qexit is declared and initialized in eval.c. */
121 /* a process object is a network connection when its childp field is neither
122 Qt nor Qnil but is instead a cons cell (HOSTNAME PORTNUM). */
125 #define NETCONN_P(p) (GC_CONSP (XPROCESS (p)->childp))
127 #define NETCONN_P(p) 0
128 #endif /* HAVE_SOCKETS */
130 /* Define first descriptor number available for subprocesses. */
132 #define FIRST_PROC_DESC 1
134 #define FIRST_PROC_DESC 3
137 /* Define SIGCHLD as an alias for SIGCLD. There are many conditionals
140 #if !defined (SIGCHLD) && defined (SIGCLD)
141 #define SIGCHLD SIGCLD
144 #include "syssignal.h"
148 extern void set_waiting_for_input
P_ ((EMACS_TIME
*));
152 extern char *sys_errlist
[];
159 /* t means use pty, nil means use a pipe,
160 maybe other values to come. */
161 static Lisp_Object Vprocess_connection_type
;
165 #include <sys/socket.h>
169 /* These next two vars are non-static since sysdep.c uses them in the
170 emulation of `select'. */
171 /* Number of events of change of status of a process. */
173 /* Number of events for which the user or sentinel has been notified. */
176 #include "sysselect.h"
178 extern int keyboard_bit_set
P_ ((SELECT_TYPE
*));
180 /* If we support a window system, turn on the code to poll periodically
181 to detect C-g. It isn't actually used when doing interrupt input. */
182 #ifdef HAVE_WINDOW_SYSTEM
183 #define POLL_FOR_INPUT
186 /* Mask of bits indicating the descriptors that we wait for input on. */
188 static SELECT_TYPE input_wait_mask
;
190 /* Mask that excludes keyboard input descriptor (s). */
192 static SELECT_TYPE non_keyboard_wait_mask
;
194 /* Mask that excludes process input descriptor (s). */
196 static SELECT_TYPE non_process_wait_mask
;
198 /* The largest descriptor currently in use for a process object. */
199 static int max_process_desc
;
201 /* The largest descriptor currently in use for keyboard input. */
202 static int max_keyboard_desc
;
204 /* Nonzero means delete a process right away if it exits. */
205 static int delete_exited_processes
;
207 /* Indexed by descriptor, gives the process (if any) for that descriptor */
208 Lisp_Object chan_process
[MAXDESC
];
210 /* Alist of elements (NAME . PROCESS) */
211 Lisp_Object Vprocess_alist
;
213 /* Buffered-ahead input char from process, indexed by channel.
214 -1 means empty (no char is buffered).
215 Used on sys V where the only way to tell if there is any
216 output from the process is to read at least one char.
217 Always -1 on systems that support FIONREAD. */
219 /* Don't make static; need to access externally. */
220 int proc_buffered_char
[MAXDESC
];
222 /* Table of `struct coding-system' for each process. */
223 static struct coding_system
*proc_decode_coding_system
[MAXDESC
];
224 static struct coding_system
*proc_encode_coding_system
[MAXDESC
];
226 static Lisp_Object
get_process ();
228 extern EMACS_TIME
timer_check ();
229 extern int timers_run
;
231 /* Maximum number of bytes to send to a pty without an eof. */
232 static int pty_max_bytes
;
234 extern Lisp_Object Vfile_name_coding_system
, Vdefault_file_name_coding_system
;
237 /* The file name of the pty opened by allocate_pty. */
239 static char pty_name
[24];
242 /* Compute the Lisp form of the process status, p->status, from
243 the numeric status that was returned by `wait'. */
245 Lisp_Object
status_convert ();
249 struct Lisp_Process
*p
;
251 union { int i
; WAITTYPE wt
; } u
;
252 u
.i
= XFASTINT (p
->raw_status_low
) + (XFASTINT (p
->raw_status_high
) << 16);
253 p
->status
= status_convert (u
.wt
);
254 p
->raw_status_low
= Qnil
;
255 p
->raw_status_high
= Qnil
;
258 /* Convert a process status word in Unix format to
259 the list that we use internally. */
266 return Fcons (Qstop
, Fcons (make_number (WSTOPSIG (w
)), Qnil
));
267 else if (WIFEXITED (w
))
268 return Fcons (Qexit
, Fcons (make_number (WRETCODE (w
)),
269 WCOREDUMP (w
) ? Qt
: Qnil
));
270 else if (WIFSIGNALED (w
))
271 return Fcons (Qsignal
, Fcons (make_number (WTERMSIG (w
)),
272 WCOREDUMP (w
) ? Qt
: Qnil
));
277 /* Given a status-list, extract the three pieces of information
278 and store them individually through the three pointers. */
281 decode_status (l
, symbol
, code
, coredump
)
299 *code
= XFASTINT (XCAR (tem
));
301 *coredump
= !NILP (tem
);
305 /* Return a string describing a process status list. */
308 status_message (status
)
313 Lisp_Object string
, string2
;
315 decode_status (status
, &symbol
, &code
, &coredump
);
317 if (EQ (symbol
, Qsignal
) || EQ (symbol
, Qstop
))
320 synchronize_system_messages_locale ();
321 signame
= strsignal (code
);
324 string
= build_string (signame
);
325 string2
= build_string (coredump
? " (core dumped)\n" : "\n");
326 XSTRING (string
)->data
[0] = DOWNCASE (XSTRING (string
)->data
[0]);
327 return concat2 (string
, string2
);
329 else if (EQ (symbol
, Qexit
))
332 return build_string ("finished\n");
333 string
= Fnumber_to_string (make_number (code
));
334 string2
= build_string (coredump
? " (core dumped)\n" : "\n");
335 return concat2 (build_string ("exited abnormally with code "),
336 concat2 (string
, string2
));
339 return Fcopy_sequence (Fsymbol_name (symbol
));
344 /* Open an available pty, returning a file descriptor.
345 Return -1 on failure.
346 The file name of the terminal corresponding to the pty
347 is left in the variable pty_name. */
356 /* Some systems name their pseudoterminals so that there are gaps in
357 the usual sequence - for example, on HP9000/S700 systems, there
358 are no pseudoterminals with names ending in 'f'. So we wait for
359 three failures in a row before deciding that we've reached the
361 int failed_count
= 0;
366 for (c
= FIRST_PTY_LETTER
; c
<= 'z'; c
++)
367 for (i
= 0; i
< 16; i
++)
370 #ifdef PTY_NAME_SPRINTF
373 sprintf (pty_name
, "/dev/pty%c%x", c
, i
);
374 #endif /* no PTY_NAME_SPRINTF */
378 #else /* no PTY_OPEN */
380 /* Unusual IRIS code */
381 *ptyv
= emacs_open ("/dev/ptc", O_RDWR
| O_NDELAY
, 0);
384 if (fstat (fd
, &stb
) < 0)
387 if (stat (pty_name
, &stb
) < 0)
390 if (failed_count
>= 3)
396 fd
= emacs_open (pty_name
, O_RDWR
| O_NONBLOCK
, 0);
398 fd
= emacs_open (pty_name
, O_RDWR
| O_NDELAY
, 0);
400 #endif /* not IRIS */
401 #endif /* no PTY_OPEN */
405 /* check to make certain that both sides are available
406 this avoids a nasty yet stupid bug in rlogins */
407 #ifdef PTY_TTY_NAME_SPRINTF
410 sprintf (pty_name
, "/dev/tty%c%x", c
, i
);
411 #endif /* no PTY_TTY_NAME_SPRINTF */
413 if (access (pty_name
, 6) != 0)
416 #if !defined(IRIS) && !defined(__sgi)
422 #endif /* not UNIPLUS */
429 #endif /* HAVE_PTYS */
435 struct Lisp_Vector
*vec
;
436 register Lisp_Object val
, tem
, name1
;
437 register struct Lisp_Process
*p
;
441 vec
= allocate_vectorlike ((EMACS_INT
) VECSIZE (struct Lisp_Process
));
442 for (i
= 0; i
< VECSIZE (struct Lisp_Process
); i
++)
443 vec
->contents
[i
] = Qnil
;
444 vec
->size
= VECSIZE (struct Lisp_Process
);
445 p
= (struct Lisp_Process
*)vec
;
447 XSETINT (p
->infd
, -1);
448 XSETINT (p
->outfd
, -1);
449 XSETFASTINT (p
->pid
, 0);
450 XSETFASTINT (p
->tick
, 0);
451 XSETFASTINT (p
->update_tick
, 0);
452 p
->raw_status_low
= Qnil
;
453 p
->raw_status_high
= Qnil
;
455 p
->mark
= Fmake_marker ();
457 /* If name is already in use, modify it until it is unused. */
462 tem
= Fget_process (name1
);
463 if (NILP (tem
)) break;
464 sprintf (suffix
, "<%d>", i
);
465 name1
= concat2 (name
, build_string (suffix
));
469 XSETPROCESS (val
, p
);
470 Vprocess_alist
= Fcons (Fcons (name
, val
), Vprocess_alist
);
475 remove_process (proc
)
476 register Lisp_Object proc
;
478 register Lisp_Object pair
;
480 pair
= Frassq (proc
, Vprocess_alist
);
481 Vprocess_alist
= Fdelq (pair
, Vprocess_alist
);
483 deactivate_process (proc
);
486 DEFUN ("processp", Fprocessp
, Sprocessp
, 1, 1, 0,
487 "Return t if OBJECT is a process.")
491 return PROCESSP (object
) ? Qt
: Qnil
;
494 DEFUN ("get-process", Fget_process
, Sget_process
, 1, 1, 0,
495 "Return the process named NAME, or nil if there is none.")
497 register Lisp_Object name
;
501 CHECK_STRING (name
, 0);
502 return Fcdr (Fassoc (name
, Vprocess_alist
));
505 DEFUN ("get-buffer-process", Fget_buffer_process
, Sget_buffer_process
, 1, 1, 0,
506 "Return the (or a) process associated with BUFFER.\n\
507 BUFFER may be a buffer or the name of one.")
509 register Lisp_Object buffer
;
511 register Lisp_Object buf
, tail
, proc
;
513 if (NILP (buffer
)) return Qnil
;
514 buf
= Fget_buffer (buffer
);
515 if (NILP (buf
)) return Qnil
;
517 for (tail
= Vprocess_alist
; !NILP (tail
); tail
= Fcdr (tail
))
519 proc
= Fcdr (Fcar (tail
));
520 if (PROCESSP (proc
) && EQ (XPROCESS (proc
)->buffer
, buf
))
526 /* This is how commands for the user decode process arguments. It
527 accepts a process, a process name, a buffer, a buffer name, or nil.
528 Buffers denote the first process in the buffer, and nil denotes the
533 register Lisp_Object name
;
535 register Lisp_Object proc
, obj
;
538 obj
= Fget_process (name
);
540 obj
= Fget_buffer (name
);
542 error ("Process %s does not exist", XSTRING (name
)->data
);
544 else if (NILP (name
))
545 obj
= Fcurrent_buffer ();
549 /* Now obj should be either a buffer object or a process object.
553 proc
= Fget_buffer_process (obj
);
555 error ("Buffer %s has no process", XSTRING (XBUFFER (obj
)->name
)->data
);
559 CHECK_PROCESS (obj
, 0);
565 DEFUN ("delete-process", Fdelete_process
, Sdelete_process
, 1, 1, 0,
566 "Delete PROCESS: kill it and forget about it immediately.\n\
567 PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
568 nil, indicating the current buffer's process.")
570 register Lisp_Object process
;
572 process
= get_process (process
);
573 XPROCESS (process
)->raw_status_low
= Qnil
;
574 XPROCESS (process
)->raw_status_high
= Qnil
;
575 if (NETCONN_P (process
))
577 XPROCESS (process
)->status
= Fcons (Qexit
, Fcons (make_number (0), Qnil
));
578 XSETINT (XPROCESS (process
)->tick
, ++process_tick
);
580 else if (XINT (XPROCESS (process
)->infd
) >= 0)
582 Fkill_process (process
, Qnil
);
583 /* Do this now, since remove_process will make sigchld_handler do nothing. */
584 XPROCESS (process
)->status
585 = Fcons (Qsignal
, Fcons (make_number (SIGKILL
), Qnil
));
586 XSETINT (XPROCESS (process
)->tick
, ++process_tick
);
589 remove_process (process
);
593 DEFUN ("process-status", Fprocess_status
, Sprocess_status
, 1, 1, 0,
594 "Return the status of PROCESS.\n\
595 The returned value is one of the following symbols:\n\
596 run -- for a process that is running.\n\
597 stop -- for a process stopped but continuable.\n\
598 exit -- for a process that has exited.\n\
599 signal -- for a process that has got a fatal signal.\n\
600 open -- for a network stream connection that is open.\n\
601 closed -- for a network stream connection that is closed.\n\
602 nil -- if arg is a process name and no such process exists.\n\
603 PROCESS may be a process, a buffer, the name of a process, or\n\
604 nil, indicating the current buffer's process.")
606 register Lisp_Object process
;
608 register struct Lisp_Process
*p
;
609 register Lisp_Object status
;
611 if (STRINGP (process
))
612 process
= Fget_process (process
);
614 process
= get_process (process
);
619 p
= XPROCESS (process
);
620 if (!NILP (p
->raw_status_low
))
624 status
= XCAR (status
);
625 if (NETCONN_P (process
))
627 if (EQ (status
, Qrun
))
629 else if (EQ (status
, Qexit
))
635 DEFUN ("process-exit-status", Fprocess_exit_status
, Sprocess_exit_status
,
637 "Return the exit status of PROCESS or the signal number that killed it.\n\
638 If PROCESS has not yet exited or died, return 0.")
640 register Lisp_Object process
;
642 CHECK_PROCESS (process
, 0);
643 if (!NILP (XPROCESS (process
)->raw_status_low
))
644 update_status (XPROCESS (process
));
645 if (CONSP (XPROCESS (process
)->status
))
646 return XCAR (XCDR (XPROCESS (process
)->status
));
647 return make_number (0);
650 DEFUN ("process-id", Fprocess_id
, Sprocess_id
, 1, 1, 0,
651 "Return the process id of PROCESS.\n\
652 This is the pid of the Unix process which PROCESS uses or talks to.\n\
653 For a network connection, this value is nil.")
655 register Lisp_Object process
;
657 CHECK_PROCESS (process
, 0);
658 return XPROCESS (process
)->pid
;
661 DEFUN ("process-name", Fprocess_name
, Sprocess_name
, 1, 1, 0,
662 "Return the name of PROCESS, as a string.\n\
663 This is the name of the program invoked in PROCESS,\n\
664 possibly modified to make it unique among process names.")
666 register Lisp_Object process
;
668 CHECK_PROCESS (process
, 0);
669 return XPROCESS (process
)->name
;
672 DEFUN ("process-command", Fprocess_command
, Sprocess_command
, 1, 1, 0,
673 "Return the command that was executed to start PROCESS.\n\
674 This is a list of strings, the first string being the program executed\n\
675 and the rest of the strings being the arguments given to it.\n\
676 For a non-child channel, this is nil.")
678 register Lisp_Object process
;
680 CHECK_PROCESS (process
, 0);
681 return XPROCESS (process
)->command
;
684 DEFUN ("process-tty-name", Fprocess_tty_name
, Sprocess_tty_name
, 1, 1, 0,
685 "Return the name of the terminal PROCESS uses, or nil if none.\n\
686 This is the terminal that the process itself reads and writes on,\n\
687 not the name of the pty that Emacs uses to talk with that terminal.")
689 register Lisp_Object process
;
691 CHECK_PROCESS (process
, 0);
692 return XPROCESS (process
)->tty_name
;
695 DEFUN ("set-process-buffer", Fset_process_buffer
, Sset_process_buffer
,
697 "Set buffer associated with PROCESS to BUFFER (a buffer, or nil).")
699 register Lisp_Object process
, buffer
;
701 CHECK_PROCESS (process
, 0);
703 CHECK_BUFFER (buffer
, 1);
704 XPROCESS (process
)->buffer
= buffer
;
708 DEFUN ("process-buffer", Fprocess_buffer
, Sprocess_buffer
,
710 "Return the buffer PROCESS is associated with.\n\
711 Output from PROCESS is inserted in this buffer unless PROCESS has a filter.")
713 register Lisp_Object process
;
715 CHECK_PROCESS (process
, 0);
716 return XPROCESS (process
)->buffer
;
719 DEFUN ("process-mark", Fprocess_mark
, Sprocess_mark
,
721 "Return the marker for the end of the last output from PROCESS.")
723 register Lisp_Object process
;
725 CHECK_PROCESS (process
, 0);
726 return XPROCESS (process
)->mark
;
729 DEFUN ("set-process-filter", Fset_process_filter
, Sset_process_filter
,
731 "Give PROCESS the filter function FILTER; nil means no filter.\n\
732 t means stop accepting output from the process.\n\
733 When a process has a filter, each time it does output\n\
734 the entire string of output is passed to the filter.\n\
735 The filter gets two arguments: the process and the string of output.\n\
736 If the process has a filter, its buffer is not used for output.")
738 register Lisp_Object process
, filter
;
740 CHECK_PROCESS (process
, 0);
743 FD_CLR (XINT (XPROCESS (process
)->infd
), &input_wait_mask
);
744 FD_CLR (XINT (XPROCESS (process
)->infd
), &non_keyboard_wait_mask
);
746 else if (EQ (XPROCESS (process
)->filter
, Qt
))
748 FD_SET (XINT (XPROCESS (process
)->infd
), &input_wait_mask
);
749 FD_SET (XINT (XPROCESS (process
)->infd
), &non_keyboard_wait_mask
);
751 XPROCESS (process
)->filter
= filter
;
755 DEFUN ("process-filter", Fprocess_filter
, Sprocess_filter
,
757 "Returns the filter function of PROCESS; nil if none.\n\
758 See `set-process-filter' for more info on filter functions.")
760 register Lisp_Object process
;
762 CHECK_PROCESS (process
, 0);
763 return XPROCESS (process
)->filter
;
766 DEFUN ("set-process-sentinel", Fset_process_sentinel
, Sset_process_sentinel
,
768 "Give PROCESS the sentinel SENTINEL; nil for none.\n\
769 The sentinel is called as a function when the process changes state.\n\
770 It gets two arguments: the process, and a string describing the change.")
772 register Lisp_Object process
, sentinel
;
774 CHECK_PROCESS (process
, 0);
775 XPROCESS (process
)->sentinel
= sentinel
;
779 DEFUN ("process-sentinel", Fprocess_sentinel
, Sprocess_sentinel
,
781 "Return the sentinel of PROCESS; nil if none.\n\
782 See `set-process-sentinel' for more info on sentinels.")
784 register Lisp_Object process
;
786 CHECK_PROCESS (process
, 0);
787 return XPROCESS (process
)->sentinel
;
790 DEFUN ("set-process-window-size", Fset_process_window_size
,
791 Sset_process_window_size
, 3, 3, 0,
792 "Tell PROCESS that it has logical window size HEIGHT and WIDTH.")
793 (process
, height
, width
)
794 register Lisp_Object process
, height
, width
;
796 CHECK_PROCESS (process
, 0);
797 CHECK_NATNUM (height
, 0);
798 CHECK_NATNUM (width
, 0);
799 if (set_window_size (XINT (XPROCESS (process
)->infd
),
800 XINT (height
), XINT (width
)) <= 0)
806 DEFUN ("set-process-inherit-coding-system-flag",
807 Fset_process_inherit_coding_system_flag
,
808 Sset_process_inherit_coding_system_flag
, 2, 2, 0,
809 "Determine whether buffer of PROCESS will inherit coding-system.\n\
810 If the second argument FLAG is non-nil, then the variable\n\
811 `buffer-file-coding-system' of the buffer associated with PROCESS\n\
812 will be bound to the value of the coding system used to decode\n\
813 the process output.\n\
815 This is useful when the coding system specified for the process buffer\n\
816 leaves either the character code conversion or the end-of-line conversion\n\
817 unspecified, or if the coding system used to decode the process output\n\
818 is more appropriate for saving the process buffer.\n\
820 Binding the variable `inherit-process-coding-system' to non-nil before\n\
821 starting the process is an alternative way of setting the inherit flag\n\
822 for the process which will run.")
824 register Lisp_Object process
, flag
;
826 CHECK_PROCESS (process
, 0);
827 XPROCESS (process
)->inherit_coding_system_flag
= flag
;
831 DEFUN ("process-inherit-coding-system-flag",
832 Fprocess_inherit_coding_system_flag
, Sprocess_inherit_coding_system_flag
,
834 "Return the value of inherit-coding-system flag for PROCESS.\n\
835 If this flag is t, `buffer-file-coding-system' of the buffer\n\
836 associated with PROCESS will inherit the coding system used to decode\n\
837 the process output.")
839 register Lisp_Object process
;
841 CHECK_PROCESS (process
, 0);
842 return XPROCESS (process
)->inherit_coding_system_flag
;
845 DEFUN ("process-kill-without-query", Fprocess_kill_without_query
,
846 Sprocess_kill_without_query
, 1, 2, 0,
847 "Say no query needed if PROCESS is running when Emacs is exited.\n\
848 Optional second argument if non-nil says to require a query.\n\
849 Value is t if a query was formerly required.")
851 register Lisp_Object process
, value
;
855 CHECK_PROCESS (process
, 0);
856 tem
= XPROCESS (process
)->kill_without_query
;
857 XPROCESS (process
)->kill_without_query
= Fnull (value
);
862 DEFUN ("process-contact", Fprocess_contact
, Sprocess_contact
,
864 "Return the contact info of PROCESS; t for a real child.\n\
865 For a net connection, the value is a cons cell of the form (HOST SERVICE).")
867 register Lisp_Object process
;
869 CHECK_PROCESS (process
, 0);
870 return XPROCESS (process
)->childp
;
873 #if 0 /* Turned off because we don't currently record this info
874 in the process. Perhaps add it. */
875 DEFUN ("process-connection", Fprocess_connection
, Sprocess_connection
, 1, 1, 0,
876 "Return the connection type of PROCESS.\n\
877 The value is nil for a pipe, t or `pty' for a pty, or `stream' for\n\
878 a socket connection.")
882 return XPROCESS (process
)->type
;
889 register Lisp_Object tail
, tem
;
890 Lisp_Object proc
, minspace
, tem1
;
891 register struct Lisp_Process
*p
;
894 XSETFASTINT (minspace
, 1);
896 set_buffer_internal (XBUFFER (Vstandard_output
));
897 Fbuffer_disable_undo (Vstandard_output
);
899 current_buffer
->truncate_lines
= Qt
;
902 Proc Status Buffer Tty Command\n\
903 ---- ------ ------ --- -------\n", -1);
905 for (tail
= Vprocess_alist
; !NILP (tail
); tail
= Fcdr (tail
))
909 proc
= Fcdr (Fcar (tail
));
911 if (NILP (p
->childp
))
914 Finsert (1, &p
->name
);
915 Findent_to (make_number (13), minspace
);
917 if (!NILP (p
->raw_status_low
))
920 if (CONSP (p
->status
))
921 symbol
= XCAR (p
->status
);
924 if (EQ (symbol
, Qsignal
))
927 tem
= Fcar (Fcdr (p
->status
));
929 if (XINT (tem
) < NSIG
)
930 write_string (sys_errlist
[XINT (tem
)], -1);
933 Fprinc (symbol
, Qnil
);
935 else if (NETCONN_P (proc
))
937 if (EQ (symbol
, Qrun
))
938 write_string ("open", -1);
939 else if (EQ (symbol
, Qexit
))
940 write_string ("closed", -1);
942 Fprinc (symbol
, Qnil
);
945 Fprinc (symbol
, Qnil
);
947 if (EQ (symbol
, Qexit
))
950 tem
= Fcar (Fcdr (p
->status
));
953 sprintf (tembuf
, " %d", (int) XFASTINT (tem
));
954 write_string (tembuf
, -1);
958 if (EQ (symbol
, Qsignal
) || EQ (symbol
, Qexit
))
959 remove_process (proc
);
961 Findent_to (make_number (22), minspace
);
962 if (NILP (p
->buffer
))
963 insert_string ("(none)");
964 else if (NILP (XBUFFER (p
->buffer
)->name
))
965 insert_string ("(Killed)");
967 Finsert (1, &XBUFFER (p
->buffer
)->name
);
969 Findent_to (make_number (37), minspace
);
971 if (STRINGP (p
->tty_name
))
972 Finsert (1, &p
->tty_name
);
974 insert_string ("(none)");
976 Findent_to (make_number (49), minspace
);
978 if (NETCONN_P (proc
))
980 sprintf (tembuf
, "(network stream connection to %s)\n",
981 XSTRING (XCAR (p
->childp
))->data
);
982 insert_string (tembuf
);
996 insert_string ("\n");
1002 DEFUN ("list-processes", Flist_processes
, Slist_processes
, 0, 0, "",
1003 "Display a list of all processes.\n\
1004 Any process listed as exited or signaled is actually eliminated\n\
1005 after the listing is made.")
1008 internal_with_output_to_temp_buffer ("*Process List*",
1009 list_processes_1
, Qnil
);
1013 DEFUN ("process-list", Fprocess_list
, Sprocess_list
, 0, 0, 0,
1014 "Return a list of all processes.")
1017 return Fmapcar (Qcdr
, Vprocess_alist
);
1020 /* Starting asynchronous inferior processes. */
1022 static Lisp_Object
start_process_unwind ();
1024 DEFUN ("start-process", Fstart_process
, Sstart_process
, 3, MANY
, 0,
1025 "Start a program in a subprocess. Return the process object for it.\n\
1026 NAME is name for process. It is modified if necessary to make it unique.\n\
1027 BUFFER is the buffer or (buffer-name) to associate with the process.\n\
1028 Process output goes at end of that buffer, unless you specify\n\
1029 an output stream or filter function to handle the output.\n\
1030 BUFFER may be also nil, meaning that this process is not associated\n\
1032 Third arg is program file name. It is searched for in PATH.\n\
1033 Remaining arguments are strings to give program as arguments.")
1036 register Lisp_Object
*args
;
1038 Lisp_Object buffer
, name
, program
, proc
, current_dir
, tem
;
1040 register unsigned char *new_argv
;
1043 register unsigned char **new_argv
;
1046 int count
= specpdl_ptr
- specpdl
;
1050 buffer
= Fget_buffer_create (buffer
);
1052 /* Make sure that the child will be able to chdir to the current
1053 buffer's current directory, or its unhandled equivalent. We
1054 can't just have the child check for an error when it does the
1055 chdir, since it's in a vfork.
1057 We have to GCPRO around this because Fexpand_file_name and
1058 Funhandled_file_name_directory might call a file name handling
1059 function. The argument list is protected by the caller, so all
1060 we really have to worry about is buffer. */
1062 struct gcpro gcpro1
, gcpro2
;
1064 current_dir
= current_buffer
->directory
;
1066 GCPRO2 (buffer
, current_dir
);
1069 = expand_and_dir_to_file (Funhandled_file_name_directory (current_dir
),
1071 if (NILP (Ffile_accessible_directory_p (current_dir
)))
1072 report_file_error ("Setting current directory",
1073 Fcons (current_buffer
->directory
, Qnil
));
1079 CHECK_STRING (name
, 0);
1083 CHECK_STRING (program
, 2);
1085 proc
= make_process (name
);
1086 /* If an error occurs and we can't start the process, we want to
1087 remove it from the process list. This means that each error
1088 check in create_process doesn't need to call remove_process
1089 itself; it's all taken care of here. */
1090 record_unwind_protect (start_process_unwind
, proc
);
1092 XPROCESS (proc
)->childp
= Qt
;
1093 XPROCESS (proc
)->command_channel_p
= Qnil
;
1094 XPROCESS (proc
)->buffer
= buffer
;
1095 XPROCESS (proc
)->sentinel
= Qnil
;
1096 XPROCESS (proc
)->filter
= Qnil
;
1097 XPROCESS (proc
)->command
= Flist (nargs
- 2, args
+ 2);
1099 /* Make the process marker point into the process buffer (if any). */
1101 set_marker_both (XPROCESS (proc
)->mark
, buffer
,
1102 BUF_ZV (XBUFFER (buffer
)),
1103 BUF_ZV_BYTE (XBUFFER (buffer
)));
1106 /* Decide coding systems for communicating with the process. Here
1107 we don't setup the structure coding_system nor pay attention to
1108 unibyte mode. They are done in create_process. */
1110 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
1111 Lisp_Object coding_systems
= Qt
;
1112 Lisp_Object val
, *args2
;
1113 struct gcpro gcpro1
, gcpro2
;
1115 val
= Vcoding_system_for_read
;
1118 args2
= (Lisp_Object
*) alloca ((nargs
+ 1) * sizeof *args2
);
1119 args2
[0] = Qstart_process
;
1120 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
1121 GCPRO2 (proc
, current_dir
);
1122 coding_systems
= Ffind_operation_coding_system (nargs
+ 1, args2
);
1124 if (CONSP (coding_systems
))
1125 val
= XCAR (coding_systems
);
1126 else if (CONSP (Vdefault_process_coding_system
))
1127 val
= XCAR (Vdefault_process_coding_system
);
1129 XPROCESS (proc
)->decode_coding_system
= val
;
1131 val
= Vcoding_system_for_write
;
1134 if (EQ (coding_systems
, Qt
))
1136 args2
= (Lisp_Object
*) alloca ((nargs
+ 1) * sizeof args2
);
1137 args2
[0] = Qstart_process
;
1138 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
1139 GCPRO2 (proc
, current_dir
);
1140 coding_systems
= Ffind_operation_coding_system (nargs
+ 1, args2
);
1143 if (CONSP (coding_systems
))
1144 val
= XCDR (coding_systems
);
1145 else if (CONSP (Vdefault_process_coding_system
))
1146 val
= XCDR (Vdefault_process_coding_system
);
1148 XPROCESS (proc
)->encode_coding_system
= val
;
1152 /* Make a one member argv with all args concatenated
1153 together separated by a blank. */
1154 len
= STRING_BYTES (XSTRING (program
)) + 2;
1155 for (i
= 3; i
< nargs
; i
++)
1158 CHECK_STRING (tem
, i
);
1159 len
+= STRING_BYTES (XSTRING (tem
)) + 1; /* count the blank */
1161 new_argv
= (unsigned char *) alloca (len
);
1162 strcpy (new_argv
, XSTRING (program
)->data
);
1163 for (i
= 3; i
< nargs
; i
++)
1166 CHECK_STRING (tem
, i
);
1167 strcat (new_argv
, " ");
1168 strcat (new_argv
, XSTRING (tem
)->data
);
1170 /* Need to add code here to check for program existence on VMS */
1173 new_argv
= (unsigned char **) alloca ((nargs
- 1) * sizeof (char *));
1175 /* If program file name is not absolute, search our path for it */
1176 if (!IS_DIRECTORY_SEP (XSTRING (program
)->data
[0])
1177 && !(XSTRING (program
)->size
> 1
1178 && IS_DEVICE_SEP (XSTRING (program
)->data
[1])))
1180 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1183 GCPRO4 (name
, program
, buffer
, current_dir
);
1184 openp (Vexec_path
, program
, EXEC_SUFFIXES
, &tem
, 1);
1187 report_file_error ("Searching for program", Fcons (program
, Qnil
));
1188 tem
= Fexpand_file_name (tem
, Qnil
);
1189 tem
= ENCODE_FILE (tem
);
1190 new_argv
[0] = XSTRING (tem
)->data
;
1194 if (!NILP (Ffile_directory_p (program
)))
1195 error ("Specified program for new process is a directory");
1197 tem
= ENCODE_FILE (program
);
1198 new_argv
[0] = XSTRING (tem
)->data
;
1201 /* Here we encode arguments by the coding system used for sending
1202 data to the process. We don't support using different coding
1203 systems for encoding arguments and for encoding data sent to the
1206 for (i
= 3; i
< nargs
; i
++)
1209 CHECK_STRING (tem
, i
);
1210 if (STRING_MULTIBYTE (tem
))
1211 tem
= (code_convert_string_norecord
1212 (tem
, XPROCESS (proc
)->encode_coding_system
, 1));
1213 new_argv
[i
- 2] = XSTRING (tem
)->data
;
1215 new_argv
[i
- 2] = 0;
1216 #endif /* not VMS */
1218 XPROCESS (proc
)->decoding_buf
= make_uninit_string (0);
1219 XPROCESS (proc
)->decoding_carryover
= make_number (0);
1220 XPROCESS (proc
)->encoding_buf
= make_uninit_string (0);
1221 XPROCESS (proc
)->encoding_carryover
= make_number (0);
1223 XPROCESS (proc
)->inherit_coding_system_flag
1224 = (NILP (buffer
) || !inherit_process_coding_system
1227 create_process (proc
, (char **) new_argv
, current_dir
);
1229 return unbind_to (count
, proc
);
1232 /* This function is the unwind_protect form for Fstart_process. If
1233 PROC doesn't have its pid set, then we know someone has signaled
1234 an error and the process wasn't started successfully, so we should
1235 remove it from the process list. */
1237 start_process_unwind (proc
)
1240 if (!PROCESSP (proc
))
1243 /* Was PROC started successfully? */
1244 if (XINT (XPROCESS (proc
)->pid
) <= 0)
1245 remove_process (proc
);
1251 create_process_1 (timer
)
1252 struct atimer
*timer
;
1254 /* Nothing to do. */
1258 #if 0 /* This doesn't work; see the note before sigchld_handler. */
1261 /* Mimic blocking of signals on system V, which doesn't really have it. */
1263 /* Nonzero means we got a SIGCHLD when it was supposed to be blocked. */
1264 int sigchld_deferred
;
1267 create_process_sigchld ()
1269 signal (SIGCHLD
, create_process_sigchld
);
1271 sigchld_deferred
= 1;
1277 #ifndef VMS /* VMS version of this function is in vmsproc.c. */
1279 create_process (process
, new_argv
, current_dir
)
1280 Lisp_Object process
;
1282 Lisp_Object current_dir
;
1284 int pid
, inchannel
, outchannel
;
1286 #ifdef POSIX_SIGNALS
1289 struct sigaction sigint_action
;
1290 struct sigaction sigquit_action
;
1292 struct sigaction sighup_action
;
1294 #else /* !POSIX_SIGNALS */
1297 SIGTYPE (*sigchld
)();
1300 #endif /* !POSIX_SIGNALS */
1301 /* Use volatile to protect variables from being clobbered by longjmp. */
1302 volatile int forkin
, forkout
;
1303 volatile int pty_flag
= 0;
1304 extern char **environ
;
1305 Lisp_Object buffer
= XPROCESS (process
)->buffer
;
1307 inchannel
= outchannel
= -1;
1310 if (!NILP (Vprocess_connection_type
))
1311 outchannel
= inchannel
= allocate_pty ();
1316 /* On USG systems it does not work to open the pty's tty here
1317 and then close and reopen it in the child. */
1319 /* Don't let this terminal become our controlling terminal
1320 (in case we don't have one). */
1321 forkout
= forkin
= emacs_open (pty_name
, O_RDWR
| O_NOCTTY
, 0);
1323 forkout
= forkin
= emacs_open (pty_name
, O_RDWR
, 0);
1326 report_file_error ("Opening pty", Qnil
);
1328 forkin
= forkout
= -1;
1329 #endif /* not USG */
1333 #endif /* HAVE_PTYS */
1336 if (socketpair (AF_UNIX
, SOCK_STREAM
, 0, sv
) < 0)
1337 report_file_error ("Opening socketpair", Qnil
);
1338 outchannel
= inchannel
= sv
[0];
1339 forkout
= forkin
= sv
[1];
1341 #else /* not SKTPAIR */
1346 report_file_error ("Creating pipe", Qnil
);
1352 emacs_close (inchannel
);
1353 emacs_close (forkout
);
1354 report_file_error ("Creating pipe", Qnil
);
1359 #endif /* not SKTPAIR */
1362 /* Replaced by close_process_descs */
1363 set_exclusive_use (inchannel
);
1364 set_exclusive_use (outchannel
);
1367 /* Stride people say it's a mystery why this is needed
1368 as well as the O_NDELAY, but that it fails without this. */
1369 #if defined (STRIDE) || (defined (pfa) && defined (HAVE_PTYS))
1372 ioctl (inchannel
, FIONBIO
, &one
);
1377 fcntl (inchannel
, F_SETFL
, O_NONBLOCK
);
1378 fcntl (outchannel
, F_SETFL
, O_NONBLOCK
);
1381 fcntl (inchannel
, F_SETFL
, O_NDELAY
);
1382 fcntl (outchannel
, F_SETFL
, O_NDELAY
);
1386 /* Record this as an active process, with its channels.
1387 As a result, child_setup will close Emacs's side of the pipes. */
1388 chan_process
[inchannel
] = process
;
1389 XSETINT (XPROCESS (process
)->infd
, inchannel
);
1390 XSETINT (XPROCESS (process
)->outfd
, outchannel
);
1391 /* Record the tty descriptor used in the subprocess. */
1393 XPROCESS (process
)->subtty
= Qnil
;
1395 XSETFASTINT (XPROCESS (process
)->subtty
, forkin
);
1396 XPROCESS (process
)->pty_flag
= (pty_flag
? Qt
: Qnil
);
1397 XPROCESS (process
)->status
= Qrun
;
1398 if (!proc_decode_coding_system
[inchannel
])
1399 proc_decode_coding_system
[inchannel
]
1400 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
1401 setup_coding_system (XPROCESS (process
)->decode_coding_system
,
1402 proc_decode_coding_system
[inchannel
]);
1403 if (!proc_encode_coding_system
[outchannel
])
1404 proc_encode_coding_system
[outchannel
]
1405 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
1406 setup_coding_system (XPROCESS (process
)->encode_coding_system
,
1407 proc_encode_coding_system
[outchannel
]);
1409 if ((!NILP (buffer
) && NILP (XBUFFER (buffer
)->enable_multibyte_characters
))
1410 || (NILP (buffer
) && NILP (buffer_defaults
.enable_multibyte_characters
)))
1412 /* In unibyte mode, character code conversion should not take
1413 place but EOL conversion should. So, setup raw-text or one
1414 of the subsidiary according to the information just setup. */
1415 if (!NILP (XPROCESS (process
)->decode_coding_system
))
1416 setup_raw_text_coding_system (proc_decode_coding_system
[inchannel
]);
1417 if (!NILP (XPROCESS (process
)->encode_coding_system
))
1418 setup_raw_text_coding_system (proc_encode_coding_system
[outchannel
]);
1421 /* Delay interrupts until we have a chance to store
1422 the new fork's pid in its process structure */
1423 #ifdef POSIX_SIGNALS
1424 sigemptyset (&blocked
);
1426 sigaddset (&blocked
, SIGCHLD
);
1429 /* On many hosts (e.g. Solaris 2.4), if a vforked child calls `signal',
1430 this sets the parent's signal handlers as well as the child's.
1431 So delay all interrupts whose handlers the child might munge,
1432 and record the current handlers so they can be restored later. */
1433 sigaddset (&blocked
, SIGINT
); sigaction (SIGINT
, 0, &sigint_action
);
1434 sigaddset (&blocked
, SIGQUIT
); sigaction (SIGQUIT
, 0, &sigquit_action
);
1436 sigaddset (&blocked
, SIGHUP
); sigaction (SIGHUP
, 0, &sighup_action
);
1438 #endif /* HAVE_VFORK */
1439 sigprocmask (SIG_BLOCK
, &blocked
, &procmask
);
1440 #else /* !POSIX_SIGNALS */
1444 #else /* not BSD4_1 */
1445 #if defined (BSD_SYSTEM) || defined (UNIPLUS) || defined (HPUX)
1446 sigsetmask (sigmask (SIGCHLD
));
1447 #else /* ordinary USG */
1449 sigchld_deferred
= 0;
1450 sigchld
= signal (SIGCHLD
, create_process_sigchld
);
1452 #endif /* ordinary USG */
1453 #endif /* not BSD4_1 */
1454 #endif /* SIGCHLD */
1455 #endif /* !POSIX_SIGNALS */
1457 FD_SET (inchannel
, &input_wait_mask
);
1458 FD_SET (inchannel
, &non_keyboard_wait_mask
);
1459 if (inchannel
> max_process_desc
)
1460 max_process_desc
= inchannel
;
1462 /* Until we store the proper pid, enable sigchld_handler
1463 to recognize an unknown pid as standing for this process.
1464 It is very important not to let this `marker' value stay
1465 in the table after this function has returned; if it does
1466 it might cause call-process to hang and subsequent asynchronous
1467 processes to get their return values scrambled. */
1468 XSETINT (XPROCESS (process
)->pid
, -1);
1473 /* child_setup must clobber environ on systems with true vfork.
1474 Protect it from permanent change. */
1475 char **save_environ
= environ
;
1477 current_dir
= ENCODE_FILE (current_dir
);
1482 #endif /* not WINDOWSNT */
1484 int xforkin
= forkin
;
1485 int xforkout
= forkout
;
1487 #if 0 /* This was probably a mistake--it duplicates code later on,
1488 but fails to handle all the cases. */
1489 /* Make sure SIGCHLD is not blocked in the child. */
1490 sigsetmask (SIGEMPTYMASK
);
1493 /* Make the pty be the controlling terminal of the process. */
1495 /* First, disconnect its current controlling terminal. */
1497 /* We tried doing setsid only if pty_flag, but it caused
1498 process_set_signal to fail on SGI when using a pipe. */
1500 /* Make the pty's terminal the controlling terminal. */
1504 /* We ignore the return value
1505 because faith@cs.unc.edu says that is necessary on Linux. */
1506 ioctl (xforkin
, TIOCSCTTY
, 0);
1509 #else /* not HAVE_SETSID */
1511 /* It's very important to call setpgrp here and no time
1512 afterwards. Otherwise, we lose our controlling tty which
1513 is set when we open the pty. */
1516 #endif /* not HAVE_SETSID */
1517 #if defined (HAVE_TERMIOS) && defined (LDISC1)
1518 if (pty_flag
&& xforkin
>= 0)
1521 tcgetattr (xforkin
, &t
);
1523 if (tcsetattr (xforkin
, TCSANOW
, &t
) < 0)
1524 emacs_write (1, "create_process/tcsetattr LDISC1 failed\n", 39);
1527 #if defined (NTTYDISC) && defined (TIOCSETD)
1528 if (pty_flag
&& xforkin
>= 0)
1530 /* Use new line discipline. */
1531 int ldisc
= NTTYDISC
;
1532 ioctl (xforkin
, TIOCSETD
, &ldisc
);
1537 /* In 4.3BSD, the TIOCSPGRP bug has been fixed, and now you
1538 can do TIOCSPGRP only to the process's controlling tty. */
1541 /* I wonder: would just ioctl (0, TIOCNOTTY, 0) work here?
1542 I can't test it since I don't have 4.3. */
1543 int j
= emacs_open ("/dev/tty", O_RDWR
, 0);
1544 ioctl (j
, TIOCNOTTY
, 0);
1547 /* In order to get a controlling terminal on some versions
1548 of BSD, it is necessary to put the process in pgrp 0
1549 before it opens the terminal. */
1557 #endif /* TIOCNOTTY */
1559 #if !defined (RTU) && !defined (UNIPLUS) && !defined (DONT_REOPEN_PTY)
1560 /*** There is a suggestion that this ought to be a
1561 conditional on TIOCSPGRP,
1562 or !(defined (HAVE_SETSID) && defined (TIOCSCTTY)).
1563 Trying the latter gave the wrong results on Debian GNU/Linux 1.1;
1564 that system does seem to need this code, even though
1565 both HAVE_SETSID and TIOCSCTTY are defined. */
1566 /* Now close the pty (if we had it open) and reopen it.
1567 This makes the pty the controlling terminal of the subprocess. */
1570 #ifdef SET_CHILD_PTY_PGRP
1571 int pgrp
= getpid ();
1574 /* I wonder if emacs_close (emacs_open (pty_name, ...))
1577 emacs_close (xforkin
);
1578 xforkout
= xforkin
= emacs_open (pty_name
, O_RDWR
, 0);
1582 emacs_write (1, "Couldn't open the pty terminal ", 31);
1583 emacs_write (1, pty_name
, strlen (pty_name
));
1584 emacs_write (1, "\n", 1);
1588 #ifdef SET_CHILD_PTY_PGRP
1589 ioctl (xforkin
, TIOCSPGRP
, &pgrp
);
1590 ioctl (xforkout
, TIOCSPGRP
, &pgrp
);
1593 #endif /* not UNIPLUS and not RTU and not DONT_REOPEN_PTY */
1595 #ifdef SETUP_SLAVE_PTY
1600 #endif /* SETUP_SLAVE_PTY */
1602 /* On AIX, we've disabled SIGHUP above once we start a child on a pty.
1603 Now reenable it in the child, so it will die when we want it to. */
1605 signal (SIGHUP
, SIG_DFL
);
1607 #endif /* HAVE_PTYS */
1609 signal (SIGINT
, SIG_DFL
);
1610 signal (SIGQUIT
, SIG_DFL
);
1612 /* Stop blocking signals in the child. */
1613 #ifdef POSIX_SIGNALS
1614 sigprocmask (SIG_SETMASK
, &procmask
, 0);
1615 #else /* !POSIX_SIGNALS */
1619 #else /* not BSD4_1 */
1620 #if defined (BSD_SYSTEM) || defined (UNIPLUS) || defined (HPUX)
1621 sigsetmask (SIGEMPTYMASK
);
1622 #else /* ordinary USG */
1624 signal (SIGCHLD
, sigchld
);
1626 #endif /* ordinary USG */
1627 #endif /* not BSD4_1 */
1628 #endif /* SIGCHLD */
1629 #endif /* !POSIX_SIGNALS */
1632 child_setup_tty (xforkout
);
1634 pid
= child_setup (xforkin
, xforkout
, xforkout
,
1635 new_argv
, 1, current_dir
);
1636 #else /* not WINDOWSNT */
1637 child_setup (xforkin
, xforkout
, xforkout
,
1638 new_argv
, 1, current_dir
);
1639 #endif /* not WINDOWSNT */
1641 environ
= save_environ
;
1646 /* This runs in the Emacs process. */
1650 emacs_close (forkin
);
1651 if (forkin
!= forkout
&& forkout
>= 0)
1652 emacs_close (forkout
);
1656 /* vfork succeeded. */
1657 XSETFASTINT (XPROCESS (process
)->pid
, pid
);
1660 register_child (pid
, inchannel
);
1661 #endif /* WINDOWSNT */
1663 /* If the subfork execv fails, and it exits,
1664 this close hangs. I don't know why.
1665 So have an interrupt jar it loose. */
1667 struct atimer
*timer
;
1671 EMACS_SET_SECS_USECS (offset
, 1, 0);
1672 timer
= start_atimer (ATIMER_RELATIVE
, offset
, create_process_1
, 0);
1674 XPROCESS (process
)->subtty
= Qnil
;
1676 emacs_close (forkin
);
1678 cancel_atimer (timer
);
1682 if (forkin
!= forkout
&& forkout
>= 0)
1683 emacs_close (forkout
);
1687 XPROCESS (process
)->tty_name
= build_string (pty_name
);
1690 XPROCESS (process
)->tty_name
= Qnil
;
1693 /* Restore the signal state whether vfork succeeded or not.
1694 (We will signal an error, below, if it failed.) */
1695 #ifdef POSIX_SIGNALS
1697 /* Restore the parent's signal handlers. */
1698 sigaction (SIGINT
, &sigint_action
, 0);
1699 sigaction (SIGQUIT
, &sigquit_action
, 0);
1701 sigaction (SIGHUP
, &sighup_action
, 0);
1703 #endif /* HAVE_VFORK */
1704 /* Stop blocking signals in the parent. */
1705 sigprocmask (SIG_SETMASK
, &procmask
, 0);
1706 #else /* !POSIX_SIGNALS */
1710 #else /* not BSD4_1 */
1711 #if defined (BSD_SYSTEM) || defined (UNIPLUS) || defined (HPUX)
1712 sigsetmask (SIGEMPTYMASK
);
1713 #else /* ordinary USG */
1715 signal (SIGCHLD
, sigchld
);
1716 /* Now really handle any of these signals
1717 that came in during this function. */
1718 if (sigchld_deferred
)
1719 kill (getpid (), SIGCHLD
);
1721 #endif /* ordinary USG */
1722 #endif /* not BSD4_1 */
1723 #endif /* SIGCHLD */
1724 #endif /* !POSIX_SIGNALS */
1726 /* Now generate the error if vfork failed. */
1728 report_file_error ("Doing vfork", Qnil
);
1730 #endif /* not VMS */
1734 /* open a TCP network connection to a given HOST/SERVICE. Treated
1735 exactly like a normal process when reading and writing. Only
1736 differences are in status display and process deletion. A network
1737 connection has no PID; you cannot signal it. All you can do is
1738 deactivate and close it via delete-process */
1740 DEFUN ("open-network-stream", Fopen_network_stream
, Sopen_network_stream
,
1742 "Open a TCP connection for a service to a host.\n\
1743 Returns a subprocess-object to represent the connection.\n\
1744 Input and output work as for subprocesses; `delete-process' closes it.\n\
1745 Args are NAME BUFFER HOST SERVICE.\n\
1746 NAME is name for process. It is modified if necessary to make it unique.\n\
1747 BUFFER is the buffer (or buffer-name) to associate with the process.\n\
1748 Process output goes at end of that buffer, unless you specify\n\
1749 an output stream or filter function to handle the output.\n\
1750 BUFFER may be also nil, meaning that this process is not associated\n\
1752 Third arg is name of the host to connect to, or its IP address.\n\
1753 Fourth arg SERVICE is name of the service desired, or an integer\n\
1754 specifying a port number to connect to.")
1755 (name
, buffer
, host
, service
)
1756 Lisp_Object name
, buffer
, host
, service
;
1759 #ifndef HAVE_GETADDRINFO
1760 struct sockaddr_in address
;
1761 struct servent
*svc_info
;
1762 struct hostent
*host_info_ptr
, host_info
;
1763 char *(addr_list
[2]);
1764 IN_ADDR numeric_addr
;
1766 #else /* HAVE_GETADDRINFO */
1767 struct addrinfo hints
, *res
, *lres
;
1770 char *portstring
, portbuf
[128];
1771 #endif /* HAVE_GETADDRINFO */
1772 int s
= -1, outch
, inch
;
1773 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1775 int count
= specpdl_ptr
- specpdl
;
1779 /* Ensure socket support is loaded if available. */
1780 init_winsock (TRUE
);
1783 GCPRO4 (name
, buffer
, host
, service
);
1784 CHECK_STRING (name
, 0);
1785 CHECK_STRING (host
, 0);
1787 #ifdef HAVE_GETADDRINFO
1789 * SERVICE can either be a string or int.
1790 * Convert to a C string for later use by getaddrinfo.
1792 if (INTEGERP (service
))
1794 sprintf (portbuf
, "%d", XINT (service
));
1795 portstring
= portbuf
;
1799 CHECK_STRING (service
, 0);
1800 portstring
= XSTRING (service
)->data
;
1802 #else /* ! HAVE_GETADDRINFO */
1803 if (INTEGERP (service
))
1804 port
= htons ((unsigned short) XINT (service
));
1807 CHECK_STRING (service
, 0);
1808 svc_info
= getservbyname (XSTRING (service
)->data
, "tcp");
1810 error ("Unknown service \"%s\"", XSTRING (service
)->data
);
1811 port
= svc_info
->s_port
;
1813 #endif /* ! HAVE_GETADDRINFO */
1816 /* Slow down polling to every ten seconds.
1817 Some kernels have a bug which causes retrying connect to fail
1818 after a connect. Polling can interfere with gethostbyname too. */
1819 #ifdef POLL_FOR_INPUT
1820 record_unwind_protect (unwind_stop_other_atimers
, Qnil
);
1821 bind_polling_period (10);
1825 #ifdef HAVE_GETADDRINFO
1829 memset (&hints
, 0, sizeof (hints
));
1831 hints
.ai_family
= AF_UNSPEC
;
1832 hints
.ai_socktype
= SOCK_STREAM
;
1833 hints
.ai_protocol
= 0;
1834 ret
= getaddrinfo (XSTRING (host
)->data
, portstring
, &hints
, &res
);
1837 error ("%s/%s %s", XSTRING (host
)->data
, portstring
,
1844 count1
= specpdl_ptr
- specpdl
;
1845 record_unwind_protect (close_file_unwind
, make_number (s
));
1847 for (lres
= res
; lres
; lres
= lres
->ai_next
)
1849 s
= socket (lres
->ai_family
, lres
->ai_socktype
, lres
->ai_protocol
);
1853 /* Kernel bugs (on Ultrix at least) cause lossage (not just EINTR)
1854 when connect is interrupted. So let's not let it get interrupted.
1855 Note we do not turn off polling, because polling is only used
1856 when not interrupt_input, and thus not normally used on the systems
1857 which have this bug. On systems which use polling, there's no way
1858 to quit if polling is turned off. */
1859 if (interrupt_input
)
1865 /* This turns off all alarm-based interrupts; the
1866 bind_polling_period call above doesn't always turn all the
1867 short-interval ones off, especially if interrupt_input is
1870 It'd be nice to be able to control the connect timeout
1871 though. Would non-blocking connect calls be portable? */
1872 turn_on_atimers (0);
1873 ret
= connect (s
, lres
->ai_addr
, lres
->ai_addrlen
);
1874 turn_on_atimers (1);
1884 if (interrupt_input
)
1888 report_file_error ("connection failed",
1889 Fcons (host
, Fcons (name
, Qnil
)));
1891 #else /* ! HAVE_GETADDRINFO */
1902 host_info_ptr
= gethostbyname (XSTRING (host
)->data
);
1906 if (! (host_info_ptr
== 0 && h_errno
== TRY_AGAIN
))
1910 Fsleep_for (make_number (1), Qnil
);
1912 if (host_info_ptr
== 0)
1913 /* Attempt to interpret host as numeric inet address */
1915 numeric_addr
= inet_addr ((char *) XSTRING (host
)->data
);
1916 if (NUMERIC_ADDR_ERROR
)
1917 error ("Unknown host \"%s\"", XSTRING (host
)->data
);
1919 host_info_ptr
= &host_info
;
1920 host_info
.h_name
= 0;
1921 host_info
.h_aliases
= 0;
1922 host_info
.h_addrtype
= AF_INET
;
1924 /* Older machines have only one address slot called h_addr.
1925 Newer machines have h_addr_list, but #define h_addr to
1926 be its first element. */
1927 host_info
.h_addr_list
= &(addr_list
[0]);
1929 host_info
.h_addr
= (char*)(&numeric_addr
);
1931 /* numeric_addr isn't null-terminated; it has fixed length. */
1932 host_info
.h_length
= sizeof (numeric_addr
);
1935 bzero (&address
, sizeof address
);
1936 bcopy (host_info_ptr
->h_addr
, (char *) &address
.sin_addr
,
1937 host_info_ptr
->h_length
);
1938 address
.sin_family
= host_info_ptr
->h_addrtype
;
1939 address
.sin_port
= port
;
1941 s
= socket (host_info_ptr
->h_addrtype
, SOCK_STREAM
, 0);
1943 report_file_error ("error creating socket", Fcons (name
, Qnil
));
1945 count1
= specpdl_ptr
- specpdl
;
1946 record_unwind_protect (close_file_unwind
, make_number (s
));
1948 /* Kernel bugs (on Ultrix at least) cause lossage (not just EINTR)
1949 when connect is interrupted. So let's not let it get interrupted.
1950 Note we do not turn off polling, because polling is only used
1951 when not interrupt_input, and thus not normally used on the systems
1952 which have this bug. On systems which use polling, there's no way
1953 to quit if polling is turned off. */
1954 if (interrupt_input
)
1962 if (connect (s
, (struct sockaddr
*) &address
, sizeof address
) == -1
1963 && errno
!= EISCONN
)
1971 if (errno
== EADDRINUSE
&& retry
< 20)
1973 /* A delay here is needed on some FreeBSD systems,
1974 and it is harmless, since this retrying takes time anyway
1975 and should be infrequent. */
1976 Fsleep_for (make_number (1), Qnil
);
1981 /* Discard the unwind protect. */
1982 specpdl_ptr
= specpdl
+ count1
;
1986 if (interrupt_input
)
1990 report_file_error ("connection failed",
1991 Fcons (host
, Fcons (name
, Qnil
)));
1993 #endif /* ! HAVE_GETADDRINFO */
1997 /* Discard the unwind protect. */
1998 specpdl_ptr
= specpdl
+ count1
;
2000 #ifdef POLL_FOR_INPUT
2001 unbind_to (count
, Qnil
);
2004 if (interrupt_input
)
2008 s
= connect_server (0);
2010 report_file_error ("error creating socket", Fcons (name
, Qnil
));
2011 send_command (s
, C_PORT
, 0, "%s:%d", XSTRING (host
)->data
, ntohs (port
));
2012 send_command (s
, C_DUMB
, 1, 0);
2019 buffer
= Fget_buffer_create (buffer
);
2020 proc
= make_process (name
);
2022 chan_process
[inch
] = proc
;
2025 fcntl (inch
, F_SETFL
, O_NONBLOCK
);
2028 fcntl (inch
, F_SETFL
, O_NDELAY
);
2032 XPROCESS (proc
)->childp
= Fcons (host
, Fcons (service
, Qnil
));
2033 XPROCESS (proc
)->command_channel_p
= Qnil
;
2034 XPROCESS (proc
)->buffer
= buffer
;
2035 XPROCESS (proc
)->sentinel
= Qnil
;
2036 XPROCESS (proc
)->filter
= Qnil
;
2037 XPROCESS (proc
)->command
= Qnil
;
2038 XPROCESS (proc
)->pid
= Qnil
;
2039 XSETINT (XPROCESS (proc
)->infd
, inch
);
2040 XSETINT (XPROCESS (proc
)->outfd
, outch
);
2041 XPROCESS (proc
)->status
= Qrun
;
2042 FD_SET (inch
, &input_wait_mask
);
2043 FD_SET (inch
, &non_keyboard_wait_mask
);
2044 if (inch
> max_process_desc
)
2045 max_process_desc
= inch
;
2048 /* Setup coding systems for communicating with the network stream. */
2049 struct gcpro gcpro1
;
2050 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
2051 Lisp_Object coding_systems
= Qt
;
2052 Lisp_Object args
[5], val
;
2054 if (!NILP (Vcoding_system_for_read
))
2055 val
= Vcoding_system_for_read
;
2056 else if ((!NILP (buffer
) && NILP (XBUFFER (buffer
)->enable_multibyte_characters
))
2057 || (NILP (buffer
) && NILP (buffer_defaults
.enable_multibyte_characters
)))
2058 /* We dare not decode end-of-line format by setting VAL to
2059 Qraw_text, because the existing Emacs Lisp libraries
2060 assume that they receive bare code including a sequene of
2065 args
[0] = Qopen_network_stream
, args
[1] = name
,
2066 args
[2] = buffer
, args
[3] = host
, args
[4] = service
;
2068 coding_systems
= Ffind_operation_coding_system (5, args
);
2070 if (CONSP (coding_systems
))
2071 val
= XCAR (coding_systems
);
2072 else if (CONSP (Vdefault_process_coding_system
))
2073 val
= XCAR (Vdefault_process_coding_system
);
2077 XPROCESS (proc
)->decode_coding_system
= val
;
2079 if (!NILP (Vcoding_system_for_write
))
2080 val
= Vcoding_system_for_write
;
2081 else if (NILP (current_buffer
->enable_multibyte_characters
))
2085 if (EQ (coding_systems
, Qt
))
2087 args
[0] = Qopen_network_stream
, args
[1] = name
,
2088 args
[2] = buffer
, args
[3] = host
, args
[4] = service
;
2090 coding_systems
= Ffind_operation_coding_system (5, args
);
2093 if (CONSP (coding_systems
))
2094 val
= XCDR (coding_systems
);
2095 else if (CONSP (Vdefault_process_coding_system
))
2096 val
= XCDR (Vdefault_process_coding_system
);
2100 XPROCESS (proc
)->encode_coding_system
= val
;
2103 if (!proc_decode_coding_system
[inch
])
2104 proc_decode_coding_system
[inch
]
2105 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
2106 setup_coding_system (XPROCESS (proc
)->decode_coding_system
,
2107 proc_decode_coding_system
[inch
]);
2108 proc_decode_coding_system
[inch
]->src_multibyte
= 1;
2109 proc_decode_coding_system
[inch
]->dst_multibyte
= 0;
2110 if (!proc_encode_coding_system
[outch
])
2111 proc_encode_coding_system
[outch
]
2112 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
2113 setup_coding_system (XPROCESS (proc
)->encode_coding_system
,
2114 proc_encode_coding_system
[outch
]);
2115 proc_encode_coding_system
[inch
]->src_multibyte
= 0;
2116 proc_encode_coding_system
[inch
]->dst_multibyte
= 1;
2118 XPROCESS (proc
)->decoding_buf
= make_uninit_string (0);
2119 XPROCESS (proc
)->decoding_carryover
= make_number (0);
2120 XPROCESS (proc
)->encoding_buf
= make_uninit_string (0);
2121 XPROCESS (proc
)->encoding_carryover
= make_number (0);
2123 XPROCESS (proc
)->inherit_coding_system_flag
2124 = (NILP (buffer
) || !inherit_process_coding_system
2130 #endif /* HAVE_SOCKETS */
2133 deactivate_process (proc
)
2136 register int inchannel
, outchannel
;
2137 register struct Lisp_Process
*p
= XPROCESS (proc
);
2139 inchannel
= XINT (p
->infd
);
2140 outchannel
= XINT (p
->outfd
);
2144 /* Beware SIGCHLD hereabouts. */
2145 flush_pending_output (inchannel
);
2148 VMS_PROC_STUFF
*get_vms_process_pointer (), *vs
;
2149 sys$
dassgn (outchannel
);
2150 vs
= get_vms_process_pointer (p
->pid
);
2152 give_back_vms_process_stuff (vs
);
2155 emacs_close (inchannel
);
2156 if (outchannel
>= 0 && outchannel
!= inchannel
)
2157 emacs_close (outchannel
);
2160 XSETINT (p
->infd
, -1);
2161 XSETINT (p
->outfd
, -1);
2162 chan_process
[inchannel
] = Qnil
;
2163 FD_CLR (inchannel
, &input_wait_mask
);
2164 FD_CLR (inchannel
, &non_keyboard_wait_mask
);
2165 if (inchannel
== max_process_desc
)
2168 /* We just closed the highest-numbered process input descriptor,
2169 so recompute the highest-numbered one now. */
2170 max_process_desc
= 0;
2171 for (i
= 0; i
< MAXDESC
; i
++)
2172 if (!NILP (chan_process
[i
]))
2173 max_process_desc
= i
;
2178 /* Close all descriptors currently in use for communication
2179 with subprocess. This is used in a newly-forked subprocess
2180 to get rid of irrelevant descriptors. */
2183 close_process_descs ()
2187 for (i
= 0; i
< MAXDESC
; i
++)
2189 Lisp_Object process
;
2190 process
= chan_process
[i
];
2191 if (!NILP (process
))
2193 int in
= XINT (XPROCESS (process
)->infd
);
2194 int out
= XINT (XPROCESS (process
)->outfd
);
2197 if (out
>= 0 && in
!= out
)
2204 DEFUN ("accept-process-output", Faccept_process_output
, Saccept_process_output
,
2206 "Allow any pending output from subprocesses to be read by Emacs.\n\
2207 It is read into the process' buffers or given to their filter functions.\n\
2208 Non-nil arg PROCESS means do not return until some output has been received\n\
2210 Non-nil second arg TIMEOUT and third arg TIMEOUT-MSECS are number of\n\
2211 seconds and microseconds to wait; return after that much time whether\n\
2212 or not there is input.\n\
2213 Return non-nil iff we received any output before the timeout expired.")
2214 (process
, timeout
, timeout_msecs
)
2215 register Lisp_Object process
, timeout
, timeout_msecs
;
2220 if (! NILP (process
))
2221 CHECK_PROCESS (process
, 0);
2223 if (! NILP (timeout_msecs
))
2225 CHECK_NUMBER (timeout_msecs
, 2);
2226 useconds
= XINT (timeout_msecs
);
2227 if (!INTEGERP (timeout
))
2228 XSETINT (timeout
, 0);
2231 int carry
= useconds
/ 1000000;
2233 XSETINT (timeout
, XINT (timeout
) + carry
);
2234 useconds
-= carry
* 1000000;
2236 /* I think this clause is necessary because C doesn't
2237 guarantee a particular rounding direction for negative
2241 XSETINT (timeout
, XINT (timeout
) - 1);
2242 useconds
+= 1000000;
2249 if (! NILP (timeout
))
2251 CHECK_NUMBER (timeout
, 1);
2252 seconds
= XINT (timeout
);
2253 if (seconds
< 0 || (seconds
== 0 && useconds
== 0))
2265 XSETFASTINT (process
, 0);
2268 (wait_reading_process_input (seconds
, useconds
, process
, 0)
2272 /* This variable is different from waiting_for_input in keyboard.c.
2273 It is used to communicate to a lisp process-filter/sentinel (via the
2274 function Fwaiting_for_user_input_p below) whether emacs was waiting
2275 for user-input when that process-filter was called.
2276 waiting_for_input cannot be used as that is by definition 0 when
2277 lisp code is being evalled.
2278 This is also used in record_asynch_buffer_change.
2279 For that purpose, this must be 0
2280 when not inside wait_reading_process_input. */
2281 static int waiting_for_user_input_p
;
2283 /* This is here so breakpoints can be put on it. */
2285 wait_reading_process_input_1 ()
2289 /* Read and dispose of subprocess output while waiting for timeout to
2290 elapse and/or keyboard input to be available.
2293 timeout in seconds, or
2294 zero for no limit, or
2295 -1 means gobble data immediately available but don't wait for any.
2298 an additional duration to wait, measured in microseconds.
2299 If this is nonzero and time_limit is 0, then the timeout
2300 consists of MICROSECS only.
2302 READ_KBD is a lisp value:
2303 0 to ignore keyboard input, or
2304 1 to return when input is available, or
2305 -1 meaning caller will actually read the input, so don't throw to
2306 the quit handler, or
2307 a cons cell, meaning wait until its car is non-nil
2308 (and gobble terminal input into the buffer if any arrives), or
2309 a process object, meaning wait until something arrives from that
2310 process. The return value is true iff we read some input from
2313 DO_DISPLAY != 0 means redisplay should be done to show subprocess
2314 output that arrives.
2316 If READ_KBD is a pointer to a struct Lisp_Process, then the
2317 function returns true iff we received input from that process
2318 before the timeout elapsed.
2319 Otherwise, return true iff we received input from any process. */
2322 wait_reading_process_input (time_limit
, microsecs
, read_kbd
, do_display
)
2323 int time_limit
, microsecs
;
2324 Lisp_Object read_kbd
;
2327 register int channel
, nfds
;
2328 static SELECT_TYPE Available
;
2331 EMACS_TIME timeout
, end_time
;
2333 int wait_channel
= -1;
2334 struct Lisp_Process
*wait_proc
= 0;
2335 int got_some_input
= 0;
2336 Lisp_Object
*wait_for_cell
= 0;
2338 FD_ZERO (&Available
);
2340 /* If read_kbd is a process to watch, set wait_proc and wait_channel
2342 if (PROCESSP (read_kbd
))
2344 wait_proc
= XPROCESS (read_kbd
);
2345 wait_channel
= XINT (wait_proc
->infd
);
2346 XSETFASTINT (read_kbd
, 0);
2349 /* If waiting for non-nil in a cell, record where. */
2350 if (CONSP (read_kbd
))
2352 wait_for_cell
= &XCAR (read_kbd
);
2353 XSETFASTINT (read_kbd
, 0);
2356 waiting_for_user_input_p
= XINT (read_kbd
);
2358 /* Since we may need to wait several times,
2359 compute the absolute time to return at. */
2360 if (time_limit
|| microsecs
)
2362 EMACS_GET_TIME (end_time
);
2363 EMACS_SET_SECS_USECS (timeout
, time_limit
, microsecs
);
2364 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
2367 /* AlainF 5-Jul-1996
2368 HP-UX 10.10 seem to have problems with signals coming in
2369 Causes "poll: interrupted system call" messages when Emacs is run
2371 Turn off periodic alarms (in case they are in use) */
2372 turn_on_atimers (0);
2377 int timeout_reduced_for_timers
= 0;
2379 /* If calling from keyboard input, do not quit
2380 since we want to return C-g as an input character.
2381 Otherwise, do pending quit if requested. */
2382 if (XINT (read_kbd
) >= 0)
2385 /* Exit now if the cell we're waiting for became non-nil. */
2386 if (wait_for_cell
&& ! NILP (*wait_for_cell
))
2389 /* Compute time from now till when time limit is up */
2390 /* Exit if already run out */
2391 if (time_limit
== -1)
2393 /* -1 specified for timeout means
2394 gobble output available now
2395 but don't wait at all. */
2397 EMACS_SET_SECS_USECS (timeout
, 0, 0);
2399 else if (time_limit
|| microsecs
)
2401 EMACS_GET_TIME (timeout
);
2402 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
2403 if (EMACS_TIME_NEG_P (timeout
))
2408 EMACS_SET_SECS_USECS (timeout
, 100000, 0);
2411 /* Normally we run timers here.
2412 But not if wait_for_cell; in those cases,
2413 the wait is supposed to be short,
2414 and those callers cannot handle running arbitrary Lisp code here. */
2415 if (! wait_for_cell
)
2417 EMACS_TIME timer_delay
;
2421 old_timers_run
= timers_run
;
2422 timer_delay
= timer_check (1);
2423 if (timers_run
!= old_timers_run
&& do_display
)
2425 redisplay_preserve_echo_area ();
2426 /* We must retry, since a timer may have requeued itself
2427 and that could alter the time_delay. */
2431 /* If there is unread keyboard input, also return. */
2432 if (XINT (read_kbd
) != 0
2433 && requeued_events_pending_p ())
2436 if (! EMACS_TIME_NEG_P (timer_delay
) && time_limit
!= -1)
2438 EMACS_TIME difference
;
2439 EMACS_SUB_TIME (difference
, timer_delay
, timeout
);
2440 if (EMACS_TIME_NEG_P (difference
))
2442 timeout
= timer_delay
;
2443 timeout_reduced_for_timers
= 1;
2446 /* If time_limit is -1, we are not going to wait at all. */
2447 else if (time_limit
!= -1)
2449 /* This is so a breakpoint can be put here. */
2450 wait_reading_process_input_1 ();
2454 /* Cause C-g and alarm signals to take immediate action,
2455 and cause input available signals to zero out timeout.
2457 It is important that we do this before checking for process
2458 activity. If we get a SIGCHLD after the explicit checks for
2459 process activity, timeout is the only way we will know. */
2460 if (XINT (read_kbd
) < 0)
2461 set_waiting_for_input (&timeout
);
2463 /* If status of something has changed, and no input is
2464 available, notify the user of the change right away. After
2465 this explicit check, we'll let the SIGCHLD handler zap
2466 timeout to get our attention. */
2467 if (update_tick
!= process_tick
&& do_display
)
2469 Atemp
= input_wait_mask
;
2470 EMACS_SET_SECS_USECS (timeout
, 0, 0);
2471 if ((select (max (max_process_desc
, max_keyboard_desc
) + 1,
2472 &Atemp
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0,
2476 /* It's okay for us to do this and then continue with
2477 the loop, since timeout has already been zeroed out. */
2478 clear_waiting_for_input ();
2483 /* Don't wait for output from a non-running process. */
2484 if (wait_proc
!= 0 && !NILP (wait_proc
->raw_status_low
))
2485 update_status (wait_proc
);
2487 && ! EQ (wait_proc
->status
, Qrun
))
2489 int nread
, total_nread
= 0;
2491 clear_waiting_for_input ();
2492 XSETPROCESS (proc
, wait_proc
);
2494 /* Read data from the process, until we exhaust it. */
2495 while (XINT (wait_proc
->infd
) >= 0)
2497 nread
= read_process_output (proc
, XINT (wait_proc
->infd
));
2503 total_nread
+= nread
;
2505 else if (nread
== -1 && EIO
== errno
)
2509 else if (nread
== -1 && EAGAIN
== errno
)
2513 else if (nread
== -1 && EWOULDBLOCK
== errno
)
2517 if (total_nread
> 0 && do_display
)
2518 redisplay_preserve_echo_area ();
2523 /* Wait till there is something to do */
2526 Available
= non_process_wait_mask
;
2527 else if (! XINT (read_kbd
))
2528 Available
= non_keyboard_wait_mask
;
2530 Available
= input_wait_mask
;
2532 /* If frame size has changed or the window is newly mapped,
2533 redisplay now, before we start to wait. There is a race
2534 condition here; if a SIGIO arrives between now and the select
2535 and indicates that a frame is trashed, the select may block
2536 displaying a trashed screen. */
2537 if (frame_garbaged
&& do_display
)
2539 clear_waiting_for_input ();
2540 redisplay_preserve_echo_area ();
2541 if (XINT (read_kbd
) < 0)
2542 set_waiting_for_input (&timeout
);
2545 if (XINT (read_kbd
) && detect_input_pending ())
2548 FD_ZERO (&Available
);
2551 nfds
= select (max (max_process_desc
, max_keyboard_desc
) + 1,
2552 &Available
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0,
2557 /* Make C-g and alarm signals set flags again */
2558 clear_waiting_for_input ();
2560 /* If we woke up due to SIGWINCH, actually change size now. */
2561 do_pending_window_change (0);
2563 if (time_limit
&& nfds
== 0 && ! timeout_reduced_for_timers
)
2564 /* We wanted the full specified time, so return now. */
2568 if (xerrno
== EINTR
)
2569 FD_ZERO (&Available
);
2571 /* Ultrix select seems to return ENOMEM when it is
2572 interrupted. Treat it just like EINTR. Bleah. Note
2573 that we want to test for the "ultrix" CPP symbol, not
2574 "__ultrix__"; the latter is only defined under GCC, but
2575 not by DEC's bundled CC. -JimB */
2576 else if (xerrno
== ENOMEM
)
2577 FD_ZERO (&Available
);
2580 /* This happens for no known reason on ALLIANT.
2581 I am guessing that this is the right response. -- RMS. */
2582 else if (xerrno
== EFAULT
)
2583 FD_ZERO (&Available
);
2585 else if (xerrno
== EBADF
)
2588 /* AIX doesn't handle PTY closure the same way BSD does. On AIX,
2589 the child's closure of the pts gives the parent a SIGHUP, and
2590 the ptc file descriptor is automatically closed,
2591 yielding EBADF here or at select() call above.
2592 So, SIGHUP is ignored (see def of PTY_TTY_NAME_SPRINTF
2593 in m/ibmrt-aix.h), and here we just ignore the select error.
2594 Cleanup occurs c/o status_notify after SIGCLD. */
2595 FD_ZERO (&Available
); /* Cannot depend on values returned */
2601 error ("select error: %s", emacs_strerror (xerrno
));
2603 #if defined(sun) && !defined(USG5_4)
2604 else if (nfds
> 0 && keyboard_bit_set (&Available
)
2606 /* System sometimes fails to deliver SIGIO.
2608 David J. Mackenzie says that Emacs doesn't compile under
2609 Solaris if this code is enabled, thus the USG5_4 in the CPP
2610 conditional. "I haven't noticed any ill effects so far.
2611 If you find a Solaris expert somewhere, they might know
2613 kill (getpid (), SIGIO
);
2616 #if 0 /* When polling is used, interrupt_input is 0,
2617 so get_input_pending should read the input.
2618 So this should not be needed. */
2619 /* If we are using polling for input,
2620 and we see input available, make it get read now.
2621 Otherwise it might not actually get read for a second.
2622 And on hpux, since we turn off polling in wait_reading_process_input,
2623 it might never get read at all if we don't spend much time
2624 outside of wait_reading_process_input. */
2625 if (XINT (read_kbd
) && interrupt_input
2626 && keyboard_bit_set (&Available
)
2627 && input_polling_used ())
2628 kill (getpid (), SIGALRM
);
2631 /* Check for keyboard input */
2632 /* If there is any, return immediately
2633 to give it higher priority than subprocesses */
2635 if (XINT (read_kbd
) != 0
2636 && detect_input_pending_run_timers (do_display
))
2638 swallow_events (do_display
);
2639 if (detect_input_pending_run_timers (do_display
))
2643 /* If there is unread keyboard input, also return. */
2644 if (XINT (read_kbd
) != 0
2645 && requeued_events_pending_p ())
2648 /* If we are not checking for keyboard input now,
2649 do process events (but don't run any timers).
2650 This is so that X events will be processed.
2651 Otherwise they may have to wait until polling takes place.
2652 That would causes delays in pasting selections, for example.
2654 (We used to do this only if wait_for_cell.) */
2655 if (XINT (read_kbd
) == 0 && detect_input_pending ())
2657 swallow_events (do_display
);
2658 #if 0 /* Exiting when read_kbd doesn't request that seems wrong, though. */
2659 if (detect_input_pending ())
2664 /* Exit now if the cell we're waiting for became non-nil. */
2665 if (wait_for_cell
&& ! NILP (*wait_for_cell
))
2669 /* If we think we have keyboard input waiting, but didn't get SIGIO,
2670 go read it. This can happen with X on BSD after logging out.
2671 In that case, there really is no input and no SIGIO,
2672 but select says there is input. */
2674 if (XINT (read_kbd
) && interrupt_input
2675 && keyboard_bit_set (&Available
))
2676 kill (getpid (), SIGIO
);
2680 got_some_input
|= nfds
> 0;
2682 /* If checking input just got us a size-change event from X,
2683 obey it now if we should. */
2684 if (XINT (read_kbd
) || wait_for_cell
)
2685 do_pending_window_change (0);
2687 /* Check for data from a process. */
2688 /* Really FIRST_PROC_DESC should be 0 on Unix,
2689 but this is safer in the short run. */
2690 for (channel
= 0; channel
<= max_process_desc
; channel
++)
2692 if (FD_ISSET (channel
, &Available
)
2693 && FD_ISSET (channel
, &non_keyboard_wait_mask
))
2697 /* If waiting for this channel, arrange to return as
2698 soon as no more input to be processed. No more
2700 if (wait_channel
== channel
)
2706 proc
= chan_process
[channel
];
2710 /* Read data from the process, starting with our
2711 buffered-ahead character if we have one. */
2713 nread
= read_process_output (proc
, channel
);
2716 /* Since read_process_output can run a filter,
2717 which can call accept-process-output,
2718 don't try to read from any other processes
2719 before doing the select again. */
2720 FD_ZERO (&Available
);
2723 redisplay_preserve_echo_area ();
2726 else if (nread
== -1 && errno
== EWOULDBLOCK
)
2729 /* ISC 4.1 defines both EWOULDBLOCK and O_NONBLOCK,
2730 and Emacs uses O_NONBLOCK, so what we get is EAGAIN. */
2732 else if (nread
== -1 && errno
== EAGAIN
)
2736 else if (nread
== -1 && errno
== EAGAIN
)
2738 /* Note that we cannot distinguish between no input
2739 available now and a closed pipe.
2740 With luck, a closed pipe will be accompanied by
2741 subprocess termination and SIGCHLD. */
2742 else if (nread
== 0 && !NETCONN_P (proc
))
2744 #endif /* O_NDELAY */
2745 #endif /* O_NONBLOCK */
2747 /* On some OSs with ptys, when the process on one end of
2748 a pty exits, the other end gets an error reading with
2749 errno = EIO instead of getting an EOF (0 bytes read).
2750 Therefore, if we get an error reading and errno =
2751 EIO, just continue, because the child process has
2752 exited and should clean itself up soon (e.g. when we
2755 However, it has been known to happen that the SIGCHLD
2756 got lost. So raise the signl again just in case.
2758 else if (nread
== -1 && errno
== EIO
)
2759 kill (getpid (), SIGCHLD
);
2760 #endif /* HAVE_PTYS */
2761 /* If we can detect process termination, don't consider the process
2762 gone just because its pipe is closed. */
2764 else if (nread
== 0 && !NETCONN_P (proc
))
2769 /* Preserve status of processes already terminated. */
2770 XSETINT (XPROCESS (proc
)->tick
, ++process_tick
);
2771 deactivate_process (proc
);
2772 if (!NILP (XPROCESS (proc
)->raw_status_low
))
2773 update_status (XPROCESS (proc
));
2774 if (EQ (XPROCESS (proc
)->status
, Qrun
))
2775 XPROCESS (proc
)->status
2776 = Fcons (Qexit
, Fcons (make_number (256), Qnil
));
2779 } /* end for each file descriptor */
2780 } /* end while exit conditions not met */
2782 waiting_for_user_input_p
= 0;
2784 /* If calling from keyboard input, do not quit
2785 since we want to return C-g as an input character.
2786 Otherwise, do pending quit if requested. */
2787 if (XINT (read_kbd
) >= 0)
2789 /* Prevent input_pending from remaining set if we quit. */
2790 clear_input_pending ();
2794 /* AlainF 5-Jul-1996
2795 HP-UX 10.10 seems to have problems with signals coming in
2796 Causes "poll: interrupted system call" messages when Emacs is run
2798 Turn periodic alarms back on */
2802 return got_some_input
;
2805 /* Given a list (FUNCTION ARGS...), apply FUNCTION to the ARGS. */
2808 read_process_output_call (fun_and_args
)
2809 Lisp_Object fun_and_args
;
2811 return apply1 (XCAR (fun_and_args
), XCDR (fun_and_args
));
2815 read_process_output_error_handler (error
)
2818 cmd_error_internal (error
, "error in process filter: ");
2820 update_echo_area ();
2821 Fsleep_for (make_number (2), Qnil
);
2825 /* Read pending output from the process channel,
2826 starting with our buffered-ahead character if we have one.
2827 Yield number of decoded characters read.
2829 This function reads at most 1024 characters.
2830 If you want to read all available subprocess output,
2831 you must call it repeatedly until it returns zero.
2833 The characters read are decoded according to PROC's coding-system
2837 read_process_output (proc
, channel
)
2839 register int channel
;
2841 register int nchars
, nbytes
;
2843 register Lisp_Object outstream
;
2844 register struct buffer
*old
= current_buffer
;
2845 register struct Lisp_Process
*p
= XPROCESS (proc
);
2846 register int opoint
;
2847 struct coding_system
*coding
= proc_decode_coding_system
[channel
];
2848 int carryover
= XINT (p
->decoding_carryover
);
2851 VMS_PROC_STUFF
*vs
, *get_vms_process_pointer();
2853 vs
= get_vms_process_pointer (p
->pid
);
2857 return (0); /* Really weird if it does this */
2858 if (!(vs
->iosb
[0] & 1))
2859 return -1; /* I/O error */
2862 error ("Could not get VMS process pointer");
2863 chars
= vs
->inputBuffer
;
2864 nbytes
= clean_vms_buffer (chars
, vs
->iosb
[1]);
2867 start_vms_process_read (vs
); /* Crank up the next read on the process */
2868 return 1; /* Nothing worth printing, say we got 1 */
2872 /* The data carried over in the previous decoding (which are at
2873 the tail of decoding buffer) should be prepended to the new
2874 data read to decode all together. */
2875 chars
= (char *) alloca (nbytes
+ carryover
);
2876 bcopy (XSTRING (p
->decoding_buf
)->data
, buf
, carryover
);
2877 bcopy (vs
->inputBuffer
, chars
+ carryover
, nbytes
);
2880 chars
= (char *) alloca (carryover
+ 1024);
2882 /* See the comment above. */
2883 bcopy (XSTRING (p
->decoding_buf
)->data
, chars
, carryover
);
2885 if (proc_buffered_char
[channel
] < 0)
2886 nbytes
= emacs_read (channel
, chars
+ carryover
, 1024 - carryover
);
2889 chars
[carryover
] = proc_buffered_char
[channel
];
2890 proc_buffered_char
[channel
] = -1;
2891 nbytes
= emacs_read (channel
, chars
+ carryover
+ 1, 1023 - carryover
);
2895 nbytes
= nbytes
+ 1;
2897 #endif /* not VMS */
2899 XSETINT (p
->decoding_carryover
, 0);
2901 /* At this point, NBYTES holds number of bytes just received
2902 (including the one in proc_buffered_char[channel]). */
2905 if (nbytes
< 0 || coding
->mode
& CODING_MODE_LAST_BLOCK
)
2907 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
2910 /* Now set NBYTES how many bytes we must decode. */
2911 nbytes
+= carryover
;
2913 /* Read and dispose of the process output. */
2914 outstream
= p
->filter
;
2915 if (!NILP (outstream
))
2917 /* We inhibit quit here instead of just catching it so that
2918 hitting ^G when a filter happens to be running won't screw
2920 int count
= specpdl_ptr
- specpdl
;
2921 Lisp_Object odeactivate
;
2922 Lisp_Object obuffer
, okeymap
;
2924 int outer_running_asynch_code
= running_asynch_code
;
2925 int waiting
= waiting_for_user_input_p
;
2927 /* No need to gcpro these, because all we do with them later
2928 is test them for EQness, and none of them should be a string. */
2929 odeactivate
= Vdeactivate_mark
;
2930 XSETBUFFER (obuffer
, current_buffer
);
2931 okeymap
= current_buffer
->keymap
;
2933 specbind (Qinhibit_quit
, Qt
);
2934 specbind (Qlast_nonmenu_event
, Qt
);
2936 /* In case we get recursively called,
2937 and we already saved the match data nonrecursively,
2938 save the same match data in safely recursive fashion. */
2939 if (outer_running_asynch_code
)
2942 /* Don't clobber the CURRENT match data, either! */
2943 tem
= Fmatch_data (Qnil
, Qnil
);
2944 restore_match_data ();
2945 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
2946 Fset_match_data (tem
);
2949 /* For speed, if a search happens within this code,
2950 save the match data in a special nonrecursive fashion. */
2951 running_asynch_code
= 1;
2953 text
= decode_coding_string (make_unibyte_string (chars
, nbytes
),
2955 Vlast_coding_system_used
= coding
->symbol
;
2956 /* A new coding system might be found. */
2957 if (!EQ (p
->decode_coding_system
, coding
->symbol
))
2959 p
->decode_coding_system
= coding
->symbol
;
2961 /* Don't call setup_coding_system for
2962 proc_decode_coding_system[channel] here. It is done in
2963 detect_coding called via decode_coding above. */
2965 /* If a coding system for encoding is not yet decided, we set
2966 it as the same as coding-system for decoding.
2968 But, before doing that we must check if
2969 proc_encode_coding_system[p->outfd] surely points to a
2970 valid memory because p->outfd will be changed once EOF is
2971 sent to the process. */
2972 if (NILP (p
->encode_coding_system
)
2973 && proc_encode_coding_system
[XINT (p
->outfd
)])
2975 p
->encode_coding_system
= coding
->symbol
;
2976 setup_coding_system (coding
->symbol
,
2977 proc_encode_coding_system
[XINT (p
->outfd
)]);
2981 carryover
= nbytes
- coding
->consumed
;
2982 bcopy (chars
+ coding
->consumed
, XSTRING (p
->decoding_buf
)->data
,
2984 XSETINT (p
->decoding_carryover
, carryover
);
2985 nbytes
= STRING_BYTES (XSTRING (text
));
2986 nchars
= XSTRING (text
)->size
;
2987 internal_condition_case_1 (read_process_output_call
,
2989 Fcons (proc
, Fcons (text
, Qnil
))),
2990 !NILP (Vdebug_on_error
) ? Qnil
: Qerror
,
2991 read_process_output_error_handler
);
2993 /* If we saved the match data nonrecursively, restore it now. */
2994 restore_match_data ();
2995 running_asynch_code
= outer_running_asynch_code
;
2997 /* Handling the process output should not deactivate the mark. */
2998 Vdeactivate_mark
= odeactivate
;
3000 /* Restore waiting_for_user_input_p as it was
3001 when we were called, in case the filter clobbered it. */
3002 waiting_for_user_input_p
= waiting
;
3004 #if 0 /* Call record_asynch_buffer_change unconditionally,
3005 because we might have changed minor modes or other things
3006 that affect key bindings. */
3007 if (! EQ (Fcurrent_buffer (), obuffer
)
3008 || ! EQ (current_buffer
->keymap
, okeymap
))
3010 /* But do it only if the caller is actually going to read events.
3011 Otherwise there's no need to make him wake up, and it could
3012 cause trouble (for example it would make Fsit_for return). */
3013 if (waiting_for_user_input_p
== -1)
3014 record_asynch_buffer_change ();
3017 start_vms_process_read (vs
);
3019 unbind_to (count
, Qnil
);
3023 /* If no filter, write into buffer if it isn't dead. */
3024 if (!NILP (p
->buffer
) && !NILP (XBUFFER (p
->buffer
)->name
))
3026 Lisp_Object old_read_only
;
3027 int old_begv
, old_zv
;
3028 int old_begv_byte
, old_zv_byte
;
3029 Lisp_Object odeactivate
;
3030 int before
, before_byte
;
3034 odeactivate
= Vdeactivate_mark
;
3036 Fset_buffer (p
->buffer
);
3038 opoint_byte
= PT_BYTE
;
3039 old_read_only
= current_buffer
->read_only
;
3042 old_begv_byte
= BEGV_BYTE
;
3043 old_zv_byte
= ZV_BYTE
;
3045 current_buffer
->read_only
= Qnil
;
3047 /* Insert new output into buffer
3048 at the current end-of-output marker,
3049 thus preserving logical ordering of input and output. */
3050 if (XMARKER (p
->mark
)->buffer
)
3051 SET_PT_BOTH (clip_to_bounds (BEGV
, marker_position (p
->mark
), ZV
),
3052 clip_to_bounds (BEGV_BYTE
, marker_byte_position (p
->mark
),
3055 SET_PT_BOTH (ZV
, ZV_BYTE
);
3057 before_byte
= PT_BYTE
;
3059 /* If the output marker is outside of the visible region, save
3060 the restriction and widen. */
3061 if (! (BEGV
<= PT
&& PT
<= ZV
))
3064 /* Insert before markers in case we are inserting where
3065 the buffer's mark is, and the user's next command is Meta-y. */
3066 text
= decode_coding_string (make_unibyte_string (chars
, nbytes
),
3068 Vlast_coding_system_used
= coding
->symbol
;
3069 /* A new coding system might be found. See the comment in the
3070 similar code in the previous `if' block. */
3071 if (!EQ (p
->decode_coding_system
, coding
->symbol
))
3073 p
->decode_coding_system
= coding
->symbol
;
3074 if (NILP (p
->encode_coding_system
)
3075 && proc_encode_coding_system
[XINT (p
->outfd
)])
3077 p
->encode_coding_system
= coding
->symbol
;
3078 setup_coding_system (coding
->symbol
,
3079 proc_encode_coding_system
[XINT (p
->outfd
)]);
3082 carryover
= nbytes
- coding
->consumed
;
3083 bcopy (chars
+ coding
->consumed
, XSTRING (p
->decoding_buf
)->data
,
3085 XSETINT (p
->decoding_carryover
, carryover
);
3086 nbytes
= STRING_BYTES (XSTRING (text
));
3087 nchars
= XSTRING (text
)->size
;
3088 insert_from_string_before_markers (text
, 0, 0, nchars
, nbytes
, 0);
3089 signal_after_change (before
, 0, PT
- before
);
3090 update_compositions (before
, PT
, CHECK_BORDER
);
3092 set_marker_both (p
->mark
, p
->buffer
, PT
, PT_BYTE
);
3094 update_mode_lines
++;
3096 /* Make sure opoint and the old restrictions
3097 float ahead of any new text just as point would. */
3098 if (opoint
>= before
)
3100 opoint
+= PT
- before
;
3101 opoint_byte
+= PT_BYTE
- before_byte
;
3103 if (old_begv
> before
)
3105 old_begv
+= PT
- before
;
3106 old_begv_byte
+= PT_BYTE
- before_byte
;
3108 if (old_zv
>= before
)
3110 old_zv
+= PT
- before
;
3111 old_zv_byte
+= PT_BYTE
- before_byte
;
3114 /* If the restriction isn't what it should be, set it. */
3115 if (old_begv
!= BEGV
|| old_zv
!= ZV
)
3116 Fnarrow_to_region (make_number (old_begv
), make_number (old_zv
));
3118 /* Handling the process output should not deactivate the mark. */
3119 Vdeactivate_mark
= odeactivate
;
3121 current_buffer
->read_only
= old_read_only
;
3122 SET_PT_BOTH (opoint
, opoint_byte
);
3123 set_buffer_internal (old
);
3126 start_vms_process_read (vs
);
3131 DEFUN ("waiting-for-user-input-p", Fwaiting_for_user_input_p
, Swaiting_for_user_input_p
,
3133 "Returns non-nil if emacs is waiting for input from the user.\n\
3134 This is intended for use by asynchronous process output filters and sentinels.")
3137 return (waiting_for_user_input_p
? Qt
: Qnil
);
3140 /* Sending data to subprocess */
3142 jmp_buf send_process_frame
;
3145 send_process_trap ()
3151 longjmp (send_process_frame
, 1);
3154 /* Send some data to process PROC.
3155 BUF is the beginning of the data; LEN is the number of characters.
3156 OBJECT is the Lisp object that the data comes from.
3158 The data is encoded by PROC's coding-system for encoding before it
3159 is sent. But if the data ends at the middle of multi-byte
3160 representation, that incomplete sequence of bytes are sent without
3161 being encoded. Should we store them in a buffer to prepend them to
3162 the data send later?
3164 This function can evaluate Lisp code and can garbage collect. */
3167 send_process (proc
, buf
, len
, object
)
3168 volatile Lisp_Object proc
;
3173 /* Use volatile to protect variables from being clobbered by longjmp. */
3175 struct coding_system
*coding
;
3176 struct gcpro gcpro1
;
3181 struct Lisp_Process
*p
= XPROCESS (proc
);
3182 VMS_PROC_STUFF
*vs
, *get_vms_process_pointer();
3185 if (! NILP (XPROCESS (proc
)->raw_status_low
))
3186 update_status (XPROCESS (proc
));
3187 if (! EQ (XPROCESS (proc
)->status
, Qrun
))
3188 error ("Process %s not running",
3189 XSTRING (XPROCESS (proc
)->name
)->data
);
3190 if (XINT (XPROCESS (proc
)->outfd
) < 0)
3191 error ("Output file descriptor of %s is closed",
3192 XSTRING (XPROCESS (proc
)->name
)->data
);
3194 coding
= proc_encode_coding_system
[XINT (XPROCESS (proc
)->outfd
)];
3195 Vlast_coding_system_used
= coding
->symbol
;
3197 if ((STRINGP (object
) && STRING_MULTIBYTE (object
))
3198 || (BUFFERP (object
)
3199 && !NILP (XBUFFER (object
)->enable_multibyte_characters
)))
3200 coding
->src_multibyte
= 1;
3201 coding
->dst_multibyte
= 0;
3203 if (CODING_REQUIRE_ENCODING (coding
))
3205 int require
= encoding_buffer_size (coding
, len
);
3206 int from_byte
= -1, from
, to
;
3207 unsigned char *temp_buf
= NULL
;
3209 if (BUFFERP (object
))
3211 from_byte
= BUF_PTR_BYTE_POS (XBUFFER (object
), buf
);
3212 from
= buf_bytepos_to_charpos (XBUFFER (object
), from_byte
);
3213 to
= buf_bytepos_to_charpos (XBUFFER (object
), from_byte
+ len
);
3215 else if (STRINGP (object
))
3217 from_byte
= buf
- XSTRING (object
)->data
;
3218 from
= string_byte_to_char (object
, from_byte
);
3219 to
= string_byte_to_char (object
, from_byte
+ len
);
3222 if (from_byte
>= 0 && coding
->composing
!= COMPOSITION_DISABLED
)
3223 coding_save_composition (coding
, from
, to
, object
);
3225 if (STRING_BYTES (XSTRING (XPROCESS (proc
)->encoding_buf
)) < require
)
3226 XPROCESS (proc
)->encoding_buf
= make_uninit_string (require
);
3229 buf
= (BUFFERP (object
)
3230 ? BUF_BYTE_ADDRESS (XBUFFER (object
), from_byte
)
3231 : XSTRING (object
)->data
+ from_byte
);
3233 object
= XPROCESS (proc
)->encoding_buf
;
3234 encode_coding (coding
, buf
, XSTRING (object
)->data
,
3235 len
, STRING_BYTES (XSTRING (object
)));
3236 len
= coding
->produced
;
3237 buf
= XSTRING (object
)->data
;
3243 vs
= get_vms_process_pointer (p
->pid
);
3245 error ("Could not find this process: %x", p
->pid
);
3246 else if (write_to_vms_process (vs
, buf
, len
))
3250 if (pty_max_bytes
== 0)
3252 #if defined (HAVE_FPATHCONF) && defined (_PC_MAX_CANON)
3253 pty_max_bytes
= fpathconf (XFASTINT (XPROCESS (proc
)->outfd
),
3255 if (pty_max_bytes
< 0)
3256 pty_max_bytes
= 250;
3258 pty_max_bytes
= 250;
3260 /* Deduct one, to leave space for the eof. */
3264 if (!setjmp (send_process_frame
))
3268 SIGTYPE (*old_sigpipe
)();
3270 /* Decide how much data we can send in one batch.
3271 Long lines need to be split into multiple batches. */
3272 if (!NILP (XPROCESS (proc
)->pty_flag
))
3274 /* Starting this at zero is always correct when not the first iteration
3275 because the previous iteration ended by sending C-d.
3276 It may not be correct for the first iteration
3277 if a partial line was sent in a separate send_process call.
3278 If that proves worth handling, we need to save linepos
3279 in the process object. */
3281 unsigned char *ptr
= buf
;
3282 unsigned char *end
= buf
+ len
;
3284 /* Scan through this text for a line that is too long. */
3285 while (ptr
!= end
&& linepos
< pty_max_bytes
)
3293 /* If we found one, break the line there
3294 and put in a C-d to force the buffer through. */
3298 /* Send this batch, using one or more write calls. */
3301 old_sigpipe
= (SIGTYPE (*) ()) signal (SIGPIPE
, send_process_trap
);
3302 rv
= emacs_write (XINT (XPROCESS (proc
)->outfd
), buf
, this);
3303 signal (SIGPIPE
, old_sigpipe
);
3309 || errno
== EWOULDBLOCK
3315 /* Buffer is full. Wait, accepting input;
3316 that may allow the program
3317 to finish doing output and read more. */
3322 #ifdef BROKEN_PTY_READ_AFTER_EAGAIN
3323 /* A gross hack to work around a bug in FreeBSD.
3324 In the following sequence, read(2) returns
3328 write(2) 954 bytes, get EAGAIN
3329 read(2) 1024 bytes in process_read_output
3330 read(2) 11 bytes in process_read_output
3332 That is, read(2) returns more bytes than have
3333 ever been written successfully. The 1033 bytes
3334 read are the 1022 bytes written successfully
3335 after processing (for example with CRs added if
3336 the terminal is set up that way which it is
3337 here). The same bytes will be seen again in a
3338 later read(2), without the CRs. */
3340 if (errno
== EAGAIN
)
3343 ioctl (XINT (XPROCESS (proc
)->outfd
), TIOCFLUSH
,
3346 #endif /* BROKEN_PTY_READ_AFTER_EAGAIN */
3348 /* Running filters might relocate buffers or strings.
3349 Arrange to relocate BUF. */
3350 if (BUFFERP (object
))
3351 offset
= BUF_PTR_BYTE_POS (XBUFFER (object
), buf
);
3352 else if (STRINGP (object
))
3353 offset
= buf
- XSTRING (object
)->data
;
3355 XSETFASTINT (zero
, 0);
3356 #ifdef EMACS_HAS_USECS
3357 wait_reading_process_input (0, 20000, zero
, 0);
3359 wait_reading_process_input (1, 0, zero
, 0);
3362 if (BUFFERP (object
))
3363 buf
= BUF_BYTE_ADDRESS (XBUFFER (object
), offset
);
3364 else if (STRINGP (object
))
3365 buf
= offset
+ XSTRING (object
)->data
;
3370 /* This is a real error. */
3371 report_file_error ("writing to process", Fcons (proc
, Qnil
));
3378 /* If we sent just part of the string, put in an EOF
3379 to force it through, before we send the rest. */
3381 Fprocess_send_eof (proc
);
3386 XPROCESS (proc
)->raw_status_low
= Qnil
;
3387 XPROCESS (proc
)->raw_status_high
= Qnil
;
3388 XPROCESS (proc
)->status
= Fcons (Qexit
, Fcons (make_number (256), Qnil
));
3389 XSETINT (XPROCESS (proc
)->tick
, ++process_tick
);
3390 deactivate_process (proc
);
3392 error ("Error writing to process %s; closed it",
3393 XSTRING (XPROCESS (proc
)->name
)->data
);
3395 error ("SIGPIPE raised on process %s; closed it",
3396 XSTRING (XPROCESS (proc
)->name
)->data
);
3403 DEFUN ("process-send-region", Fprocess_send_region
, Sprocess_send_region
,
3405 "Send current contents of region as input to PROCESS.\n\
3406 PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
3407 nil, indicating the current buffer's process.\n\
3408 Called from program, takes three arguments, PROCESS, START and END.\n\
3409 If the region is more than 500 characters long,\n\
3410 it is sent in several bunches. This may happen even for shorter regions.\n\
3411 Output from processes can arrive in between bunches.")
3412 (process
, start
, end
)
3413 Lisp_Object process
, start
, end
;
3418 proc
= get_process (process
);
3419 validate_region (&start
, &end
);
3421 if (XINT (start
) < GPT
&& XINT (end
) > GPT
)
3422 move_gap (XINT (start
));
3424 start1
= CHAR_TO_BYTE (XINT (start
));
3425 end1
= CHAR_TO_BYTE (XINT (end
));
3426 send_process (proc
, BYTE_POS_ADDR (start1
), end1
- start1
,
3427 Fcurrent_buffer ());
3432 DEFUN ("process-send-string", Fprocess_send_string
, Sprocess_send_string
,
3434 "Send PROCESS the contents of STRING as input.\n\
3435 PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
3436 nil, indicating the current buffer's process.\n\
3437 If STRING is more than 500 characters long,\n\
3438 it is sent in several bunches. This may happen even for shorter strings.\n\
3439 Output from processes can arrive in between bunches.")
3441 Lisp_Object process
, string
;
3444 CHECK_STRING (string
, 1);
3445 proc
= get_process (process
);
3446 send_process (proc
, XSTRING (string
)->data
,
3447 STRING_BYTES (XSTRING (string
)), string
);
3451 DEFUN ("process-running-child-p", Fprocess_running_child_p
,
3452 Sprocess_running_child_p
, 0, 1, 0,
3453 "Return t if PROCESS has given the terminal to a child.\n\
3454 If the operating system does not make it possible to find out,\n\
3455 return t unconditionally.")
3457 Lisp_Object process
;
3459 /* Initialize in case ioctl doesn't exist or gives an error,
3460 in a way that will cause returning t. */
3463 struct Lisp_Process
*p
;
3465 proc
= get_process (process
);
3466 p
= XPROCESS (proc
);
3468 if (!EQ (p
->childp
, Qt
))
3469 error ("Process %s is not a subprocess",
3470 XSTRING (p
->name
)->data
);
3471 if (XINT (p
->infd
) < 0)
3472 error ("Process %s is not active",
3473 XSTRING (p
->name
)->data
);
3476 if (!NILP (p
->subtty
))
3477 ioctl (XFASTINT (p
->subtty
), TIOCGPGRP
, &gid
);
3479 ioctl (XINT (p
->infd
), TIOCGPGRP
, &gid
);
3480 #endif /* defined (TIOCGPGRP ) */
3482 if (gid
== XFASTINT (p
->pid
))
3487 /* send a signal number SIGNO to PROCESS.
3488 If CURRENT_GROUP is t, that means send to the process group
3489 that currently owns the terminal being used to communicate with PROCESS.
3490 This is used for various commands in shell mode.
3491 If CURRENT_GROUP is lambda, that means send to the process group
3492 that currently owns the terminal, but only if it is NOT the shell itself.
3494 If NOMSG is zero, insert signal-announcements into process's buffers
3497 If we can, we try to signal PROCESS by sending control characters
3498 down the pty. This allows us to signal inferiors who have changed
3499 their uid, for which killpg would return an EPERM error. */
3502 process_send_signal (process
, signo
, current_group
, nomsg
)
3503 Lisp_Object process
;
3505 Lisp_Object current_group
;
3509 register struct Lisp_Process
*p
;
3513 proc
= get_process (process
);
3514 p
= XPROCESS (proc
);
3516 if (!EQ (p
->childp
, Qt
))
3517 error ("Process %s is not a subprocess",
3518 XSTRING (p
->name
)->data
);
3519 if (XINT (p
->infd
) < 0)
3520 error ("Process %s is not active",
3521 XSTRING (p
->name
)->data
);
3523 if (NILP (p
->pty_flag
))
3524 current_group
= Qnil
;
3526 /* If we are using pgrps, get a pgrp number and make it negative. */
3527 if (!NILP (current_group
))
3529 #ifdef SIGNALS_VIA_CHARACTERS
3530 /* If possible, send signals to the entire pgrp
3531 by sending an input character to it. */
3533 /* TERMIOS is the latest and bestest, and seems most likely to
3534 work. If the system has it, use it. */
3541 tcgetattr (XINT (p
->infd
), &t
);
3542 send_process (proc
, &t
.c_cc
[VINTR
], 1, Qnil
);
3546 tcgetattr (XINT (p
->infd
), &t
);
3547 send_process (proc
, &t
.c_cc
[VQUIT
], 1, Qnil
);
3551 tcgetattr (XINT (p
->infd
), &t
);
3552 #if defined (VSWTCH) && !defined (PREFER_VSUSP)
3553 send_process (proc
, &t
.c_cc
[VSWTCH
], 1, Qnil
);
3555 send_process (proc
, &t
.c_cc
[VSUSP
], 1, Qnil
);
3560 #else /* ! HAVE_TERMIOS */
3562 /* On Berkeley descendants, the following IOCTL's retrieve the
3563 current control characters. */
3564 #if defined (TIOCGLTC) && defined (TIOCGETC)
3572 ioctl (XINT (p
->infd
), TIOCGETC
, &c
);
3573 send_process (proc
, &c
.t_intrc
, 1, Qnil
);
3576 ioctl (XINT (p
->infd
), TIOCGETC
, &c
);
3577 send_process (proc
, &c
.t_quitc
, 1, Qnil
);
3581 ioctl (XINT (p
->infd
), TIOCGLTC
, &lc
);
3582 send_process (proc
, &lc
.t_suspc
, 1, Qnil
);
3584 #endif /* ! defined (SIGTSTP) */
3587 #else /* ! defined (TIOCGLTC) && defined (TIOCGETC) */
3589 /* On SYSV descendants, the TCGETA ioctl retrieves the current control
3596 ioctl (XINT (p
->infd
), TCGETA
, &t
);
3597 send_process (proc
, &t
.c_cc
[VINTR
], 1, Qnil
);
3600 ioctl (XINT (p
->infd
), TCGETA
, &t
);
3601 send_process (proc
, &t
.c_cc
[VQUIT
], 1, Qnil
);
3605 ioctl (XINT (p
->infd
), TCGETA
, &t
);
3606 send_process (proc
, &t
.c_cc
[VSWTCH
], 1, Qnil
);
3608 #endif /* ! defined (SIGTSTP) */
3610 #else /* ! defined (TCGETA) */
3611 Your configuration files are messed up
.
3612 /* If your system configuration files define SIGNALS_VIA_CHARACTERS,
3613 you'd better be using one of the alternatives above! */
3614 #endif /* ! defined (TCGETA) */
3615 #endif /* ! defined (TIOCGLTC) && defined (TIOCGETC) */
3616 #endif /* ! defined HAVE_TERMIOS */
3617 #endif /* ! defined (SIGNALS_VIA_CHARACTERS) */
3620 /* Get the pgrp using the tty itself, if we have that.
3621 Otherwise, use the pty to get the pgrp.
3622 On pfa systems, saka@pfu.fujitsu.co.JP writes:
3623 "TIOCGPGRP symbol defined in sys/ioctl.h at E50.
3624 But, TIOCGPGRP does not work on E50 ;-P works fine on E60"
3625 His patch indicates that if TIOCGPGRP returns an error, then
3626 we should just assume that p->pid is also the process group id. */
3630 if (!NILP (p
->subtty
))
3631 err
= ioctl (XFASTINT (p
->subtty
), TIOCGPGRP
, &gid
);
3633 err
= ioctl (XINT (p
->infd
), TIOCGPGRP
, &gid
);
3637 gid
= - XFASTINT (p
->pid
);
3638 #endif /* ! defined (pfa) */
3644 #else /* ! defined (TIOCGPGRP ) */
3645 /* Can't select pgrps on this system, so we know that
3646 the child itself heads the pgrp. */
3647 gid
= - XFASTINT (p
->pid
);
3648 #endif /* ! defined (TIOCGPGRP ) */
3650 /* If current_group is lambda, and the shell owns the terminal,
3651 don't send any signal. */
3652 if (EQ (current_group
, Qlambda
) && gid
== - XFASTINT (p
->pid
))
3656 gid
= - XFASTINT (p
->pid
);
3662 p
->raw_status_low
= Qnil
;
3663 p
->raw_status_high
= Qnil
;
3665 XSETINT (p
->tick
, ++process_tick
);
3669 #endif /* ! defined (SIGCONT) */
3672 send_process (proc
, "\003", 1, Qnil
); /* ^C */
3677 send_process (proc
, "\031", 1, Qnil
); /* ^Y */
3682 sys$
forcex (&(XFASTINT (p
->pid
)), 0, 1);
3685 flush_pending_output (XINT (p
->infd
));
3689 /* If we don't have process groups, send the signal to the immediate
3690 subprocess. That isn't really right, but it's better than any
3691 obvious alternative. */
3694 kill (XFASTINT (p
->pid
), signo
);
3698 /* gid may be a pid, or minus a pgrp's number */
3700 if (!NILP (current_group
))
3701 ioctl (XINT (p
->infd
), TIOCSIGSEND
, signo
);
3704 gid
= - XFASTINT (p
->pid
);
3707 #else /* ! defined (TIOCSIGSEND) */
3708 EMACS_KILLPG (-gid
, signo
);
3709 #endif /* ! defined (TIOCSIGSEND) */
3712 DEFUN ("interrupt-process", Finterrupt_process
, Sinterrupt_process
, 0, 2, 0,
3713 "Interrupt process PROCESS.\n\
3714 PROCESS may be a process, a buffer, or the name of a process or buffer.\n\
3715 nil or no arg means current buffer's process.\n\
3716 Second arg CURRENT-GROUP non-nil means send signal to\n\
3717 the current process-group of the process's controlling terminal\n\
3718 rather than to the process's own process group.\n\
3719 If the process is a shell, this means interrupt current subjob\n\
3720 rather than the shell.\n\
3722 If CURRENT-GROUP is `lambda', and if the shell owns the terminal,\n\
3723 don't send the signal.")
3724 (process
, current_group
)
3725 Lisp_Object process
, current_group
;
3727 process_send_signal (process
, SIGINT
, current_group
, 0);
3731 DEFUN ("kill-process", Fkill_process
, Skill_process
, 0, 2, 0,
3732 "Kill process PROCESS. May be process or name of one.\n\
3733 See function `interrupt-process' for more details on usage.")
3734 (process
, current_group
)
3735 Lisp_Object process
, current_group
;
3737 process_send_signal (process
, SIGKILL
, current_group
, 0);
3741 DEFUN ("quit-process", Fquit_process
, Squit_process
, 0, 2, 0,
3742 "Send QUIT signal to process PROCESS. May be process or name of one.\n\
3743 See function `interrupt-process' for more details on usage.")
3744 (process
, current_group
)
3745 Lisp_Object process
, current_group
;
3747 process_send_signal (process
, SIGQUIT
, current_group
, 0);
3751 DEFUN ("stop-process", Fstop_process
, Sstop_process
, 0, 2, 0,
3752 "Stop process PROCESS. May be process or name of one.\n\
3753 See function `interrupt-process' for more details on usage.")
3754 (process
, current_group
)
3755 Lisp_Object process
, current_group
;
3758 error ("no SIGTSTP support");
3760 process_send_signal (process
, SIGTSTP
, current_group
, 0);
3765 DEFUN ("continue-process", Fcontinue_process
, Scontinue_process
, 0, 2, 0,
3766 "Continue process PROCESS. May be process or name of one.\n\
3767 See function `interrupt-process' for more details on usage.")
3768 (process
, current_group
)
3769 Lisp_Object process
, current_group
;
3772 process_send_signal (process
, SIGCONT
, current_group
, 0);
3774 error ("no SIGCONT support");
3779 DEFUN ("signal-process", Fsignal_process
, Ssignal_process
,
3780 2, 2, "nProcess number: \nnSignal code: ",
3781 "Send the process with process id PID the signal with code SIGCODE.\n\
3782 PID must be an integer. The process need not be a child of this Emacs.\n\
3783 SIGCODE may be an integer, or a symbol whose name is a signal name.")
3785 Lisp_Object pid
, sigcode
;
3787 CHECK_NUMBER (pid
, 0);
3789 #define handle_signal(NAME, VALUE) \
3790 else if (!strcmp (name, NAME)) \
3791 XSETINT (sigcode, VALUE)
3793 if (INTEGERP (sigcode
))
3797 unsigned char *name
;
3799 CHECK_SYMBOL (sigcode
, 1);
3800 name
= XSYMBOL (sigcode
)->name
->data
;
3805 handle_signal ("SIGHUP", SIGHUP
);
3808 handle_signal ("SIGINT", SIGINT
);
3811 handle_signal ("SIGQUIT", SIGQUIT
);
3814 handle_signal ("SIGILL", SIGILL
);
3817 handle_signal ("SIGABRT", SIGABRT
);
3820 handle_signal ("SIGEMT", SIGEMT
);
3823 handle_signal ("SIGKILL", SIGKILL
);
3826 handle_signal ("SIGFPE", SIGFPE
);
3829 handle_signal ("SIGBUS", SIGBUS
);
3832 handle_signal ("SIGSEGV", SIGSEGV
);
3835 handle_signal ("SIGSYS", SIGSYS
);
3838 handle_signal ("SIGPIPE", SIGPIPE
);
3841 handle_signal ("SIGALRM", SIGALRM
);
3844 handle_signal ("SIGTERM", SIGTERM
);
3847 handle_signal ("SIGURG", SIGURG
);
3850 handle_signal ("SIGSTOP", SIGSTOP
);
3853 handle_signal ("SIGTSTP", SIGTSTP
);
3856 handle_signal ("SIGCONT", SIGCONT
);
3859 handle_signal ("SIGCHLD", SIGCHLD
);
3862 handle_signal ("SIGTTIN", SIGTTIN
);
3865 handle_signal ("SIGTTOU", SIGTTOU
);
3868 handle_signal ("SIGIO", SIGIO
);
3871 handle_signal ("SIGXCPU", SIGXCPU
);
3874 handle_signal ("SIGXFSZ", SIGXFSZ
);
3877 handle_signal ("SIGVTALRM", SIGVTALRM
);
3880 handle_signal ("SIGPROF", SIGPROF
);
3883 handle_signal ("SIGWINCH", SIGWINCH
);
3886 handle_signal ("SIGINFO", SIGINFO
);
3889 handle_signal ("SIGUSR1", SIGUSR1
);
3892 handle_signal ("SIGUSR2", SIGUSR2
);
3895 error ("Undefined signal name %s", name
);
3898 #undef handle_signal
3900 return make_number (kill (XINT (pid
), XINT (sigcode
)));
3903 DEFUN ("process-send-eof", Fprocess_send_eof
, Sprocess_send_eof
, 0, 1, 0,
3904 "Make PROCESS see end-of-file in its input.\n\
3905 EOF comes after any text already sent to it.\n\
3906 PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
3907 nil, indicating the current buffer's process.\n\
3908 If PROCESS is a network connection, or is a process communicating\n\
3909 through a pipe (as opposed to a pty), then you cannot send any more\n\
3910 text to PROCESS after you call this function.")
3912 Lisp_Object process
;
3915 struct coding_system
*coding
;
3917 proc
= get_process (process
);
3918 coding
= proc_encode_coding_system
[XINT (XPROCESS (proc
)->outfd
)];
3920 /* Make sure the process is really alive. */
3921 if (! NILP (XPROCESS (proc
)->raw_status_low
))
3922 update_status (XPROCESS (proc
));
3923 if (! EQ (XPROCESS (proc
)->status
, Qrun
))
3924 error ("Process %s not running", XSTRING (XPROCESS (proc
)->name
)->data
);
3926 if (CODING_REQUIRE_FLUSHING (coding
))
3928 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
3929 send_process (proc
, "", 0, Qnil
);
3933 send_process (proc
, "\032", 1, Qnil
); /* ^z */
3935 if (!NILP (XPROCESS (proc
)->pty_flag
))
3936 send_process (proc
, "\004", 1, Qnil
);
3939 int old_outfd
, new_outfd
;
3941 #ifdef HAVE_SHUTDOWN
3942 /* If this is a network connection, or socketpair is used
3943 for communication with the subprocess, call shutdown to cause EOF.
3944 (In some old system, shutdown to socketpair doesn't work.
3945 Then we just can't win.) */
3946 if (NILP (XPROCESS (proc
)->pid
)
3947 || XINT (XPROCESS (proc
)->outfd
) == XINT (XPROCESS (proc
)->infd
))
3948 shutdown (XINT (XPROCESS (proc
)->outfd
), 1);
3949 /* In case of socketpair, outfd == infd, so don't close it. */
3950 if (XINT (XPROCESS (proc
)->outfd
) != XINT (XPROCESS (proc
)->infd
))
3951 emacs_close (XINT (XPROCESS (proc
)->outfd
));
3952 #else /* not HAVE_SHUTDOWN */
3953 emacs_close (XINT (XPROCESS (proc
)->outfd
));
3954 #endif /* not HAVE_SHUTDOWN */
3955 new_outfd
= emacs_open (NULL_DEVICE
, O_WRONLY
, 0);
3956 old_outfd
= XINT (XPROCESS (proc
)->outfd
);
3958 if (!proc_encode_coding_system
[new_outfd
])
3959 proc_encode_coding_system
[new_outfd
]
3960 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
3961 bcopy (proc_encode_coding_system
[old_outfd
],
3962 proc_encode_coding_system
[new_outfd
],
3963 sizeof (struct coding_system
));
3964 bzero (proc_encode_coding_system
[old_outfd
],
3965 sizeof (struct coding_system
));
3967 XSETINT (XPROCESS (proc
)->outfd
, new_outfd
);
3973 /* Kill all processes associated with `buffer'.
3974 If `buffer' is nil, kill all processes */
3977 kill_buffer_processes (buffer
)
3980 Lisp_Object tail
, proc
;
3982 for (tail
= Vprocess_alist
; GC_CONSP (tail
); tail
= XCDR (tail
))
3984 proc
= XCDR (XCAR (tail
));
3985 if (GC_PROCESSP (proc
)
3986 && (NILP (buffer
) || EQ (XPROCESS (proc
)->buffer
, buffer
)))
3988 if (NETCONN_P (proc
))
3989 Fdelete_process (proc
);
3990 else if (XINT (XPROCESS (proc
)->infd
) >= 0)
3991 process_send_signal (proc
, SIGHUP
, Qnil
, 1);
3996 /* On receipt of a signal that a child status has changed,
3997 loop asking about children with changed statuses until
3998 the system says there are no more.
3999 All we do is change the status;
4000 we do not run sentinels or print notifications.
4001 That is saved for the next time keyboard input is done,
4002 in order to avoid timing errors. */
4004 /** WARNING: this can be called during garbage collection.
4005 Therefore, it must not be fooled by the presence of mark bits in
4008 /** USG WARNING: Although it is not obvious from the documentation
4009 in signal(2), on a USG system the SIGCLD handler MUST NOT call
4010 signal() before executing at least one wait(), otherwise the handler
4011 will be called again, resulting in an infinite loop. The relevant
4012 portion of the documentation reads "SIGCLD signals will be queued
4013 and the signal-catching function will be continually reentered until
4014 the queue is empty". Invoking signal() causes the kernel to reexamine
4015 the SIGCLD queue. Fred Fish, UniSoft Systems Inc. */
4018 sigchld_handler (signo
)
4021 int old_errno
= errno
;
4023 register struct Lisp_Process
*p
;
4024 extern EMACS_TIME
*input_available_clear_time
;
4028 sigheld
|= sigbit (SIGCHLD
);
4040 #endif /* no WUNTRACED */
4041 /* Keep trying to get a status until we get a definitive result. */
4045 pid
= wait3 (&w
, WNOHANG
| WUNTRACED
, 0);
4047 while (pid
<= 0 && errno
== EINTR
);
4051 /* A real failure. We have done all our job, so return. */
4053 /* USG systems forget handlers when they are used;
4054 must reestablish each time */
4055 #if defined (USG) && !defined (POSIX_SIGNALS)
4056 signal (signo
, sigchld_handler
); /* WARNING - must come after wait3() */
4059 sigheld
&= ~sigbit (SIGCHLD
);
4067 #endif /* no WNOHANG */
4069 /* Find the process that signaled us, and record its status. */
4072 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
4074 proc
= XCDR (XCAR (tail
));
4075 p
= XPROCESS (proc
);
4076 if (EQ (p
->childp
, Qt
) && XFASTINT (p
->pid
) == pid
)
4081 /* Look for an asynchronous process whose pid hasn't been filled
4084 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
4086 proc
= XCDR (XCAR (tail
));
4087 p
= XPROCESS (proc
);
4088 if (INTEGERP (p
->pid
) && XINT (p
->pid
) == -1)
4093 /* Change the status of the process that was found. */
4096 union { int i
; WAITTYPE wt
; } u
;
4097 int clear_desc_flag
= 0;
4099 XSETINT (p
->tick
, ++process_tick
);
4101 XSETINT (p
->raw_status_low
, u
.i
& 0xffff);
4102 XSETINT (p
->raw_status_high
, u
.i
>> 16);
4104 /* If process has terminated, stop waiting for its output. */
4105 if ((WIFSIGNALED (w
) || WIFEXITED (w
))
4106 && XINT (p
->infd
) >= 0)
4107 clear_desc_flag
= 1;
4109 /* We use clear_desc_flag to avoid a compiler bug in Microsoft C. */
4110 if (clear_desc_flag
)
4112 FD_CLR (XINT (p
->infd
), &input_wait_mask
);
4113 FD_CLR (XINT (p
->infd
), &non_keyboard_wait_mask
);
4116 /* Tell wait_reading_process_input that it needs to wake up and
4118 if (input_available_clear_time
)
4119 EMACS_SET_SECS_USECS (*input_available_clear_time
, 0, 0);
4122 /* There was no asynchronous process found for that id. Check
4123 if we have a synchronous process. */
4126 synch_process_alive
= 0;
4128 /* Report the status of the synchronous process. */
4130 synch_process_retcode
= WRETCODE (w
);
4131 else if (WIFSIGNALED (w
))
4133 int code
= WTERMSIG (w
);
4136 synchronize_system_messages_locale ();
4137 signame
= strsignal (code
);
4140 signame
= "unknown";
4142 synch_process_death
= signame
;
4145 /* Tell wait_reading_process_input that it needs to wake up and
4147 if (input_available_clear_time
)
4148 EMACS_SET_SECS_USECS (*input_available_clear_time
, 0, 0);
4151 /* On some systems, we must return right away.
4152 If any more processes want to signal us, we will
4154 Otherwise (on systems that have WNOHANG), loop around
4155 to use up all the processes that have something to tell us. */
4156 #if defined (USG) && ! (defined (HPUX) && defined (WNOHANG)) || defined (WINDOWSNT)
4157 #if defined (USG) && ! defined (POSIX_SIGNALS)
4158 signal (signo
, sigchld_handler
);
4162 #endif /* USG, but not HPUX with WNOHANG */
4168 exec_sentinel_unwind (data
)
4171 XPROCESS (XCAR (data
))->sentinel
= XCDR (data
);
4176 exec_sentinel_error_handler (error
)
4179 cmd_error_internal (error
, "error in process sentinel: ");
4181 update_echo_area ();
4182 Fsleep_for (make_number (2), Qnil
);
4187 exec_sentinel (proc
, reason
)
4188 Lisp_Object proc
, reason
;
4190 Lisp_Object sentinel
, obuffer
, odeactivate
, okeymap
;
4191 register struct Lisp_Process
*p
= XPROCESS (proc
);
4192 int count
= specpdl_ptr
- specpdl
;
4193 int outer_running_asynch_code
= running_asynch_code
;
4194 int waiting
= waiting_for_user_input_p
;
4196 /* No need to gcpro these, because all we do with them later
4197 is test them for EQness, and none of them should be a string. */
4198 odeactivate
= Vdeactivate_mark
;
4199 XSETBUFFER (obuffer
, current_buffer
);
4200 okeymap
= current_buffer
->keymap
;
4202 sentinel
= p
->sentinel
;
4203 if (NILP (sentinel
))
4206 /* Zilch the sentinel while it's running, to avoid recursive invocations;
4207 assure that it gets restored no matter how the sentinel exits. */
4209 record_unwind_protect (exec_sentinel_unwind
, Fcons (proc
, sentinel
));
4210 /* Inhibit quit so that random quits don't screw up a running filter. */
4211 specbind (Qinhibit_quit
, Qt
);
4212 specbind (Qlast_nonmenu_event
, Qt
);
4214 /* In case we get recursively called,
4215 and we already saved the match data nonrecursively,
4216 save the same match data in safely recursive fashion. */
4217 if (outer_running_asynch_code
)
4220 tem
= Fmatch_data (Qnil
, Qnil
);
4221 restore_match_data ();
4222 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
4223 Fset_match_data (tem
);
4226 /* For speed, if a search happens within this code,
4227 save the match data in a special nonrecursive fashion. */
4228 running_asynch_code
= 1;
4230 internal_condition_case_1 (read_process_output_call
,
4232 Fcons (proc
, Fcons (reason
, Qnil
))),
4233 !NILP (Vdebug_on_error
) ? Qnil
: Qerror
,
4234 exec_sentinel_error_handler
);
4236 /* If we saved the match data nonrecursively, restore it now. */
4237 restore_match_data ();
4238 running_asynch_code
= outer_running_asynch_code
;
4240 Vdeactivate_mark
= odeactivate
;
4242 /* Restore waiting_for_user_input_p as it was
4243 when we were called, in case the filter clobbered it. */
4244 waiting_for_user_input_p
= waiting
;
4247 if (! EQ (Fcurrent_buffer (), obuffer
)
4248 || ! EQ (current_buffer
->keymap
, okeymap
))
4250 /* But do it only if the caller is actually going to read events.
4251 Otherwise there's no need to make him wake up, and it could
4252 cause trouble (for example it would make Fsit_for return). */
4253 if (waiting_for_user_input_p
== -1)
4254 record_asynch_buffer_change ();
4256 unbind_to (count
, Qnil
);
4259 /* Report all recent events of a change in process status
4260 (either run the sentinel or output a message).
4261 This is done while Emacs is waiting for keyboard input. */
4266 register Lisp_Object proc
, buffer
;
4267 Lisp_Object tail
, msg
;
4268 struct gcpro gcpro1
, gcpro2
;
4272 /* We need to gcpro tail; if read_process_output calls a filter
4273 which deletes a process and removes the cons to which tail points
4274 from Vprocess_alist, and then causes a GC, tail is an unprotected
4278 /* Set this now, so that if new processes are created by sentinels
4279 that we run, we get called again to handle their status changes. */
4280 update_tick
= process_tick
;
4282 for (tail
= Vprocess_alist
; !NILP (tail
); tail
= Fcdr (tail
))
4285 register struct Lisp_Process
*p
;
4287 proc
= Fcdr (Fcar (tail
));
4288 p
= XPROCESS (proc
);
4290 if (XINT (p
->tick
) != XINT (p
->update_tick
))
4292 XSETINT (p
->update_tick
, XINT (p
->tick
));
4294 /* If process is still active, read any output that remains. */
4295 while (! EQ (p
->filter
, Qt
)
4296 && XINT (p
->infd
) >= 0
4297 && read_process_output (proc
, XINT (p
->infd
)) > 0);
4301 /* Get the text to use for the message. */
4302 if (!NILP (p
->raw_status_low
))
4304 msg
= status_message (p
->status
);
4306 /* If process is terminated, deactivate it or delete it. */
4308 if (CONSP (p
->status
))
4309 symbol
= XCAR (p
->status
);
4311 if (EQ (symbol
, Qsignal
) || EQ (symbol
, Qexit
)
4312 || EQ (symbol
, Qclosed
))
4314 if (delete_exited_processes
)
4315 remove_process (proc
);
4317 deactivate_process (proc
);
4320 /* The actions above may have further incremented p->tick.
4321 So set p->update_tick again
4322 so that an error in the sentinel will not cause
4323 this code to be run again. */
4324 XSETINT (p
->update_tick
, XINT (p
->tick
));
4325 /* Now output the message suitably. */
4326 if (!NILP (p
->sentinel
))
4327 exec_sentinel (proc
, msg
);
4328 /* Don't bother with a message in the buffer
4329 when a process becomes runnable. */
4330 else if (!EQ (symbol
, Qrun
) && !NILP (buffer
))
4332 Lisp_Object ro
, tem
;
4333 struct buffer
*old
= current_buffer
;
4334 int opoint
, opoint_byte
;
4335 int before
, before_byte
;
4337 ro
= XBUFFER (buffer
)->read_only
;
4339 /* Avoid error if buffer is deleted
4340 (probably that's why the process is dead, too) */
4341 if (NILP (XBUFFER (buffer
)->name
))
4343 Fset_buffer (buffer
);
4346 opoint_byte
= PT_BYTE
;
4347 /* Insert new output into buffer
4348 at the current end-of-output marker,
4349 thus preserving logical ordering of input and output. */
4350 if (XMARKER (p
->mark
)->buffer
)
4351 Fgoto_char (p
->mark
);
4353 SET_PT_BOTH (ZV
, ZV_BYTE
);
4356 before_byte
= PT_BYTE
;
4358 tem
= current_buffer
->read_only
;
4359 current_buffer
->read_only
= Qnil
;
4360 insert_string ("\nProcess ");
4361 Finsert (1, &p
->name
);
4362 insert_string (" ");
4364 current_buffer
->read_only
= tem
;
4365 set_marker_both (p
->mark
, p
->buffer
, PT
, PT_BYTE
);
4367 if (opoint
>= before
)
4368 SET_PT_BOTH (opoint
+ (PT
- before
),
4369 opoint_byte
+ (PT_BYTE
- before_byte
));
4371 SET_PT_BOTH (opoint
, opoint_byte
);
4373 set_buffer_internal (old
);
4378 update_mode_lines
++; /* in case buffers use %s in mode-line-format */
4379 redisplay_preserve_echo_area ();
4385 DEFUN ("set-process-coding-system", Fset_process_coding_system
,
4386 Sset_process_coding_system
, 1, 3, 0,
4387 "Set coding systems of PROCESS to DECODING and ENCODING.\n\
4388 DECODING will be used to decode subprocess output and ENCODING to\n\
4389 encode subprocess input.")
4390 (proc
, decoding
, encoding
)
4391 register Lisp_Object proc
, decoding
, encoding
;
4393 register struct Lisp_Process
*p
;
4395 CHECK_PROCESS (proc
, 0);
4396 p
= XPROCESS (proc
);
4397 if (XINT (p
->infd
) < 0)
4398 error ("Input file descriptor of %s closed", XSTRING (p
->name
)->data
);
4399 if (XINT (p
->outfd
) < 0)
4400 error ("Output file descriptor of %s closed", XSTRING (p
->name
)->data
);
4402 p
->decode_coding_system
= Fcheck_coding_system (decoding
);
4403 p
->encode_coding_system
= Fcheck_coding_system (encoding
);
4404 setup_coding_system (decoding
,
4405 proc_decode_coding_system
[XINT (p
->infd
)]);
4406 setup_coding_system (encoding
,
4407 proc_encode_coding_system
[XINT (p
->outfd
)]);
4412 DEFUN ("process-coding-system",
4413 Fprocess_coding_system
, Sprocess_coding_system
, 1, 1, 0,
4414 "Return a cons of coding systems for decoding and encoding of PROCESS.")
4416 register Lisp_Object proc
;
4418 CHECK_PROCESS (proc
, 0);
4419 return Fcons (XPROCESS (proc
)->decode_coding_system
,
4420 XPROCESS (proc
)->encode_coding_system
);
4423 /* The first time this is called, assume keyboard input comes from DESC
4424 instead of from where we used to expect it.
4425 Subsequent calls mean assume input keyboard can come from DESC
4426 in addition to other places. */
4428 static int add_keyboard_wait_descriptor_called_flag
;
4431 add_keyboard_wait_descriptor (desc
)
4434 if (! add_keyboard_wait_descriptor_called_flag
)
4435 FD_CLR (0, &input_wait_mask
);
4436 add_keyboard_wait_descriptor_called_flag
= 1;
4437 FD_SET (desc
, &input_wait_mask
);
4438 FD_SET (desc
, &non_process_wait_mask
);
4439 if (desc
> max_keyboard_desc
)
4440 max_keyboard_desc
= desc
;
4443 /* From now on, do not expect DESC to give keyboard input. */
4446 delete_keyboard_wait_descriptor (desc
)
4450 int lim
= max_keyboard_desc
;
4452 FD_CLR (desc
, &input_wait_mask
);
4453 FD_CLR (desc
, &non_process_wait_mask
);
4455 if (desc
== max_keyboard_desc
)
4456 for (fd
= 0; fd
< lim
; fd
++)
4457 if (FD_ISSET (fd
, &input_wait_mask
)
4458 && !FD_ISSET (fd
, &non_keyboard_wait_mask
))
4459 max_keyboard_desc
= fd
;
4462 /* Return nonzero if *MASK has a bit set
4463 that corresponds to one of the keyboard input descriptors. */
4466 keyboard_bit_set (mask
)
4471 for (fd
= 0; fd
<= max_keyboard_desc
; fd
++)
4472 if (FD_ISSET (fd
, mask
) && FD_ISSET (fd
, &input_wait_mask
)
4473 && !FD_ISSET (fd
, &non_keyboard_wait_mask
))
4486 if (! noninteractive
|| initialized
)
4488 signal (SIGCHLD
, sigchld_handler
);
4491 FD_ZERO (&input_wait_mask
);
4492 FD_ZERO (&non_keyboard_wait_mask
);
4493 FD_ZERO (&non_process_wait_mask
);
4494 max_process_desc
= 0;
4496 FD_SET (0, &input_wait_mask
);
4498 Vprocess_alist
= Qnil
;
4499 for (i
= 0; i
< MAXDESC
; i
++)
4501 chan_process
[i
] = Qnil
;
4502 proc_buffered_char
[i
] = -1;
4504 bzero (proc_decode_coding_system
, sizeof proc_decode_coding_system
);
4505 bzero (proc_encode_coding_system
, sizeof proc_encode_coding_system
);
4507 Vdefault_process_coding_system
4508 = (NILP (buffer_defaults
.enable_multibyte_characters
)
4509 ? Fcons (Qraw_text
, Qnil
)
4510 : Fcons (Qemacs_mule
, Qnil
));
4516 Qprocessp
= intern ("processp");
4517 staticpro (&Qprocessp
);
4518 Qrun
= intern ("run");
4520 Qstop
= intern ("stop");
4522 Qsignal
= intern ("signal");
4523 staticpro (&Qsignal
);
4525 /* Qexit is already staticpro'd by syms_of_eval; don't staticpro it
4528 Qexit = intern ("exit");
4529 staticpro (&Qexit); */
4531 Qopen
= intern ("open");
4533 Qclosed
= intern ("closed");
4534 staticpro (&Qclosed
);
4536 Qlast_nonmenu_event
= intern ("last-nonmenu-event");
4537 staticpro (&Qlast_nonmenu_event
);
4539 staticpro (&Vprocess_alist
);
4541 DEFVAR_BOOL ("delete-exited-processes", &delete_exited_processes
,
4542 "*Non-nil means delete processes immediately when they exit.\n\
4543 nil means don't delete them until `list-processes' is run.");
4545 delete_exited_processes
= 1;
4547 DEFVAR_LISP ("process-connection-type", &Vprocess_connection_type
,
4548 "Control type of device used to communicate with subprocesses.\n\
4549 Values are nil to use a pipe, or t or `pty' to use a pty.\n\
4550 The value has no effect if the system has no ptys or if all ptys are busy:\n\
4551 then a pipe is used in any case.\n\
4552 The value takes effect when `start-process' is called.");
4553 Vprocess_connection_type
= Qt
;
4555 defsubr (&Sprocessp
);
4556 defsubr (&Sget_process
);
4557 defsubr (&Sget_buffer_process
);
4558 defsubr (&Sdelete_process
);
4559 defsubr (&Sprocess_status
);
4560 defsubr (&Sprocess_exit_status
);
4561 defsubr (&Sprocess_id
);
4562 defsubr (&Sprocess_name
);
4563 defsubr (&Sprocess_tty_name
);
4564 defsubr (&Sprocess_command
);
4565 defsubr (&Sset_process_buffer
);
4566 defsubr (&Sprocess_buffer
);
4567 defsubr (&Sprocess_mark
);
4568 defsubr (&Sset_process_filter
);
4569 defsubr (&Sprocess_filter
);
4570 defsubr (&Sset_process_sentinel
);
4571 defsubr (&Sprocess_sentinel
);
4572 defsubr (&Sset_process_window_size
);
4573 defsubr (&Sset_process_inherit_coding_system_flag
);
4574 defsubr (&Sprocess_inherit_coding_system_flag
);
4575 defsubr (&Sprocess_kill_without_query
);
4576 defsubr (&Sprocess_contact
);
4577 defsubr (&Slist_processes
);
4578 defsubr (&Sprocess_list
);
4579 defsubr (&Sstart_process
);
4581 defsubr (&Sopen_network_stream
);
4582 #endif /* HAVE_SOCKETS */
4583 defsubr (&Saccept_process_output
);
4584 defsubr (&Sprocess_send_region
);
4585 defsubr (&Sprocess_send_string
);
4586 defsubr (&Sinterrupt_process
);
4587 defsubr (&Skill_process
);
4588 defsubr (&Squit_process
);
4589 defsubr (&Sstop_process
);
4590 defsubr (&Scontinue_process
);
4591 defsubr (&Sprocess_running_child_p
);
4592 defsubr (&Sprocess_send_eof
);
4593 defsubr (&Ssignal_process
);
4594 defsubr (&Swaiting_for_user_input_p
);
4595 /* defsubr (&Sprocess_connection); */
4596 defsubr (&Sset_process_coding_system
);
4597 defsubr (&Sprocess_coding_system
);
4601 #else /* not subprocesses */
4603 #include <sys/types.h>
4607 #include "systime.h"
4608 #include "charset.h"
4610 #include "termopts.h"
4611 #include "sysselect.h"
4613 extern int frame_garbaged
;
4615 extern EMACS_TIME
timer_check ();
4616 extern int timers_run
;
4618 /* As described above, except assuming that there are no subprocesses:
4620 Wait for timeout to elapse and/or keyboard input to be available.
4623 timeout in seconds, or
4624 zero for no limit, or
4625 -1 means gobble data immediately available but don't wait for any.
4627 read_kbd is a Lisp_Object:
4628 0 to ignore keyboard input, or
4629 1 to return when input is available, or
4630 -1 means caller will actually read the input, so don't throw to
4632 a cons cell, meaning wait until its car is non-nil
4633 (and gobble terminal input into the buffer if any arrives), or
4634 We know that read_kbd will never be a Lisp_Process, since
4635 `subprocesses' isn't defined.
4637 do_display != 0 means redisplay should be done to show subprocess
4638 output that arrives.
4640 Return true iff we received input from any process. */
4643 wait_reading_process_input (time_limit
, microsecs
, read_kbd
, do_display
)
4644 int time_limit
, microsecs
;
4645 Lisp_Object read_kbd
;
4649 EMACS_TIME end_time
, timeout
;
4650 SELECT_TYPE waitchannels
;
4652 Lisp_Object
*wait_for_cell
= 0;
4654 /* If waiting for non-nil in a cell, record where. */
4655 if (CONSP (read_kbd
))
4657 wait_for_cell
= &XCAR (read_kbd
);
4658 XSETFASTINT (read_kbd
, 0);
4661 /* What does time_limit really mean? */
4662 if (time_limit
|| microsecs
)
4664 EMACS_GET_TIME (end_time
);
4665 EMACS_SET_SECS_USECS (timeout
, time_limit
, microsecs
);
4666 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
4669 /* Turn off periodic alarms (in case they are in use)
4670 because the select emulator uses alarms. */
4671 turn_on_atimers (0);
4675 int timeout_reduced_for_timers
= 0;
4677 /* If calling from keyboard input, do not quit
4678 since we want to return C-g as an input character.
4679 Otherwise, do pending quit if requested. */
4680 if (XINT (read_kbd
) >= 0)
4683 /* Exit now if the cell we're waiting for became non-nil. */
4684 if (wait_for_cell
&& ! NILP (*wait_for_cell
))
4687 /* Compute time from now till when time limit is up */
4688 /* Exit if already run out */
4689 if (time_limit
== -1)
4691 /* -1 specified for timeout means
4692 gobble output available now
4693 but don't wait at all. */
4695 EMACS_SET_SECS_USECS (timeout
, 0, 0);
4697 else if (time_limit
|| microsecs
)
4699 EMACS_GET_TIME (timeout
);
4700 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
4701 if (EMACS_TIME_NEG_P (timeout
))
4706 EMACS_SET_SECS_USECS (timeout
, 100000, 0);
4709 /* If our caller will not immediately handle keyboard events,
4710 run timer events directly.
4711 (Callers that will immediately read keyboard events
4712 call timer_delay on their own.) */
4713 if (! wait_for_cell
)
4715 EMACS_TIME timer_delay
;
4719 old_timers_run
= timers_run
;
4720 timer_delay
= timer_check (1);
4721 if (timers_run
!= old_timers_run
&& do_display
)
4723 redisplay_preserve_echo_area ();
4724 /* We must retry, since a timer may have requeued itself
4725 and that could alter the time delay. */
4729 /* If there is unread keyboard input, also return. */
4730 if (XINT (read_kbd
) != 0
4731 && requeued_events_pending_p ())
4734 if (! EMACS_TIME_NEG_P (timer_delay
) && time_limit
!= -1)
4736 EMACS_TIME difference
;
4737 EMACS_SUB_TIME (difference
, timer_delay
, timeout
);
4738 if (EMACS_TIME_NEG_P (difference
))
4740 timeout
= timer_delay
;
4741 timeout_reduced_for_timers
= 1;
4746 /* Cause C-g and alarm signals to take immediate action,
4747 and cause input available signals to zero out timeout. */
4748 if (XINT (read_kbd
) < 0)
4749 set_waiting_for_input (&timeout
);
4751 /* Wait till there is something to do. */
4753 if (! XINT (read_kbd
) && wait_for_cell
== 0)
4754 FD_ZERO (&waitchannels
);
4756 FD_SET (0, &waitchannels
);
4758 /* If a frame has been newly mapped and needs updating,
4759 reprocess its display stuff. */
4760 if (frame_garbaged
&& do_display
)
4762 clear_waiting_for_input ();
4763 redisplay_preserve_echo_area ();
4764 if (XINT (read_kbd
) < 0)
4765 set_waiting_for_input (&timeout
);
4768 if (XINT (read_kbd
) && detect_input_pending ())
4771 FD_ZERO (&waitchannels
);
4774 nfds
= select (1, &waitchannels
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0,
4779 /* Make C-g and alarm signals set flags again */
4780 clear_waiting_for_input ();
4782 /* If we woke up due to SIGWINCH, actually change size now. */
4783 do_pending_window_change (0);
4785 if (time_limit
&& nfds
== 0 && ! timeout_reduced_for_timers
)
4786 /* We waited the full specified time, so return now. */
4791 /* If the system call was interrupted, then go around the
4793 if (xerrno
== EINTR
)
4794 FD_ZERO (&waitchannels
);
4796 error ("select error: %s", emacs_strerror (xerrno
));
4799 else if (nfds
> 0 && (waitchannels
& 1) && interrupt_input
)
4800 /* System sometimes fails to deliver SIGIO. */
4801 kill (getpid (), SIGIO
);
4804 if (XINT (read_kbd
) && interrupt_input
&& (waitchannels
& 1))
4805 kill (getpid (), SIGIO
);
4808 /* Check for keyboard input */
4810 if ((XINT (read_kbd
) != 0)
4811 && detect_input_pending_run_timers (do_display
))
4813 swallow_events (do_display
);
4814 if (detect_input_pending_run_timers (do_display
))
4818 /* If there is unread keyboard input, also return. */
4819 if (XINT (read_kbd
) != 0
4820 && requeued_events_pending_p ())
4823 /* If wait_for_cell. check for keyboard input
4824 but don't run any timers.
4825 ??? (It seems wrong to me to check for keyboard
4826 input at all when wait_for_cell, but the code
4827 has been this way since July 1994.
4828 Try changing this after version 19.31.) */
4830 && detect_input_pending ())
4832 swallow_events (do_display
);
4833 if (detect_input_pending ())
4837 /* Exit now if the cell we're waiting for became non-nil. */
4838 if (wait_for_cell
&& ! NILP (*wait_for_cell
))
4848 DEFUN ("get-buffer-process", Fget_buffer_process
, Sget_buffer_process
, 1, 1, 0,
4849 /* Don't confuse make-docfile by having two doc strings for this function.
4850 make-docfile does not pay attention to #if, for good reason! */
4853 register Lisp_Object name
;
4858 DEFUN ("process-inherit-coding-system-flag",
4859 Fprocess_inherit_coding_system_flag
, Sprocess_inherit_coding_system_flag
,
4861 /* Don't confuse make-docfile by having two doc strings for this function.
4862 make-docfile does not pay attention to #if, for good reason! */
4865 register Lisp_Object process
;
4867 /* Ignore the argument and return the value of
4868 inherit-process-coding-system. */
4869 return inherit_process_coding_system
? Qt
: Qnil
;
4872 /* Kill all processes associated with `buffer'.
4873 If `buffer' is nil, kill all processes.
4874 Since we have no subprocesses, this does nothing. */
4877 kill_buffer_processes (buffer
)
4890 defsubr (&Sget_buffer_process
);
4891 defsubr (&Sprocess_inherit_coding_system_flag
);
4895 #endif /* not subprocesses */