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. */
27 /* This file is split into two parts by the following preprocessor
28 conditional. The 'then' clause contains all of the support for
29 asynchronous subprocesses. The 'else' clause contains stub
30 versions of some of the asynchronous subprocess routines that are
31 often called elsewhere in Emacs, so we don't have to #ifdef the
32 sections that call them. */
40 #include <sys/types.h> /* some typedefs are used in sys/file.h */
50 #endif /* not WINDOWSNT */
52 #ifdef HAVE_SOCKETS /* TCP connection support, if kernel can do it */
53 #include <sys/socket.h>
55 #include <netinet/in.h>
56 #include <arpa/inet.h>
57 #ifdef NEED_NET_ERRNO_H
58 #include <net/errno.h>
59 #endif /* NEED_NET_ERRNO_H */
60 #endif /* HAVE_SOCKETS */
62 /* TERM is a poor-man's SLIP, used on Linux. */
67 /* On some systems, e.g. DGUX, inet_addr returns a 'struct in_addr'. */
68 #ifdef HAVE_BROKEN_INET_ADDR
69 #define IN_ADDR struct in_addr
70 #define NUMERIC_ADDR_ERROR (numeric_addr.s_addr == -1)
72 #define IN_ADDR unsigned long
73 #define NUMERIC_ADDR_ERROR (numeric_addr == -1)
76 #if defined(BSD_SYSTEM) || defined(STRIDE)
77 #include <sys/ioctl.h>
78 #if !defined (O_NDELAY) && defined (HAVE_PTYS) && !defined(USG5)
80 #endif /* HAVE_PTYS and no O_NDELAY */
81 #endif /* BSD_SYSTEM || STRIDE */
83 #ifdef BROKEN_O_NONBLOCK
85 #endif /* BROKEN_O_NONBLOCK */
92 #include <sys/sysmacros.h> /* for "minor" */
104 #include "termhooks.h"
105 #include "termopts.h"
106 #include "commands.h"
108 #include "blockinput.h"
109 #include "keyboard.h"
110 #include "dispextern.h"
112 #define max(a, b) ((a) > (b) ? (a) : (b))
114 Lisp_Object Qprocessp
;
115 Lisp_Object Qrun
, Qstop
, Qsignal
, Qopen
, Qclosed
;
116 Lisp_Object Qlast_nonmenu_event
;
117 /* Qexit is declared and initialized in eval.c. */
119 /* a process object is a network connection when its childp field is neither
120 Qt nor Qnil but is instead a cons cell (HOSTNAME PORTNUM). */
123 #define NETCONN_P(p) (GC_CONSP (XPROCESS (p)->childp))
125 #define NETCONN_P(p) 0
126 #endif /* HAVE_SOCKETS */
128 /* Define first descriptor number available for subprocesses. */
130 #define FIRST_PROC_DESC 1
132 #define FIRST_PROC_DESC 3
135 /* Define SIGCHLD as an alias for SIGCLD. There are many conditionals
138 #if !defined (SIGCHLD) && defined (SIGCLD)
139 #define SIGCHLD SIGCLD
142 #include "syssignal.h"
146 extern void set_waiting_for_input
P_ ((EMACS_TIME
*));
149 extern char *strerror ();
151 extern char *sys_errlist
[];
158 #ifndef HAVE_STRSIGNAL
159 #ifndef SYS_SIGLIST_DECLARED
164 extern char *sys_siglist
[];
165 #endif /* not LINUX */
167 char *sys_siglist
[] =
173 "illegal instruction",
177 "floating point exception",
180 "segmentation violation",
181 "bad argument to system call",
182 "write on a pipe with no one to read it",
184 "software termination signal from kill",
186 "sendable stop signal not from tty",
187 "stop signal from tty",
188 "continue a stopped process",
189 "child status has changed",
190 "background read attempted from control tty",
191 "background write attempted from control tty",
192 "input record available at control tty",
193 "exceeded CPU time limit",
194 "exceeded file size limit"
196 #endif /* not WINDOWSNT */
199 #endif /* ! SYS_SIGLIST_DECLARED */
200 #endif /* ! HAVE_STRSIGNAL */
202 /* t means use pty, nil means use a pipe,
203 maybe other values to come. */
204 static Lisp_Object Vprocess_connection_type
;
208 #include <sys/socket.h>
212 /* These next two vars are non-static since sysdep.c uses them in the
213 emulation of `select'. */
214 /* Number of events of change of status of a process. */
216 /* Number of events for which the user or sentinel has been notified. */
219 #include "sysselect.h"
221 extern int keyboard_bit_set
P_ ((SELECT_TYPE
*));
223 /* If we support a window system, turn on the code to poll periodically
224 to detect C-g. It isn't actually used when doing interrupt input. */
225 #ifdef HAVE_WINDOW_SYSTEM
226 #define POLL_FOR_INPUT
229 /* Mask of bits indicating the descriptors that we wait for input on. */
231 static SELECT_TYPE input_wait_mask
;
233 /* Mask that excludes keyboard input descriptor (s). */
235 static SELECT_TYPE non_keyboard_wait_mask
;
237 /* Mask that excludes process input descriptor (s). */
239 static SELECT_TYPE non_process_wait_mask
;
241 /* The largest descriptor currently in use for a process object. */
242 static int max_process_desc
;
244 /* The largest descriptor currently in use for keyboard input. */
245 static int max_keyboard_desc
;
247 /* Nonzero means delete a process right away if it exits. */
248 static int delete_exited_processes
;
250 /* Indexed by descriptor, gives the process (if any) for that descriptor */
251 Lisp_Object chan_process
[MAXDESC
];
253 /* Alist of elements (NAME . PROCESS) */
254 Lisp_Object Vprocess_alist
;
256 /* Buffered-ahead input char from process, indexed by channel.
257 -1 means empty (no char is buffered).
258 Used on sys V where the only way to tell if there is any
259 output from the process is to read at least one char.
260 Always -1 on systems that support FIONREAD. */
262 /* Don't make static; need to access externally. */
263 int proc_buffered_char
[MAXDESC
];
265 /* Table of `struct coding-system' for each process. */
266 static struct coding_system
*proc_decode_coding_system
[MAXDESC
];
267 static struct coding_system
*proc_encode_coding_system
[MAXDESC
];
269 static Lisp_Object
get_process ();
271 extern EMACS_TIME
timer_check ();
272 extern int timers_run
;
274 /* Maximum number of bytes to send to a pty without an eof. */
275 static int pty_max_bytes
;
277 extern Lisp_Object Vfile_name_coding_system
, Vdefault_file_name_coding_system
;
280 /* The file name of the pty opened by allocate_pty. */
282 static char pty_name
[24];
285 /* Compute the Lisp form of the process status, p->status, from
286 the numeric status that was returned by `wait'. */
288 Lisp_Object
status_convert ();
292 struct Lisp_Process
*p
;
294 union { int i
; WAITTYPE wt
; } u
;
295 u
.i
= XFASTINT (p
->raw_status_low
) + (XFASTINT (p
->raw_status_high
) << 16);
296 p
->status
= status_convert (u
.wt
);
297 p
->raw_status_low
= Qnil
;
298 p
->raw_status_high
= Qnil
;
301 /* Convert a process status word in Unix format to
302 the list that we use internally. */
309 return Fcons (Qstop
, Fcons (make_number (WSTOPSIG (w
)), Qnil
));
310 else if (WIFEXITED (w
))
311 return Fcons (Qexit
, Fcons (make_number (WRETCODE (w
)),
312 WCOREDUMP (w
) ? Qt
: Qnil
));
313 else if (WIFSIGNALED (w
))
314 return Fcons (Qsignal
, Fcons (make_number (WTERMSIG (w
)),
315 WCOREDUMP (w
) ? Qt
: Qnil
));
320 /* Given a status-list, extract the three pieces of information
321 and store them individually through the three pointers. */
324 decode_status (l
, symbol
, code
, coredump
)
342 *code
= XFASTINT (XCAR (tem
));
344 *coredump
= !NILP (tem
);
348 /* Return a string describing a process status list. */
351 status_message (status
)
356 Lisp_Object string
, string2
;
358 decode_status (status
, &symbol
, &code
, &coredump
);
360 if (EQ (symbol
, Qsignal
) || EQ (symbol
, Qstop
))
363 synchronize_messages_locale ();
364 signame
= strsignal (code
);
367 string
= build_string (signame
);
368 string2
= build_string (coredump
? " (core dumped)\n" : "\n");
369 XSTRING (string
)->data
[0] = DOWNCASE (XSTRING (string
)->data
[0]);
370 return concat2 (string
, string2
);
372 else if (EQ (symbol
, Qexit
))
375 return build_string ("finished\n");
376 string
= Fnumber_to_string (make_number (code
));
377 string2
= build_string (coredump
? " (core dumped)\n" : "\n");
378 return concat2 (build_string ("exited abnormally with code "),
379 concat2 (string
, string2
));
382 return Fcopy_sequence (Fsymbol_name (symbol
));
387 /* Open an available pty, returning a file descriptor.
388 Return -1 on failure.
389 The file name of the terminal corresponding to the pty
390 is left in the variable pty_name. */
399 /* Some systems name their pseudoterminals so that there are gaps in
400 the usual sequence - for example, on HP9000/S700 systems, there
401 are no pseudoterminals with names ending in 'f'. So we wait for
402 three failures in a row before deciding that we've reached the
404 int failed_count
= 0;
409 for (c
= FIRST_PTY_LETTER
; c
<= 'z'; c
++)
410 for (i
= 0; i
< 16; i
++)
413 #ifdef PTY_NAME_SPRINTF
416 sprintf (pty_name
, "/dev/pty%c%x", c
, i
);
417 #endif /* no PTY_NAME_SPRINTF */
421 #else /* no PTY_OPEN */
423 /* Unusual IRIS code */
424 *ptyv
= emacs_open ("/dev/ptc", O_RDWR
| O_NDELAY
, 0);
427 if (fstat (fd
, &stb
) < 0)
430 if (stat (pty_name
, &stb
) < 0)
433 if (failed_count
>= 3)
439 fd
= emacs_open (pty_name
, O_RDWR
| O_NONBLOCK
, 0);
441 fd
= emacs_open (pty_name
, O_RDWR
| O_NDELAY
, 0);
443 #endif /* not IRIS */
444 #endif /* no PTY_OPEN */
448 /* check to make certain that both sides are available
449 this avoids a nasty yet stupid bug in rlogins */
450 #ifdef PTY_TTY_NAME_SPRINTF
453 sprintf (pty_name
, "/dev/tty%c%x", c
, i
);
454 #endif /* no PTY_TTY_NAME_SPRINTF */
456 if (access (pty_name
, 6) != 0)
459 #if !defined(IRIS) && !defined(__sgi)
465 #endif /* not UNIPLUS */
472 #endif /* HAVE_PTYS */
478 struct Lisp_Vector
*vec
;
479 register Lisp_Object val
, tem
, name1
;
480 register struct Lisp_Process
*p
;
484 vec
= allocate_vectorlike ((EMACS_INT
) VECSIZE (struct Lisp_Process
));
485 for (i
= 0; i
< VECSIZE (struct Lisp_Process
); i
++)
486 vec
->contents
[i
] = Qnil
;
487 vec
->size
= VECSIZE (struct Lisp_Process
);
488 p
= (struct Lisp_Process
*)vec
;
490 XSETINT (p
->infd
, -1);
491 XSETINT (p
->outfd
, -1);
492 XSETFASTINT (p
->pid
, 0);
493 XSETFASTINT (p
->tick
, 0);
494 XSETFASTINT (p
->update_tick
, 0);
495 p
->raw_status_low
= Qnil
;
496 p
->raw_status_high
= Qnil
;
498 p
->mark
= Fmake_marker ();
500 /* If name is already in use, modify it until it is unused. */
505 tem
= Fget_process (name1
);
506 if (NILP (tem
)) break;
507 sprintf (suffix
, "<%d>", i
);
508 name1
= concat2 (name
, build_string (suffix
));
512 XSETPROCESS (val
, p
);
513 Vprocess_alist
= Fcons (Fcons (name
, val
), Vprocess_alist
);
518 remove_process (proc
)
519 register Lisp_Object proc
;
521 register Lisp_Object pair
;
523 pair
= Frassq (proc
, Vprocess_alist
);
524 Vprocess_alist
= Fdelq (pair
, Vprocess_alist
);
526 deactivate_process (proc
);
529 DEFUN ("processp", Fprocessp
, Sprocessp
, 1, 1, 0,
530 "Return t if OBJECT is a process.")
534 return PROCESSP (object
) ? Qt
: Qnil
;
537 DEFUN ("get-process", Fget_process
, Sget_process
, 1, 1, 0,
538 "Return the process named NAME, or nil if there is none.")
540 register Lisp_Object name
;
544 CHECK_STRING (name
, 0);
545 return Fcdr (Fassoc (name
, Vprocess_alist
));
548 DEFUN ("get-buffer-process", Fget_buffer_process
, Sget_buffer_process
, 1, 1, 0,
549 "Return the (or a) process associated with BUFFER.\n\
550 BUFFER may be a buffer or the name of one.")
552 register Lisp_Object buffer
;
554 register Lisp_Object buf
, tail
, proc
;
556 if (NILP (buffer
)) return Qnil
;
557 buf
= Fget_buffer (buffer
);
558 if (NILP (buf
)) return Qnil
;
560 for (tail
= Vprocess_alist
; !NILP (tail
); tail
= Fcdr (tail
))
562 proc
= Fcdr (Fcar (tail
));
563 if (PROCESSP (proc
) && EQ (XPROCESS (proc
)->buffer
, buf
))
569 /* This is how commands for the user decode process arguments. It
570 accepts a process, a process name, a buffer, a buffer name, or nil.
571 Buffers denote the first process in the buffer, and nil denotes the
576 register Lisp_Object name
;
578 register Lisp_Object proc
, obj
;
581 obj
= Fget_process (name
);
583 obj
= Fget_buffer (name
);
585 error ("Process %s does not exist", XSTRING (name
)->data
);
587 else if (NILP (name
))
588 obj
= Fcurrent_buffer ();
592 /* Now obj should be either a buffer object or a process object.
596 proc
= Fget_buffer_process (obj
);
598 error ("Buffer %s has no process", XSTRING (XBUFFER (obj
)->name
)->data
);
602 CHECK_PROCESS (obj
, 0);
608 DEFUN ("delete-process", Fdelete_process
, Sdelete_process
, 1, 1, 0,
609 "Delete PROCESS: kill it and forget about it immediately.\n\
610 PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
611 nil, indicating the current buffer's process.")
613 register Lisp_Object process
;
615 process
= get_process (process
);
616 XPROCESS (process
)->raw_status_low
= Qnil
;
617 XPROCESS (process
)->raw_status_high
= Qnil
;
618 if (NETCONN_P (process
))
620 XPROCESS (process
)->status
= Fcons (Qexit
, Fcons (make_number (0), Qnil
));
621 XSETINT (XPROCESS (process
)->tick
, ++process_tick
);
623 else if (XINT (XPROCESS (process
)->infd
) >= 0)
625 Fkill_process (process
, Qnil
);
626 /* Do this now, since remove_process will make sigchld_handler do nothing. */
627 XPROCESS (process
)->status
628 = Fcons (Qsignal
, Fcons (make_number (SIGKILL
), Qnil
));
629 XSETINT (XPROCESS (process
)->tick
, ++process_tick
);
632 remove_process (process
);
636 DEFUN ("process-status", Fprocess_status
, Sprocess_status
, 1, 1, 0,
637 "Return the status of PROCESS.\n\
638 The returned value is one of the following symbols:\n\
639 run -- for a process that is running.\n\
640 stop -- for a process stopped but continuable.\n\
641 exit -- for a process that has exited.\n\
642 signal -- for a process that has got a fatal signal.\n\
643 open -- for a network stream connection that is open.\n\
644 closed -- for a network stream connection that is closed.\n\
645 nil -- if arg is a process name and no such process exists.\n\
646 PROCESS may be a process, a buffer, the name of a process, or\n\
647 nil, indicating the current buffer's process.")
649 register Lisp_Object process
;
651 register struct Lisp_Process
*p
;
652 register Lisp_Object status
;
654 if (STRINGP (process
))
655 process
= Fget_process (process
);
657 process
= get_process (process
);
662 p
= XPROCESS (process
);
663 if (!NILP (p
->raw_status_low
))
667 status
= XCAR (status
);
668 if (NETCONN_P (process
))
670 if (EQ (status
, Qrun
))
672 else if (EQ (status
, Qexit
))
678 DEFUN ("process-exit-status", Fprocess_exit_status
, Sprocess_exit_status
,
680 "Return the exit status of PROCESS or the signal number that killed it.\n\
681 If PROCESS has not yet exited or died, return 0.")
683 register Lisp_Object process
;
685 CHECK_PROCESS (process
, 0);
686 if (!NILP (XPROCESS (process
)->raw_status_low
))
687 update_status (XPROCESS (process
));
688 if (CONSP (XPROCESS (process
)->status
))
689 return XCAR (XCDR (XPROCESS (process
)->status
));
690 return make_number (0);
693 DEFUN ("process-id", Fprocess_id
, Sprocess_id
, 1, 1, 0,
694 "Return the process id of PROCESS.\n\
695 This is the pid of the Unix process which PROCESS uses or talks to.\n\
696 For a network connection, this value is nil.")
698 register Lisp_Object process
;
700 CHECK_PROCESS (process
, 0);
701 return XPROCESS (process
)->pid
;
704 DEFUN ("process-name", Fprocess_name
, Sprocess_name
, 1, 1, 0,
705 "Return the name of PROCESS, as a string.\n\
706 This is the name of the program invoked in PROCESS,\n\
707 possibly modified to make it unique among process names.")
709 register Lisp_Object process
;
711 CHECK_PROCESS (process
, 0);
712 return XPROCESS (process
)->name
;
715 DEFUN ("process-command", Fprocess_command
, Sprocess_command
, 1, 1, 0,
716 "Return the command that was executed to start PROCESS.\n\
717 This is a list of strings, the first string being the program executed\n\
718 and the rest of the strings being the arguments given to it.\n\
719 For a non-child channel, this is nil.")
721 register Lisp_Object process
;
723 CHECK_PROCESS (process
, 0);
724 return XPROCESS (process
)->command
;
727 DEFUN ("process-tty-name", Fprocess_tty_name
, Sprocess_tty_name
, 1, 1, 0,
728 "Return the name of the terminal PROCESS uses, or nil if none.\n\
729 This is the terminal that the process itself reads and writes on,\n\
730 not the name of the pty that Emacs uses to talk with that terminal.")
732 register Lisp_Object process
;
734 CHECK_PROCESS (process
, 0);
735 return XPROCESS (process
)->tty_name
;
738 DEFUN ("set-process-buffer", Fset_process_buffer
, Sset_process_buffer
,
740 "Set buffer associated with PROCESS to BUFFER (a buffer, or nil).")
742 register Lisp_Object process
, buffer
;
744 CHECK_PROCESS (process
, 0);
746 CHECK_BUFFER (buffer
, 1);
747 XPROCESS (process
)->buffer
= buffer
;
751 DEFUN ("process-buffer", Fprocess_buffer
, Sprocess_buffer
,
753 "Return the buffer PROCESS is associated with.\n\
754 Output from PROCESS is inserted in this buffer unless PROCESS has a filter.")
756 register Lisp_Object process
;
758 CHECK_PROCESS (process
, 0);
759 return XPROCESS (process
)->buffer
;
762 DEFUN ("process-mark", Fprocess_mark
, Sprocess_mark
,
764 "Return the marker for the end of the last output from PROCESS.")
766 register Lisp_Object process
;
768 CHECK_PROCESS (process
, 0);
769 return XPROCESS (process
)->mark
;
772 DEFUN ("set-process-filter", Fset_process_filter
, Sset_process_filter
,
774 "Give PROCESS the filter function FILTER; nil means no filter.\n\
775 t means stop accepting output from the process.\n\
776 When a process has a filter, each time it does output\n\
777 the entire string of output is passed to the filter.\n\
778 The filter gets two arguments: the process and the string of output.\n\
779 If the process has a filter, its buffer is not used for output.")
781 register Lisp_Object process
, filter
;
783 CHECK_PROCESS (process
, 0);
786 FD_CLR (XINT (XPROCESS (process
)->infd
), &input_wait_mask
);
787 FD_CLR (XINT (XPROCESS (process
)->infd
), &non_keyboard_wait_mask
);
789 else if (EQ (XPROCESS (process
)->filter
, Qt
))
791 FD_SET (XINT (XPROCESS (process
)->infd
), &input_wait_mask
);
792 FD_SET (XINT (XPROCESS (process
)->infd
), &non_keyboard_wait_mask
);
794 XPROCESS (process
)->filter
= filter
;
798 DEFUN ("process-filter", Fprocess_filter
, Sprocess_filter
,
800 "Returns the filter function of PROCESS; nil if none.\n\
801 See `set-process-filter' for more info on filter functions.")
803 register Lisp_Object process
;
805 CHECK_PROCESS (process
, 0);
806 return XPROCESS (process
)->filter
;
809 DEFUN ("set-process-sentinel", Fset_process_sentinel
, Sset_process_sentinel
,
811 "Give PROCESS the sentinel SENTINEL; nil for none.\n\
812 The sentinel is called as a function when the process changes state.\n\
813 It gets two arguments: the process, and a string describing the change.")
815 register Lisp_Object process
, sentinel
;
817 CHECK_PROCESS (process
, 0);
818 XPROCESS (process
)->sentinel
= sentinel
;
822 DEFUN ("process-sentinel", Fprocess_sentinel
, Sprocess_sentinel
,
824 "Return the sentinel of PROCESS; nil if none.\n\
825 See `set-process-sentinel' for more info on sentinels.")
827 register Lisp_Object process
;
829 CHECK_PROCESS (process
, 0);
830 return XPROCESS (process
)->sentinel
;
833 DEFUN ("set-process-window-size", Fset_process_window_size
,
834 Sset_process_window_size
, 3, 3, 0,
835 "Tell PROCESS that it has logical window size HEIGHT and WIDTH.")
836 (process
, height
, width
)
837 register Lisp_Object process
, height
, width
;
839 CHECK_PROCESS (process
, 0);
840 CHECK_NATNUM (height
, 0);
841 CHECK_NATNUM (width
, 0);
842 if (set_window_size (XINT (XPROCESS (process
)->infd
),
843 XINT (height
), XINT (width
)) <= 0)
849 DEFUN ("set-process-inherit-coding-system-flag",
850 Fset_process_inherit_coding_system_flag
,
851 Sset_process_inherit_coding_system_flag
, 2, 2, 0,
852 "Determine whether buffer of PROCESS will inherit coding-system.\n\
853 If the second argument FLAG is non-nil, then the variable\n\
854 `buffer-file-coding-system' of the buffer associated with PROCESS\n\
855 will be bound to the value of the coding system used to decode\n\
856 the process output.\n\
858 This is useful when the coding system specified for the process buffer\n\
859 leaves either the character code conversion or the end-of-line conversion\n\
860 unspecified, or if the coding system used to decode the process output\n\
861 is more appropriate for saving the process buffer.\n\
863 Binding the variable `inherit-process-coding-system' to non-nil before\n\
864 starting the process is an alternative way of setting the inherit flag\n\
865 for the process which will run.")
867 register Lisp_Object process
, flag
;
869 CHECK_PROCESS (process
, 0);
870 XPROCESS (process
)->inherit_coding_system_flag
= flag
;
874 DEFUN ("process-inherit-coding-system-flag",
875 Fprocess_inherit_coding_system_flag
, Sprocess_inherit_coding_system_flag
,
877 "Return the value of inherit-coding-system flag for PROCESS.\n\
878 If this flag is t, `buffer-file-coding-system' of the buffer\n\
879 associated with PROCESS will inherit the coding system used to decode\n\
880 the process output.")
882 register Lisp_Object process
;
884 CHECK_PROCESS (process
, 0);
885 return XPROCESS (process
)->inherit_coding_system_flag
;
888 DEFUN ("process-kill-without-query", Fprocess_kill_without_query
,
889 Sprocess_kill_without_query
, 1, 2, 0,
890 "Say no query needed if PROCESS is running when Emacs is exited.\n\
891 Optional second argument if non-nil says to require a query.\n\
892 Value is t if a query was formerly required.")
894 register Lisp_Object process
, value
;
898 CHECK_PROCESS (process
, 0);
899 tem
= XPROCESS (process
)->kill_without_query
;
900 XPROCESS (process
)->kill_without_query
= Fnull (value
);
905 DEFUN ("process-contact", Fprocess_contact
, Sprocess_contact
,
907 "Return the contact info of PROCESS; t for a real child.\n\
908 For a net connection, the value is a cons cell of the form (HOST SERVICE).")
910 register Lisp_Object process
;
912 CHECK_PROCESS (process
, 0);
913 return XPROCESS (process
)->childp
;
916 #if 0 /* Turned off because we don't currently record this info
917 in the process. Perhaps add it. */
918 DEFUN ("process-connection", Fprocess_connection
, Sprocess_connection
, 1, 1, 0,
919 "Return the connection type of PROCESS.\n\
920 The value is nil for a pipe, t or `pty' for a pty, or `stream' for\n\
921 a socket connection.")
925 return XPROCESS (process
)->type
;
932 register Lisp_Object tail
, tem
;
933 Lisp_Object proc
, minspace
, tem1
;
934 register struct Lisp_Process
*p
;
937 XSETFASTINT (minspace
, 1);
939 set_buffer_internal (XBUFFER (Vstandard_output
));
940 Fbuffer_disable_undo (Vstandard_output
);
942 current_buffer
->truncate_lines
= Qt
;
945 Proc Status Buffer Tty Command\n\
946 ---- ------ ------ --- -------\n", -1);
948 for (tail
= Vprocess_alist
; !NILP (tail
); tail
= Fcdr (tail
))
952 proc
= Fcdr (Fcar (tail
));
954 if (NILP (p
->childp
))
957 Finsert (1, &p
->name
);
958 Findent_to (make_number (13), minspace
);
960 if (!NILP (p
->raw_status_low
))
963 if (CONSP (p
->status
))
964 symbol
= XCAR (p
->status
);
967 if (EQ (symbol
, Qsignal
))
970 tem
= Fcar (Fcdr (p
->status
));
972 if (XINT (tem
) < NSIG
)
973 write_string (sys_errlist
[XINT (tem
)], -1);
976 Fprinc (symbol
, Qnil
);
978 else if (NETCONN_P (proc
))
980 if (EQ (symbol
, Qrun
))
981 write_string ("open", -1);
982 else if (EQ (symbol
, Qexit
))
983 write_string ("closed", -1);
985 Fprinc (symbol
, Qnil
);
988 Fprinc (symbol
, Qnil
);
990 if (EQ (symbol
, Qexit
))
993 tem
= Fcar (Fcdr (p
->status
));
996 sprintf (tembuf
, " %d", (int) XFASTINT (tem
));
997 write_string (tembuf
, -1);
1001 if (EQ (symbol
, Qsignal
) || EQ (symbol
, Qexit
))
1002 remove_process (proc
);
1004 Findent_to (make_number (22), minspace
);
1005 if (NILP (p
->buffer
))
1006 insert_string ("(none)");
1007 else if (NILP (XBUFFER (p
->buffer
)->name
))
1008 insert_string ("(Killed)");
1010 Finsert (1, &XBUFFER (p
->buffer
)->name
);
1012 Findent_to (make_number (37), minspace
);
1014 if (STRINGP (p
->tty_name
))
1015 Finsert (1, &p
->tty_name
);
1017 insert_string ("(none)");
1019 Findent_to (make_number (49), minspace
);
1021 if (NETCONN_P (proc
))
1023 sprintf (tembuf
, "(network stream connection to %s)\n",
1024 XSTRING (XCAR (p
->childp
))->data
);
1025 insert_string (tembuf
);
1037 insert_string (" ");
1039 insert_string ("\n");
1045 DEFUN ("list-processes", Flist_processes
, Slist_processes
, 0, 0, "",
1046 "Display a list of all processes.\n\
1047 Any process listed as exited or signaled is actually eliminated\n\
1048 after the listing is made.")
1051 internal_with_output_to_temp_buffer ("*Process List*",
1052 list_processes_1
, Qnil
);
1056 DEFUN ("process-list", Fprocess_list
, Sprocess_list
, 0, 0, 0,
1057 "Return a list of all processes.")
1060 return Fmapcar (Qcdr
, Vprocess_alist
);
1063 /* Starting asynchronous inferior processes. */
1065 static Lisp_Object
start_process_unwind ();
1067 DEFUN ("start-process", Fstart_process
, Sstart_process
, 3, MANY
, 0,
1068 "Start a program in a subprocess. Return the process object for it.\n\
1069 Args are NAME BUFFER PROGRAM &rest PROGRAM-ARGS\n\
1070 NAME is name for process. It is modified if necessary to make it unique.\n\
1071 BUFFER is the buffer or (buffer-name) to associate with the process.\n\
1072 Process output goes at end of that buffer, unless you specify\n\
1073 an output stream or filter function to handle the output.\n\
1074 BUFFER may be also nil, meaning that this process is not associated\n\
1076 Third arg is program file name. It is searched for in PATH.\n\
1077 Remaining arguments are strings to give program as arguments.")
1080 register Lisp_Object
*args
;
1082 Lisp_Object buffer
, name
, program
, proc
, current_dir
, tem
;
1084 register unsigned char *new_argv
;
1087 register unsigned char **new_argv
;
1090 int count
= specpdl_ptr
- specpdl
;
1094 buffer
= Fget_buffer_create (buffer
);
1096 /* Make sure that the child will be able to chdir to the current
1097 buffer's current directory, or its unhandled equivalent. We
1098 can't just have the child check for an error when it does the
1099 chdir, since it's in a vfork.
1101 We have to GCPRO around this because Fexpand_file_name and
1102 Funhandled_file_name_directory might call a file name handling
1103 function. The argument list is protected by the caller, so all
1104 we really have to worry about is buffer. */
1106 struct gcpro gcpro1
, gcpro2
;
1108 current_dir
= current_buffer
->directory
;
1110 GCPRO2 (buffer
, current_dir
);
1113 = expand_and_dir_to_file (Funhandled_file_name_directory (current_dir
),
1115 if (NILP (Ffile_accessible_directory_p (current_dir
)))
1116 report_file_error ("Setting current directory",
1117 Fcons (current_buffer
->directory
, Qnil
));
1123 CHECK_STRING (name
, 0);
1127 CHECK_STRING (program
, 2);
1130 /* Make a one member argv with all args concatenated
1131 together separated by a blank. */
1132 len
= STRING_BYTES (XSTRING (program
)) + 2;
1133 for (i
= 3; i
< nargs
; i
++)
1136 CHECK_STRING (tem
, i
);
1137 len
+= STRING_BYTES (XSTRING (tem
)) + 1; /* count the blank */
1139 new_argv
= (unsigned char *) alloca (len
);
1140 strcpy (new_argv
, XSTRING (program
)->data
);
1141 for (i
= 3; i
< nargs
; i
++)
1144 CHECK_STRING (tem
, i
);
1145 strcat (new_argv
, " ");
1146 strcat (new_argv
, XSTRING (tem
)->data
);
1148 /* Need to add code here to check for program existence on VMS */
1151 new_argv
= (unsigned char **) alloca ((nargs
- 1) * sizeof (char *));
1153 /* If program file name is not absolute, search our path for it */
1154 if (!IS_DIRECTORY_SEP (XSTRING (program
)->data
[0])
1155 && !(XSTRING (program
)->size
> 1
1156 && IS_DEVICE_SEP (XSTRING (program
)->data
[1])))
1158 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1161 GCPRO4 (name
, program
, buffer
, current_dir
);
1162 openp (Vexec_path
, program
, EXEC_SUFFIXES
, &tem
, 1);
1165 report_file_error ("Searching for program", Fcons (program
, Qnil
));
1166 tem
= Fexpand_file_name (tem
, Qnil
);
1167 new_argv
[0] = XSTRING (tem
)->data
;
1171 if (!NILP (Ffile_directory_p (program
)))
1172 error ("Specified program for new process is a directory");
1174 new_argv
[0] = XSTRING (program
)->data
;
1177 for (i
= 3; i
< nargs
; i
++)
1180 CHECK_STRING (tem
, i
);
1181 new_argv
[i
- 2] = XSTRING (tem
)->data
;
1183 new_argv
[i
- 2] = 0;
1184 #endif /* not VMS */
1186 proc
= make_process (name
);
1187 /* If an error occurs and we can't start the process, we want to
1188 remove it from the process list. This means that each error
1189 check in create_process doesn't need to call remove_process
1190 itself; it's all taken care of here. */
1191 record_unwind_protect (start_process_unwind
, proc
);
1193 XPROCESS (proc
)->childp
= Qt
;
1194 XPROCESS (proc
)->command_channel_p
= Qnil
;
1195 XPROCESS (proc
)->buffer
= buffer
;
1196 XPROCESS (proc
)->sentinel
= Qnil
;
1197 XPROCESS (proc
)->filter
= Qnil
;
1198 XPROCESS (proc
)->command
= Flist (nargs
- 2, args
+ 2);
1200 /* Make the process marker point into the process buffer (if any). */
1202 set_marker_both (XPROCESS (proc
)->mark
, buffer
,
1203 BUF_ZV (XBUFFER (buffer
)),
1204 BUF_ZV_BYTE (XBUFFER (buffer
)));
1207 /* Decide coding systems for communicating with the process. Here
1208 we don't setup the structure coding_system nor pay attention to
1209 unibyte mode. They are done in create_process. */
1211 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
1212 Lisp_Object coding_systems
= Qt
;
1213 Lisp_Object val
, *args2
;
1214 struct gcpro gcpro1
;
1216 val
= Vcoding_system_for_read
;
1219 args2
= (Lisp_Object
*) alloca ((nargs
+ 1) * sizeof *args2
);
1220 args2
[0] = Qstart_process
;
1221 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
1223 coding_systems
= Ffind_operation_coding_system (nargs
+ 1, args2
);
1225 if (CONSP (coding_systems
))
1226 val
= XCAR (coding_systems
);
1227 else if (CONSP (Vdefault_process_coding_system
))
1228 val
= XCAR (Vdefault_process_coding_system
);
1230 XPROCESS (proc
)->decode_coding_system
= val
;
1232 val
= Vcoding_system_for_write
;
1235 if (EQ (coding_systems
, Qt
))
1237 args2
= (Lisp_Object
*) alloca ((nargs
+ 1) * sizeof args2
);
1238 args2
[0] = Qstart_process
;
1239 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
1241 coding_systems
= Ffind_operation_coding_system (nargs
+ 1, args2
);
1244 if (CONSP (coding_systems
))
1245 val
= XCDR (coding_systems
);
1246 else if (CONSP (Vdefault_process_coding_system
))
1247 val
= XCDR (Vdefault_process_coding_system
);
1249 XPROCESS (proc
)->encode_coding_system
= val
;
1252 XPROCESS (proc
)->decoding_buf
= make_uninit_string (0);
1253 XPROCESS (proc
)->decoding_carryover
= make_number (0);
1254 XPROCESS (proc
)->encoding_buf
= make_uninit_string (0);
1255 XPROCESS (proc
)->encoding_carryover
= make_number (0);
1257 XPROCESS (proc
)->inherit_coding_system_flag
1258 = (NILP (buffer
) || !inherit_process_coding_system
1261 create_process (proc
, (char **) new_argv
, current_dir
);
1263 return unbind_to (count
, proc
);
1266 /* This function is the unwind_protect form for Fstart_process. If
1267 PROC doesn't have its pid set, then we know someone has signaled
1268 an error and the process wasn't started successfully, so we should
1269 remove it from the process list. */
1271 start_process_unwind (proc
)
1274 if (!PROCESSP (proc
))
1277 /* Was PROC started successfully? */
1278 if (XINT (XPROCESS (proc
)->pid
) <= 0)
1279 remove_process (proc
);
1286 create_process_1 (signo
)
1289 #if defined (USG) && !defined (POSIX_SIGNALS)
1290 /* USG systems forget handlers when they are used;
1291 must reestablish each time */
1292 signal (signo
, create_process_1
);
1296 #if 0 /* This doesn't work; see the note before sigchld_handler. */
1299 /* Mimic blocking of signals on system V, which doesn't really have it. */
1301 /* Nonzero means we got a SIGCHLD when it was supposed to be blocked. */
1302 int sigchld_deferred
;
1305 create_process_sigchld ()
1307 signal (SIGCHLD
, create_process_sigchld
);
1309 sigchld_deferred
= 1;
1315 #ifndef VMS /* VMS version of this function is in vmsproc.c. */
1317 create_process (process
, new_argv
, current_dir
)
1318 Lisp_Object process
;
1320 Lisp_Object current_dir
;
1322 int pid
, inchannel
, outchannel
;
1324 #ifdef POSIX_SIGNALS
1327 struct sigaction sigint_action
;
1328 struct sigaction sigquit_action
;
1330 struct sigaction sighup_action
;
1332 #else /* !POSIX_SIGNALS */
1335 SIGTYPE (*sigchld
)();
1338 #endif /* !POSIX_SIGNALS */
1339 /* Use volatile to protect variables from being clobbered by longjmp. */
1340 volatile int forkin
, forkout
;
1341 volatile int pty_flag
= 0;
1342 extern char **environ
;
1343 Lisp_Object buffer
= XPROCESS (process
)->buffer
;
1345 inchannel
= outchannel
= -1;
1348 if (!NILP (Vprocess_connection_type
))
1349 outchannel
= inchannel
= allocate_pty ();
1354 /* On USG systems it does not work to open the pty's tty here
1355 and then close and reopen it in the child. */
1357 /* Don't let this terminal become our controlling terminal
1358 (in case we don't have one). */
1359 forkout
= forkin
= emacs_open (pty_name
, O_RDWR
| O_NOCTTY
, 0);
1361 forkout
= forkin
= emacs_open (pty_name
, O_RDWR
, 0);
1364 report_file_error ("Opening pty", Qnil
);
1366 forkin
= forkout
= -1;
1367 #endif /* not USG */
1371 #endif /* HAVE_PTYS */
1374 if (socketpair (AF_UNIX
, SOCK_STREAM
, 0, sv
) < 0)
1375 report_file_error ("Opening socketpair", Qnil
);
1376 outchannel
= inchannel
= sv
[0];
1377 forkout
= forkin
= sv
[1];
1379 #else /* not SKTPAIR */
1384 report_file_error ("Creating pipe", Qnil
);
1390 emacs_close (inchannel
);
1391 emacs_close (forkout
);
1392 report_file_error ("Creating pipe", Qnil
);
1397 #endif /* not SKTPAIR */
1400 /* Replaced by close_process_descs */
1401 set_exclusive_use (inchannel
);
1402 set_exclusive_use (outchannel
);
1405 /* Stride people say it's a mystery why this is needed
1406 as well as the O_NDELAY, but that it fails without this. */
1407 #if defined (STRIDE) || (defined (pfa) && defined (HAVE_PTYS))
1410 ioctl (inchannel
, FIONBIO
, &one
);
1415 fcntl (inchannel
, F_SETFL
, O_NONBLOCK
);
1416 fcntl (outchannel
, F_SETFL
, O_NONBLOCK
);
1419 fcntl (inchannel
, F_SETFL
, O_NDELAY
);
1420 fcntl (outchannel
, F_SETFL
, O_NDELAY
);
1424 /* Record this as an active process, with its channels.
1425 As a result, child_setup will close Emacs's side of the pipes. */
1426 chan_process
[inchannel
] = process
;
1427 XSETINT (XPROCESS (process
)->infd
, inchannel
);
1428 XSETINT (XPROCESS (process
)->outfd
, outchannel
);
1429 /* Record the tty descriptor used in the subprocess. */
1431 XPROCESS (process
)->subtty
= Qnil
;
1433 XSETFASTINT (XPROCESS (process
)->subtty
, forkin
);
1434 XPROCESS (process
)->pty_flag
= (pty_flag
? Qt
: Qnil
);
1435 XPROCESS (process
)->status
= Qrun
;
1436 if (!proc_decode_coding_system
[inchannel
])
1437 proc_decode_coding_system
[inchannel
]
1438 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
1439 setup_coding_system (XPROCESS (process
)->decode_coding_system
,
1440 proc_decode_coding_system
[inchannel
]);
1441 if (!proc_encode_coding_system
[outchannel
])
1442 proc_encode_coding_system
[outchannel
]
1443 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
1444 setup_coding_system (XPROCESS (process
)->encode_coding_system
,
1445 proc_encode_coding_system
[outchannel
]);
1447 if ((!NILP (buffer
) && NILP (XBUFFER (buffer
)->enable_multibyte_characters
))
1448 || (NILP (buffer
) && NILP (buffer_defaults
.enable_multibyte_characters
)))
1450 /* In unibyte mode, character code conversion should not take
1451 place but EOL conversion should. So, setup raw-text or one
1452 of the subsidiary according to the information just setup. */
1453 if (!NILP (XPROCESS (process
)->decode_coding_system
))
1454 setup_raw_text_coding_system (proc_decode_coding_system
[inchannel
]);
1455 if (!NILP (XPROCESS (process
)->encode_coding_system
))
1456 setup_raw_text_coding_system (proc_encode_coding_system
[outchannel
]);
1459 if (CODING_REQUIRE_ENCODING (proc_encode_coding_system
[outchannel
]))
1461 /* Here we encode arguments by the coding system used for
1462 sending data to the process. We don't support using
1463 different coding systems for encoding arguments and for
1464 encoding data sent to the process. */
1465 struct gcpro gcpro1
;
1467 struct coding_system
*coding
= proc_encode_coding_system
[outchannel
];
1469 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
1471 while (new_argv
[i
] != 0)
1473 int len
= strlen (new_argv
[i
]);
1474 int size
= encoding_buffer_size (coding
, len
);
1475 unsigned char *buf
= (unsigned char *) alloca (size
);
1477 encode_coding (coding
, (unsigned char *)new_argv
[i
], buf
, len
, size
);
1478 buf
[coding
->produced
] = 0;
1479 /* We don't have to free new_argv[i] because it points to a
1480 Lisp string given as an argument to `start-process'. */
1481 new_argv
[i
++] = (char *) buf
;
1484 coding
->mode
&= ~CODING_MODE_LAST_BLOCK
;
1487 /* Delay interrupts until we have a chance to store
1488 the new fork's pid in its process structure */
1489 #ifdef POSIX_SIGNALS
1490 sigemptyset (&blocked
);
1492 sigaddset (&blocked
, SIGCHLD
);
1495 /* On many hosts (e.g. Solaris 2.4), if a vforked child calls `signal',
1496 this sets the parent's signal handlers as well as the child's.
1497 So delay all interrupts whose handlers the child might munge,
1498 and record the current handlers so they can be restored later. */
1499 sigaddset (&blocked
, SIGINT
); sigaction (SIGINT
, 0, &sigint_action
);
1500 sigaddset (&blocked
, SIGQUIT
); sigaction (SIGQUIT
, 0, &sigquit_action
);
1502 sigaddset (&blocked
, SIGHUP
); sigaction (SIGHUP
, 0, &sighup_action
);
1504 #endif /* HAVE_VFORK */
1505 sigprocmask (SIG_BLOCK
, &blocked
, &procmask
);
1506 #else /* !POSIX_SIGNALS */
1510 #else /* not BSD4_1 */
1511 #if defined (BSD_SYSTEM) || defined (UNIPLUS) || defined (HPUX)
1512 sigsetmask (sigmask (SIGCHLD
));
1513 #else /* ordinary USG */
1515 sigchld_deferred
= 0;
1516 sigchld
= signal (SIGCHLD
, create_process_sigchld
);
1518 #endif /* ordinary USG */
1519 #endif /* not BSD4_1 */
1520 #endif /* SIGCHLD */
1521 #endif /* !POSIX_SIGNALS */
1523 FD_SET (inchannel
, &input_wait_mask
);
1524 FD_SET (inchannel
, &non_keyboard_wait_mask
);
1525 if (inchannel
> max_process_desc
)
1526 max_process_desc
= inchannel
;
1528 /* Until we store the proper pid, enable sigchld_handler
1529 to recognize an unknown pid as standing for this process.
1530 It is very important not to let this `marker' value stay
1531 in the table after this function has returned; if it does
1532 it might cause call-process to hang and subsequent asynchronous
1533 processes to get their return values scrambled. */
1534 XSETINT (XPROCESS (process
)->pid
, -1);
1539 /* child_setup must clobber environ on systems with true vfork.
1540 Protect it from permanent change. */
1541 char **save_environ
= environ
;
1543 current_dir
= ENCODE_FILE (current_dir
);
1548 #endif /* not WINDOWSNT */
1550 int xforkin
= forkin
;
1551 int xforkout
= forkout
;
1553 #if 0 /* This was probably a mistake--it duplicates code later on,
1554 but fails to handle all the cases. */
1555 /* Make sure SIGCHLD is not blocked in the child. */
1556 sigsetmask (SIGEMPTYMASK
);
1559 /* Make the pty be the controlling terminal of the process. */
1561 /* First, disconnect its current controlling terminal. */
1563 /* We tried doing setsid only if pty_flag, but it caused
1564 process_set_signal to fail on SGI when using a pipe. */
1566 /* Make the pty's terminal the controlling terminal. */
1570 /* We ignore the return value
1571 because faith@cs.unc.edu says that is necessary on Linux. */
1572 ioctl (xforkin
, TIOCSCTTY
, 0);
1575 #else /* not HAVE_SETSID */
1577 /* It's very important to call setpgrp here and no time
1578 afterwards. Otherwise, we lose our controlling tty which
1579 is set when we open the pty. */
1582 #endif /* not HAVE_SETSID */
1583 #if defined (HAVE_TERMIOS) && defined (LDISC1)
1584 if (pty_flag
&& xforkin
>= 0)
1587 tcgetattr (xforkin
, &t
);
1589 if (tcsetattr (xforkin
, TCSANOW
, &t
) < 0)
1590 emacs_write (1, "create_process/tcsetattr LDISC1 failed\n", 39);
1593 #if defined (NTTYDISC) && defined (TIOCSETD)
1594 if (pty_flag
&& xforkin
>= 0)
1596 /* Use new line discipline. */
1597 int ldisc
= NTTYDISC
;
1598 ioctl (xforkin
, TIOCSETD
, &ldisc
);
1603 /* In 4.3BSD, the TIOCSPGRP bug has been fixed, and now you
1604 can do TIOCSPGRP only to the process's controlling tty. */
1607 /* I wonder: would just ioctl (0, TIOCNOTTY, 0) work here?
1608 I can't test it since I don't have 4.3. */
1609 int j
= emacs_open ("/dev/tty", O_RDWR
, 0);
1610 ioctl (j
, TIOCNOTTY
, 0);
1613 /* In order to get a controlling terminal on some versions
1614 of BSD, it is necessary to put the process in pgrp 0
1615 before it opens the terminal. */
1623 #endif /* TIOCNOTTY */
1625 #if !defined (RTU) && !defined (UNIPLUS) && !defined (DONT_REOPEN_PTY)
1626 /*** There is a suggestion that this ought to be a
1627 conditional on TIOCSPGRP,
1628 or !(defined (HAVE_SETSID) && defined (TIOCSCTTY)).
1629 Trying the latter gave the wrong results on Debian GNU/Linux 1.1;
1630 that system does seem to need this code, even though
1631 both HAVE_SETSID and TIOCSCTTY are defined. */
1632 /* Now close the pty (if we had it open) and reopen it.
1633 This makes the pty the controlling terminal of the subprocess. */
1636 #ifdef SET_CHILD_PTY_PGRP
1637 int pgrp
= getpid ();
1640 /* I wonder if emacs_close (emacs_open (pty_name, ...))
1643 emacs_close (xforkin
);
1644 xforkout
= xforkin
= emacs_open (pty_name
, O_RDWR
, 0);
1648 emacs_write (1, "Couldn't open the pty terminal ", 31);
1649 emacs_write (1, pty_name
, strlen (pty_name
));
1650 emacs_write (1, "\n", 1);
1654 #ifdef SET_CHILD_PTY_PGRP
1655 ioctl (xforkin
, TIOCSPGRP
, &pgrp
);
1656 ioctl (xforkout
, TIOCSPGRP
, &pgrp
);
1659 #endif /* not UNIPLUS and not RTU and not DONT_REOPEN_PTY */
1661 #ifdef SETUP_SLAVE_PTY
1666 #endif /* SETUP_SLAVE_PTY */
1668 /* On AIX, we've disabled SIGHUP above once we start a child on a pty.
1669 Now reenable it in the child, so it will die when we want it to. */
1671 signal (SIGHUP
, SIG_DFL
);
1673 #endif /* HAVE_PTYS */
1675 signal (SIGINT
, SIG_DFL
);
1676 signal (SIGQUIT
, SIG_DFL
);
1678 /* Stop blocking signals in the child. */
1679 #ifdef POSIX_SIGNALS
1680 sigprocmask (SIG_SETMASK
, &procmask
, 0);
1681 #else /* !POSIX_SIGNALS */
1685 #else /* not BSD4_1 */
1686 #if defined (BSD_SYSTEM) || defined (UNIPLUS) || defined (HPUX)
1687 sigsetmask (SIGEMPTYMASK
);
1688 #else /* ordinary USG */
1690 signal (SIGCHLD
, sigchld
);
1692 #endif /* ordinary USG */
1693 #endif /* not BSD4_1 */
1694 #endif /* SIGCHLD */
1695 #endif /* !POSIX_SIGNALS */
1698 child_setup_tty (xforkout
);
1700 pid
= child_setup (xforkin
, xforkout
, xforkout
,
1701 new_argv
, 1, current_dir
);
1702 #else /* not WINDOWSNT */
1703 child_setup (xforkin
, xforkout
, xforkout
,
1704 new_argv
, 1, current_dir
);
1705 #endif /* not WINDOWSNT */
1707 environ
= save_environ
;
1712 /* This runs in the Emacs process. */
1716 emacs_close (forkin
);
1717 if (forkin
!= forkout
&& forkout
>= 0)
1718 emacs_close (forkout
);
1722 /* vfork succeeded. */
1723 XSETFASTINT (XPROCESS (process
)->pid
, pid
);
1726 register_child (pid
, inchannel
);
1727 #endif /* WINDOWSNT */
1729 /* If the subfork execv fails, and it exits,
1730 this close hangs. I don't know why.
1731 So have an interrupt jar it loose. */
1733 signal (SIGALRM
, create_process_1
);
1735 XPROCESS (process
)->subtty
= Qnil
;
1737 emacs_close (forkin
);
1740 if (forkin
!= forkout
&& forkout
>= 0)
1741 emacs_close (forkout
);
1745 XPROCESS (process
)->tty_name
= build_string (pty_name
);
1748 XPROCESS (process
)->tty_name
= Qnil
;
1751 /* Restore the signal state whether vfork succeeded or not.
1752 (We will signal an error, below, if it failed.) */
1753 #ifdef POSIX_SIGNALS
1755 /* Restore the parent's signal handlers. */
1756 sigaction (SIGINT
, &sigint_action
, 0);
1757 sigaction (SIGQUIT
, &sigquit_action
, 0);
1759 sigaction (SIGHUP
, &sighup_action
, 0);
1761 #endif /* HAVE_VFORK */
1762 /* Stop blocking signals in the parent. */
1763 sigprocmask (SIG_SETMASK
, &procmask
, 0);
1764 #else /* !POSIX_SIGNALS */
1768 #else /* not BSD4_1 */
1769 #if defined (BSD_SYSTEM) || defined (UNIPLUS) || defined (HPUX)
1770 sigsetmask (SIGEMPTYMASK
);
1771 #else /* ordinary USG */
1773 signal (SIGCHLD
, sigchld
);
1774 /* Now really handle any of these signals
1775 that came in during this function. */
1776 if (sigchld_deferred
)
1777 kill (getpid (), SIGCHLD
);
1779 #endif /* ordinary USG */
1780 #endif /* not BSD4_1 */
1781 #endif /* SIGCHLD */
1782 #endif /* !POSIX_SIGNALS */
1784 /* Now generate the error if vfork failed. */
1786 report_file_error ("Doing vfork", Qnil
);
1788 #endif /* not VMS */
1792 /* open a TCP network connection to a given HOST/SERVICE. Treated
1793 exactly like a normal process when reading and writing. Only
1794 differences are in status display and process deletion. A network
1795 connection has no PID; you cannot signal it. All you can do is
1796 deactivate and close it via delete-process */
1798 DEFUN ("open-network-stream", Fopen_network_stream
, Sopen_network_stream
,
1800 "Open a TCP connection for a service to a host.\n\
1801 Returns a subprocess-object to represent the connection.\n\
1802 Input and output work as for subprocesses; `delete-process' closes it.\n\
1803 Args are NAME BUFFER HOST SERVICE.\n\
1804 NAME is name for process. It is modified if necessary to make it unique.\n\
1805 BUFFER is the buffer (or buffer-name) to associate with the process.\n\
1806 Process output goes at end of that buffer, unless you specify\n\
1807 an output stream or filter function to handle the output.\n\
1808 BUFFER may be also nil, meaning that this process is not associated\n\
1810 Third arg is name of the host to connect to, or its IP address.\n\
1811 Fourth arg SERVICE is name of the service desired, or an integer\n\
1812 specifying a port number to connect to.")
1813 (name
, buffer
, host
, service
)
1814 Lisp_Object name
, buffer
, host
, service
;
1817 #ifndef HAVE_GETADDRINFO
1818 struct sockaddr_in address
;
1819 struct servent
*svc_info
;
1820 struct hostent
*host_info_ptr
, host_info
;
1821 char *(addr_list
[2]);
1822 IN_ADDR numeric_addr
;
1824 #else /* HAVE_GETADDRINFO */
1825 struct addrinfo hints
, *res
, *lres
;
1828 char *portstring
, portbuf
[128];
1829 #endif /* HAVE_GETADDRINFO */
1830 int s
= -1, outch
, inch
;
1831 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1833 int count
= specpdl_ptr
- specpdl
;
1837 /* Ensure socket support is loaded if available. */
1838 init_winsock (TRUE
);
1841 GCPRO4 (name
, buffer
, host
, service
);
1842 CHECK_STRING (name
, 0);
1843 CHECK_STRING (host
, 0);
1845 #ifdef HAVE_GETADDRINFO
1847 * SERVICE can either be a string or int.
1848 * Convert to a C string for later use by getaddrinfo.
1850 if (INTEGERP (service
))
1852 sprintf (portbuf
, "%d", XINT (service
));
1853 portstring
= portbuf
;
1857 CHECK_STRING (service
, 0);
1858 portstring
= XSTRING (service
)->data
;
1860 #else /* ! HAVE_GETADDRINFO */
1861 if (INTEGERP (service
))
1862 port
= htons ((unsigned short) XINT (service
));
1865 CHECK_STRING (service
, 0);
1866 svc_info
= getservbyname (XSTRING (service
)->data
, "tcp");
1868 error ("Unknown service \"%s\"", XSTRING (service
)->data
);
1869 port
= svc_info
->s_port
;
1871 #endif /* ! HAVE_GETADDRINFO */
1874 /* Slow down polling to every ten seconds.
1875 Some kernels have a bug which causes retrying connect to fail
1876 after a connect. Polling can interfere with gethostbyname too. */
1877 #ifdef POLL_FOR_INPUT
1878 bind_polling_period (10);
1882 #ifdef HAVE_GETADDRINFO
1886 memset (&hints
, 0, sizeof (hints
));
1888 hints
.ai_family
= AF_UNSPEC
;
1889 hints
.ai_socktype
= SOCK_STREAM
;
1890 hints
.ai_protocol
= 0;
1891 ret
= getaddrinfo (XSTRING (host
)->data
, portstring
, &hints
, &res
);
1894 error ("%s/%s %s", XSTRING (host
)->data
, portstring
,
1901 count1
= specpdl_ptr
- specpdl
;
1902 record_unwind_protect (close_file_unwind
, make_number (s
));
1904 for (lres
= res
; lres
; lres
= lres
->ai_next
)
1906 s
= socket (lres
->ai_family
, lres
->ai_socktype
, lres
->ai_protocol
);
1910 /* Kernel bugs (on Ultrix at least) cause lossage (not just EINTR)
1911 when connect is interrupted. So let's not let it get interrupted.
1912 Note we do not turn off polling, because polling is only used
1913 when not interrupt_input, and thus not normally used on the systems
1914 which have this bug. On systems which use polling, there's no way
1915 to quit if polling is turned off. */
1916 if (interrupt_input
)
1922 ret
= connect (s
, lres
->ai_addr
, lres
->ai_addrlen
);
1932 if (interrupt_input
)
1936 report_file_error ("connection failed",
1937 Fcons (host
, Fcons (name
, Qnil
)));
1939 #else /* ! HAVE_GETADDRINFO */
1950 host_info_ptr
= gethostbyname (XSTRING (host
)->data
);
1954 if (! (host_info_ptr
== 0 && h_errno
== TRY_AGAIN
))
1958 Fsleep_for (make_number (1), Qnil
);
1960 if (host_info_ptr
== 0)
1961 /* Attempt to interpret host as numeric inet address */
1963 numeric_addr
= inet_addr ((char *) XSTRING (host
)->data
);
1964 if (NUMERIC_ADDR_ERROR
)
1965 error ("Unknown host \"%s\"", XSTRING (host
)->data
);
1967 host_info_ptr
= &host_info
;
1968 host_info
.h_name
= 0;
1969 host_info
.h_aliases
= 0;
1970 host_info
.h_addrtype
= AF_INET
;
1972 /* Older machines have only one address slot called h_addr.
1973 Newer machines have h_addr_list, but #define h_addr to
1974 be its first element. */
1975 host_info
.h_addr_list
= &(addr_list
[0]);
1977 host_info
.h_addr
= (char*)(&numeric_addr
);
1979 /* numeric_addr isn't null-terminated; it has fixed length. */
1980 host_info
.h_length
= sizeof (numeric_addr
);
1983 bzero (&address
, sizeof address
);
1984 bcopy (host_info_ptr
->h_addr
, (char *) &address
.sin_addr
,
1985 host_info_ptr
->h_length
);
1986 address
.sin_family
= host_info_ptr
->h_addrtype
;
1987 address
.sin_port
= port
;
1989 s
= socket (host_info_ptr
->h_addrtype
, SOCK_STREAM
, 0);
1991 report_file_error ("error creating socket", Fcons (name
, Qnil
));
1993 count1
= specpdl_ptr
- specpdl
;
1994 record_unwind_protect (close_file_unwind
, make_number (s
));
1996 /* Kernel bugs (on Ultrix at least) cause lossage (not just EINTR)
1997 when connect is interrupted. So let's not let it get interrupted.
1998 Note we do not turn off polling, because polling is only used
1999 when not interrupt_input, and thus not normally used on the systems
2000 which have this bug. On systems which use polling, there's no way
2001 to quit if polling is turned off. */
2002 if (interrupt_input
)
2010 if (connect (s
, (struct sockaddr
*) &address
, sizeof address
) == -1
2011 && errno
!= EISCONN
)
2019 if (errno
== EADDRINUSE
&& retry
< 20)
2021 /* A delay here is needed on some FreeBSD systems,
2022 and it is harmless, since this retrying takes time anyway
2023 and should be infrequent. */
2024 Fsleep_for (make_number (1), Qnil
);
2029 /* Discard the unwind protect. */
2030 specpdl_ptr
= specpdl
+ count1
;
2034 if (interrupt_input
)
2038 report_file_error ("connection failed",
2039 Fcons (host
, Fcons (name
, Qnil
)));
2041 #endif /* ! HAVE_GETADDRINFO */
2045 /* Discard the unwind protect. */
2046 specpdl_ptr
= specpdl
+ count1
;
2048 #ifdef POLL_FOR_INPUT
2049 unbind_to (count
, Qnil
);
2052 if (interrupt_input
)
2056 s
= connect_server (0);
2058 report_file_error ("error creating socket", Fcons (name
, Qnil
));
2059 send_command (s
, C_PORT
, 0, "%s:%d", XSTRING (host
)->data
, ntohs (port
));
2060 send_command (s
, C_DUMB
, 1, 0);
2067 buffer
= Fget_buffer_create (buffer
);
2068 proc
= make_process (name
);
2070 chan_process
[inch
] = proc
;
2073 fcntl (inch
, F_SETFL
, O_NONBLOCK
);
2076 fcntl (inch
, F_SETFL
, O_NDELAY
);
2080 XPROCESS (proc
)->childp
= Fcons (host
, Fcons (service
, Qnil
));
2081 XPROCESS (proc
)->command_channel_p
= Qnil
;
2082 XPROCESS (proc
)->buffer
= buffer
;
2083 XPROCESS (proc
)->sentinel
= Qnil
;
2084 XPROCESS (proc
)->filter
= Qnil
;
2085 XPROCESS (proc
)->command
= Qnil
;
2086 XPROCESS (proc
)->pid
= Qnil
;
2087 XSETINT (XPROCESS (proc
)->infd
, inch
);
2088 XSETINT (XPROCESS (proc
)->outfd
, outch
);
2089 XPROCESS (proc
)->status
= Qrun
;
2090 FD_SET (inch
, &input_wait_mask
);
2091 FD_SET (inch
, &non_keyboard_wait_mask
);
2092 if (inch
> max_process_desc
)
2093 max_process_desc
= inch
;
2096 /* Setup coding systems for communicating with the network stream. */
2097 struct gcpro gcpro1
;
2098 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
2099 Lisp_Object coding_systems
= Qt
;
2100 Lisp_Object args
[5], val
;
2102 if (!NILP (Vcoding_system_for_read
))
2103 val
= Vcoding_system_for_read
;
2104 else if ((!NILP (buffer
) && NILP (XBUFFER (buffer
)->enable_multibyte_characters
))
2105 || (NILP (buffer
) && NILP (buffer_defaults
.enable_multibyte_characters
)))
2106 /* We dare not decode end-of-line format by setting VAL to
2107 Qraw_text, because the existing Emacs Lisp libraries
2108 assume that they receive bare code including a sequene of
2113 args
[0] = Qopen_network_stream
, args
[1] = name
,
2114 args
[2] = buffer
, args
[3] = host
, args
[4] = service
;
2116 coding_systems
= Ffind_operation_coding_system (5, args
);
2118 if (CONSP (coding_systems
))
2119 val
= XCAR (coding_systems
);
2120 else if (CONSP (Vdefault_process_coding_system
))
2121 val
= XCAR (Vdefault_process_coding_system
);
2125 XPROCESS (proc
)->decode_coding_system
= val
;
2127 if (!NILP (Vcoding_system_for_write
))
2128 val
= Vcoding_system_for_write
;
2129 else if (NILP (current_buffer
->enable_multibyte_characters
))
2133 if (EQ (coding_systems
, Qt
))
2135 args
[0] = Qopen_network_stream
, args
[1] = name
,
2136 args
[2] = buffer
, args
[3] = host
, args
[4] = service
;
2138 coding_systems
= Ffind_operation_coding_system (5, args
);
2141 if (CONSP (coding_systems
))
2142 val
= XCDR (coding_systems
);
2143 else if (CONSP (Vdefault_process_coding_system
))
2144 val
= XCDR (Vdefault_process_coding_system
);
2148 XPROCESS (proc
)->encode_coding_system
= val
;
2151 if (!proc_decode_coding_system
[inch
])
2152 proc_decode_coding_system
[inch
]
2153 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
2154 setup_coding_system (XPROCESS (proc
)->decode_coding_system
,
2155 proc_decode_coding_system
[inch
]);
2156 if (!proc_encode_coding_system
[outch
])
2157 proc_encode_coding_system
[outch
]
2158 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
2159 setup_coding_system (XPROCESS (proc
)->encode_coding_system
,
2160 proc_encode_coding_system
[outch
]);
2162 XPROCESS (proc
)->decoding_buf
= make_uninit_string (0);
2163 XPROCESS (proc
)->decoding_carryover
= make_number (0);
2164 XPROCESS (proc
)->encoding_buf
= make_uninit_string (0);
2165 XPROCESS (proc
)->encoding_carryover
= make_number (0);
2167 XPROCESS (proc
)->inherit_coding_system_flag
2168 = (NILP (buffer
) || !inherit_process_coding_system
2174 #endif /* HAVE_SOCKETS */
2177 deactivate_process (proc
)
2180 register int inchannel
, outchannel
;
2181 register struct Lisp_Process
*p
= XPROCESS (proc
);
2183 inchannel
= XINT (p
->infd
);
2184 outchannel
= XINT (p
->outfd
);
2188 /* Beware SIGCHLD hereabouts. */
2189 flush_pending_output (inchannel
);
2192 VMS_PROC_STUFF
*get_vms_process_pointer (), *vs
;
2193 sys$
dassgn (outchannel
);
2194 vs
= get_vms_process_pointer (p
->pid
);
2196 give_back_vms_process_stuff (vs
);
2199 emacs_close (inchannel
);
2200 if (outchannel
>= 0 && outchannel
!= inchannel
)
2201 emacs_close (outchannel
);
2204 XSETINT (p
->infd
, -1);
2205 XSETINT (p
->outfd
, -1);
2206 chan_process
[inchannel
] = Qnil
;
2207 FD_CLR (inchannel
, &input_wait_mask
);
2208 FD_CLR (inchannel
, &non_keyboard_wait_mask
);
2209 if (inchannel
== max_process_desc
)
2212 /* We just closed the highest-numbered process input descriptor,
2213 so recompute the highest-numbered one now. */
2214 max_process_desc
= 0;
2215 for (i
= 0; i
< MAXDESC
; i
++)
2216 if (!NILP (chan_process
[i
]))
2217 max_process_desc
= i
;
2222 /* Close all descriptors currently in use for communication
2223 with subprocess. This is used in a newly-forked subprocess
2224 to get rid of irrelevant descriptors. */
2227 close_process_descs ()
2231 for (i
= 0; i
< MAXDESC
; i
++)
2233 Lisp_Object process
;
2234 process
= chan_process
[i
];
2235 if (!NILP (process
))
2237 int in
= XINT (XPROCESS (process
)->infd
);
2238 int out
= XINT (XPROCESS (process
)->outfd
);
2241 if (out
>= 0 && in
!= out
)
2248 DEFUN ("accept-process-output", Faccept_process_output
, Saccept_process_output
,
2250 "Allow any pending output from subprocesses to be read by Emacs.\n\
2251 It is read into the process' buffers or given to their filter functions.\n\
2252 Non-nil arg PROCESS means do not return until some output has been received\n\
2254 Non-nil second arg TIMEOUT and third arg TIMEOUT-MSECS are number of\n\
2255 seconds and microseconds to wait; return after that much time whether\n\
2256 or not there is input.\n\
2257 Return non-nil iff we received any output before the timeout expired.")
2258 (process
, timeout
, timeout_msecs
)
2259 register Lisp_Object process
, timeout
, timeout_msecs
;
2264 if (! NILP (process
))
2265 CHECK_PROCESS (process
, 0);
2267 if (! NILP (timeout_msecs
))
2269 CHECK_NUMBER (timeout_msecs
, 2);
2270 useconds
= XINT (timeout_msecs
);
2271 if (!INTEGERP (timeout
))
2272 XSETINT (timeout
, 0);
2275 int carry
= useconds
/ 1000000;
2277 XSETINT (timeout
, XINT (timeout
) + carry
);
2278 useconds
-= carry
* 1000000;
2280 /* I think this clause is necessary because C doesn't
2281 guarantee a particular rounding direction for negative
2285 XSETINT (timeout
, XINT (timeout
) - 1);
2286 useconds
+= 1000000;
2293 if (! NILP (timeout
))
2295 CHECK_NUMBER (timeout
, 1);
2296 seconds
= XINT (timeout
);
2297 if (seconds
< 0 || (seconds
== 0 && useconds
== 0))
2309 XSETFASTINT (process
, 0);
2312 (wait_reading_process_input (seconds
, useconds
, process
, 0)
2316 /* This variable is different from waiting_for_input in keyboard.c.
2317 It is used to communicate to a lisp process-filter/sentinel (via the
2318 function Fwaiting_for_user_input_p below) whether emacs was waiting
2319 for user-input when that process-filter was called.
2320 waiting_for_input cannot be used as that is by definition 0 when
2321 lisp code is being evalled.
2322 This is also used in record_asynch_buffer_change.
2323 For that purpose, this must be 0
2324 when not inside wait_reading_process_input. */
2325 static int waiting_for_user_input_p
;
2327 /* This is here so breakpoints can be put on it. */
2329 wait_reading_process_input_1 ()
2333 /* Read and dispose of subprocess output while waiting for timeout to
2334 elapse and/or keyboard input to be available.
2337 timeout in seconds, or
2338 zero for no limit, or
2339 -1 means gobble data immediately available but don't wait for any.
2342 an additional duration to wait, measured in microseconds.
2343 If this is nonzero and time_limit is 0, then the timeout
2344 consists of MICROSECS only.
2346 READ_KBD is a lisp value:
2347 0 to ignore keyboard input, or
2348 1 to return when input is available, or
2349 -1 meaning caller will actually read the input, so don't throw to
2350 the quit handler, or
2351 a cons cell, meaning wait until its car is non-nil
2352 (and gobble terminal input into the buffer if any arrives), or
2353 a process object, meaning wait until something arrives from that
2354 process. The return value is true iff we read some input from
2357 DO_DISPLAY != 0 means redisplay should be done to show subprocess
2358 output that arrives.
2360 If READ_KBD is a pointer to a struct Lisp_Process, then the
2361 function returns true iff we received input from that process
2362 before the timeout elapsed.
2363 Otherwise, return true iff we received input from any process. */
2366 wait_reading_process_input (time_limit
, microsecs
, read_kbd
, do_display
)
2367 int time_limit
, microsecs
;
2368 Lisp_Object read_kbd
;
2371 register int channel
, nfds
;
2372 static SELECT_TYPE Available
;
2375 EMACS_TIME timeout
, end_time
;
2377 int wait_channel
= -1;
2378 struct Lisp_Process
*wait_proc
= 0;
2379 int got_some_input
= 0;
2380 Lisp_Object
*wait_for_cell
= 0;
2382 FD_ZERO (&Available
);
2384 /* If read_kbd is a process to watch, set wait_proc and wait_channel
2386 if (PROCESSP (read_kbd
))
2388 wait_proc
= XPROCESS (read_kbd
);
2389 wait_channel
= XINT (wait_proc
->infd
);
2390 XSETFASTINT (read_kbd
, 0);
2393 /* If waiting for non-nil in a cell, record where. */
2394 if (CONSP (read_kbd
))
2396 wait_for_cell
= &XCAR (read_kbd
);
2397 XSETFASTINT (read_kbd
, 0);
2400 waiting_for_user_input_p
= XINT (read_kbd
);
2402 /* Since we may need to wait several times,
2403 compute the absolute time to return at. */
2404 if (time_limit
|| microsecs
)
2406 EMACS_GET_TIME (end_time
);
2407 EMACS_SET_SECS_USECS (timeout
, time_limit
, microsecs
);
2408 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
2411 /* AlainF 5-Jul-1996
2412 HP-UX 10.10 seem to have problems with signals coming in
2413 Causes "poll: interrupted system call" messages when Emacs is run
2415 Turn off periodic alarms (in case they are in use) */
2421 int timeout_reduced_for_timers
= 0;
2423 #ifdef HAVE_X_WINDOWS
2424 if (display_busy_cursor_p
)
2425 Fx_hide_busy_cursor (Qnil
);
2428 /* If calling from keyboard input, do not quit
2429 since we want to return C-g as an input character.
2430 Otherwise, do pending quit if requested. */
2431 if (XINT (read_kbd
) >= 0)
2434 /* Exit now if the cell we're waiting for became non-nil. */
2435 if (wait_for_cell
&& ! NILP (*wait_for_cell
))
2438 /* Compute time from now till when time limit is up */
2439 /* Exit if already run out */
2440 if (time_limit
== -1)
2442 /* -1 specified for timeout means
2443 gobble output available now
2444 but don't wait at all. */
2446 EMACS_SET_SECS_USECS (timeout
, 0, 0);
2448 else if (time_limit
|| microsecs
)
2450 EMACS_GET_TIME (timeout
);
2451 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
2452 if (EMACS_TIME_NEG_P (timeout
))
2457 EMACS_SET_SECS_USECS (timeout
, 100000, 0);
2460 /* Normally we run timers here.
2461 But not if wait_for_cell; in those cases,
2462 the wait is supposed to be short,
2463 and those callers cannot handle running arbitrary Lisp code here. */
2464 if (! wait_for_cell
)
2466 EMACS_TIME timer_delay
;
2470 old_timers_run
= timers_run
;
2471 timer_delay
= timer_check (1);
2472 if (timers_run
!= old_timers_run
&& do_display
)
2474 redisplay_preserve_echo_area ();
2475 /* We must retry, since a timer may have requeued itself
2476 and that could alter the time_delay. */
2480 /* If there is unread keyboard input, also return. */
2481 if (XINT (read_kbd
) != 0
2482 && requeued_events_pending_p ())
2485 if (! EMACS_TIME_NEG_P (timer_delay
) && time_limit
!= -1)
2487 EMACS_TIME difference
;
2488 EMACS_SUB_TIME (difference
, timer_delay
, timeout
);
2489 if (EMACS_TIME_NEG_P (difference
))
2491 timeout
= timer_delay
;
2492 timeout_reduced_for_timers
= 1;
2495 /* If time_limit is -1, we are not going to wait at all. */
2496 else if (time_limit
!= -1)
2498 /* This is so a breakpoint can be put here. */
2499 wait_reading_process_input_1 ();
2503 /* Cause C-g and alarm signals to take immediate action,
2504 and cause input available signals to zero out timeout.
2506 It is important that we do this before checking for process
2507 activity. If we get a SIGCHLD after the explicit checks for
2508 process activity, timeout is the only way we will know. */
2509 if (XINT (read_kbd
) < 0)
2510 set_waiting_for_input (&timeout
);
2512 /* If status of something has changed, and no input is
2513 available, notify the user of the change right away. After
2514 this explicit check, we'll let the SIGCHLD handler zap
2515 timeout to get our attention. */
2516 if (update_tick
!= process_tick
&& do_display
)
2518 Atemp
= input_wait_mask
;
2519 EMACS_SET_SECS_USECS (timeout
, 0, 0);
2520 if ((select (max (max_process_desc
, max_keyboard_desc
) + 1,
2521 &Atemp
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0,
2525 /* It's okay for us to do this and then continue with
2526 the loop, since timeout has already been zeroed out. */
2527 clear_waiting_for_input ();
2532 /* Don't wait for output from a non-running process. */
2533 if (wait_proc
!= 0 && !NILP (wait_proc
->raw_status_low
))
2534 update_status (wait_proc
);
2536 && ! EQ (wait_proc
->status
, Qrun
))
2538 int nread
, total_nread
= 0;
2540 clear_waiting_for_input ();
2541 XSETPROCESS (proc
, wait_proc
);
2543 /* Read data from the process, until we exhaust it. */
2544 while (XINT (wait_proc
->infd
) >= 0)
2546 nread
= read_process_output (proc
, XINT (wait_proc
->infd
));
2552 total_nread
+= nread
;
2554 else if (nread
== -1 && EIO
== errno
)
2558 else if (nread
== -1 && EAGAIN
== errno
)
2562 else if (nread
== -1 && EWOULDBLOCK
== errno
)
2566 if (total_nread
> 0 && do_display
)
2567 redisplay_preserve_echo_area ();
2572 /* Wait till there is something to do */
2575 Available
= non_process_wait_mask
;
2576 else if (! XINT (read_kbd
))
2577 Available
= non_keyboard_wait_mask
;
2579 Available
= input_wait_mask
;
2581 /* If frame size has changed or the window is newly mapped,
2582 redisplay now, before we start to wait. There is a race
2583 condition here; if a SIGIO arrives between now and the select
2584 and indicates that a frame is trashed, the select may block
2585 displaying a trashed screen. */
2586 if (frame_garbaged
&& do_display
)
2588 clear_waiting_for_input ();
2589 redisplay_preserve_echo_area ();
2590 if (XINT (read_kbd
) < 0)
2591 set_waiting_for_input (&timeout
);
2594 if (XINT (read_kbd
) && detect_input_pending ())
2597 FD_ZERO (&Available
);
2600 nfds
= select (max (max_process_desc
, max_keyboard_desc
) + 1,
2601 &Available
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0,
2606 /* Make C-g and alarm signals set flags again */
2607 clear_waiting_for_input ();
2609 /* If we woke up due to SIGWINCH, actually change size now. */
2610 do_pending_window_change (0);
2612 if (time_limit
&& nfds
== 0 && ! timeout_reduced_for_timers
)
2613 /* We wanted the full specified time, so return now. */
2617 if (xerrno
== EINTR
)
2618 FD_ZERO (&Available
);
2620 /* Ultrix select seems to return ENOMEM when it is
2621 interrupted. Treat it just like EINTR. Bleah. Note
2622 that we want to test for the "ultrix" CPP symbol, not
2623 "__ultrix__"; the latter is only defined under GCC, but
2624 not by DEC's bundled CC. -JimB */
2625 else if (xerrno
== ENOMEM
)
2626 FD_ZERO (&Available
);
2629 /* This happens for no known reason on ALLIANT.
2630 I am guessing that this is the right response. -- RMS. */
2631 else if (xerrno
== EFAULT
)
2632 FD_ZERO (&Available
);
2634 else if (xerrno
== EBADF
)
2637 /* AIX doesn't handle PTY closure the same way BSD does. On AIX,
2638 the child's closure of the pts gives the parent a SIGHUP, and
2639 the ptc file descriptor is automatically closed,
2640 yielding EBADF here or at select() call above.
2641 So, SIGHUP is ignored (see def of PTY_TTY_NAME_SPRINTF
2642 in m/ibmrt-aix.h), and here we just ignore the select error.
2643 Cleanup occurs c/o status_notify after SIGCLD. */
2644 FD_ZERO (&Available
); /* Cannot depend on values returned */
2650 error ("select error: %s", emacs_strerror (xerrno
));
2652 #if defined(sun) && !defined(USG5_4)
2653 else if (nfds
> 0 && keyboard_bit_set (&Available
)
2655 /* System sometimes fails to deliver SIGIO.
2657 David J. Mackenzie says that Emacs doesn't compile under
2658 Solaris if this code is enabled, thus the USG5_4 in the CPP
2659 conditional. "I haven't noticed any ill effects so far.
2660 If you find a Solaris expert somewhere, they might know
2662 kill (getpid (), SIGIO
);
2665 #if 0 /* When polling is used, interrupt_input is 0,
2666 so get_input_pending should read the input.
2667 So this should not be needed. */
2668 /* If we are using polling for input,
2669 and we see input available, make it get read now.
2670 Otherwise it might not actually get read for a second.
2671 And on hpux, since we turn off polling in wait_reading_process_input,
2672 it might never get read at all if we don't spend much time
2673 outside of wait_reading_process_input. */
2674 if (XINT (read_kbd
) && interrupt_input
2675 && keyboard_bit_set (&Available
)
2676 && input_polling_used ())
2677 kill (getpid (), SIGALRM
);
2680 /* Check for keyboard input */
2681 /* If there is any, return immediately
2682 to give it higher priority than subprocesses */
2684 if (XINT (read_kbd
) != 0
2685 && detect_input_pending_run_timers (do_display
))
2687 swallow_events (do_display
);
2688 if (detect_input_pending_run_timers (do_display
))
2692 /* If there is unread keyboard input, also return. */
2693 if (XINT (read_kbd
) != 0
2694 && requeued_events_pending_p ())
2697 /* If we are not checking for keyboard input now,
2698 do process events (but don't run any timers).
2699 This is so that X events will be processed.
2700 Otherwise they may have to wait until polling takes place.
2701 That would causes delays in pasting selections, for example.
2703 (We used to do this only if wait_for_cell.) */
2704 if (XINT (read_kbd
) == 0 && detect_input_pending ())
2706 swallow_events (do_display
);
2707 #if 0 /* Exiting when read_kbd doesn't request that seems wrong, though. */
2708 if (detect_input_pending ())
2713 /* Exit now if the cell we're waiting for became non-nil. */
2714 if (wait_for_cell
&& ! NILP (*wait_for_cell
))
2718 /* If we think we have keyboard input waiting, but didn't get SIGIO,
2719 go read it. This can happen with X on BSD after logging out.
2720 In that case, there really is no input and no SIGIO,
2721 but select says there is input. */
2723 if (XINT (read_kbd
) && interrupt_input
2724 && keyboard_bit_set (&Available
))
2725 kill (getpid (), SIGIO
);
2729 got_some_input
|= nfds
> 0;
2731 /* If checking input just got us a size-change event from X,
2732 obey it now if we should. */
2733 if (XINT (read_kbd
) || wait_for_cell
)
2734 do_pending_window_change (0);
2736 /* Check for data from a process. */
2737 /* Really FIRST_PROC_DESC should be 0 on Unix,
2738 but this is safer in the short run. */
2739 for (channel
= 0; channel
<= max_process_desc
; channel
++)
2741 if (FD_ISSET (channel
, &Available
)
2742 && FD_ISSET (channel
, &non_keyboard_wait_mask
))
2746 /* If waiting for this channel, arrange to return as
2747 soon as no more input to be processed. No more
2749 if (wait_channel
== channel
)
2755 proc
= chan_process
[channel
];
2759 /* Read data from the process, starting with our
2760 buffered-ahead character if we have one. */
2762 nread
= read_process_output (proc
, channel
);
2765 /* Since read_process_output can run a filter,
2766 which can call accept-process-output,
2767 don't try to read from any other processes
2768 before doing the select again. */
2769 FD_ZERO (&Available
);
2772 redisplay_preserve_echo_area ();
2775 else if (nread
== -1 && errno
== EWOULDBLOCK
)
2778 /* ISC 4.1 defines both EWOULDBLOCK and O_NONBLOCK,
2779 and Emacs uses O_NONBLOCK, so what we get is EAGAIN. */
2781 else if (nread
== -1 && errno
== EAGAIN
)
2785 else if (nread
== -1 && errno
== EAGAIN
)
2787 /* Note that we cannot distinguish between no input
2788 available now and a closed pipe.
2789 With luck, a closed pipe will be accompanied by
2790 subprocess termination and SIGCHLD. */
2791 else if (nread
== 0 && !NETCONN_P (proc
))
2793 #endif /* O_NDELAY */
2794 #endif /* O_NONBLOCK */
2796 /* On some OSs with ptys, when the process on one end of
2797 a pty exits, the other end gets an error reading with
2798 errno = EIO instead of getting an EOF (0 bytes read).
2799 Therefore, if we get an error reading and errno =
2800 EIO, just continue, because the child process has
2801 exited and should clean itself up soon (e.g. when we
2804 However, it has been known to happen that the SIGCHLD
2805 got lost. So raise the signl again just in case.
2807 else if (nread
== -1 && errno
== EIO
)
2808 kill (getpid (), SIGCHLD
);
2809 #endif /* HAVE_PTYS */
2810 /* If we can detect process termination, don't consider the process
2811 gone just because its pipe is closed. */
2813 else if (nread
== 0 && !NETCONN_P (proc
))
2818 /* Preserve status of processes already terminated. */
2819 XSETINT (XPROCESS (proc
)->tick
, ++process_tick
);
2820 deactivate_process (proc
);
2821 if (!NILP (XPROCESS (proc
)->raw_status_low
))
2822 update_status (XPROCESS (proc
));
2823 if (EQ (XPROCESS (proc
)->status
, Qrun
))
2824 XPROCESS (proc
)->status
2825 = Fcons (Qexit
, Fcons (make_number (256), Qnil
));
2828 } /* end for each file descriptor */
2829 } /* end while exit conditions not met */
2831 waiting_for_user_input_p
= 0;
2833 /* If calling from keyboard input, do not quit
2834 since we want to return C-g as an input character.
2835 Otherwise, do pending quit if requested. */
2836 if (XINT (read_kbd
) >= 0)
2838 /* Prevent input_pending from remaining set if we quit. */
2839 clear_input_pending ();
2843 /* AlainF 5-Jul-1996
2844 HP-UX 10.10 seems to have problems with signals coming in
2845 Causes "poll: interrupted system call" messages when Emacs is run
2847 Turn periodic alarms back on */
2851 #ifdef HAVE_X_WINDOWS
2852 if (display_busy_cursor_p
)
2853 if (!inhibit_busy_cursor
)
2854 Fx_show_busy_cursor ();
2857 return got_some_input
;
2860 /* Given a list (FUNCTION ARGS...), apply FUNCTION to the ARGS. */
2863 read_process_output_call (fun_and_args
)
2864 Lisp_Object fun_and_args
;
2866 return apply1 (XCAR (fun_and_args
), XCDR (fun_and_args
));
2870 read_process_output_error_handler (error
)
2873 cmd_error_internal (error
, "error in process filter: ");
2875 update_echo_area ();
2876 Fsleep_for (make_number (2), Qnil
);
2879 /* Read pending output from the process channel,
2880 starting with our buffered-ahead character if we have one.
2881 Yield number of decoded characters read.
2883 This function reads at most 1024 characters.
2884 If you want to read all available subprocess output,
2885 you must call it repeatedly until it returns zero.
2887 The characters read are decoded according to PROC's coding-system
2891 read_process_output (proc
, channel
)
2893 register int channel
;
2895 register int nchars
, nbytes
;
2898 int chars_allocated
= 0; /* If 1, `chars' should be freed later. */
2902 register Lisp_Object outstream
;
2903 register struct buffer
*old
= current_buffer
;
2904 register struct Lisp_Process
*p
= XPROCESS (proc
);
2905 register int opoint
;
2906 struct coding_system
*coding
= proc_decode_coding_system
[channel
];
2907 int chars_in_decoding_buf
= 0; /* If 1, `chars' points
2908 XSTRING (p->decoding_buf)->data. */
2909 int carryover
= XINT (p
->decoding_carryover
);
2912 VMS_PROC_STUFF
*vs
, *get_vms_process_pointer();
2914 vs
= get_vms_process_pointer (p
->pid
);
2918 return (0); /* Really weird if it does this */
2919 if (!(vs
->iosb
[0] & 1))
2920 return -1; /* I/O error */
2923 error ("Could not get VMS process pointer");
2924 chars
= vs
->inputBuffer
;
2925 nbytes
= clean_vms_buffer (chars
, vs
->iosb
[1]);
2928 start_vms_process_read (vs
); /* Crank up the next read on the process */
2929 return 1; /* Nothing worth printing, say we got 1 */
2933 /* The data carried over in the previous decoding (which are at
2934 the tail of decoding buffer) should be prepended to the new
2935 data read to decode all together. */
2936 char *buf
= (char *) xmalloc (nbytes
+ carryover
);
2938 bcopy (XSTRING (p
->decoding_buf
)->data
2939 + STRING_BYTES (XSTRING (p
->decoding_buf
)) - carryover
,
2941 bcopy (chars
, buf
+ carryover
, nbytes
);
2943 chars_allocated
= 1;
2948 /* See the comment above. */
2949 bcopy (XSTRING (p
->decoding_buf
)->data
2950 + STRING_BYTES (XSTRING (p
->decoding_buf
)) - carryover
,
2953 if (proc_buffered_char
[channel
] < 0)
2954 nbytes
= emacs_read (channel
, buf
+ carryover
, (sizeof buf
) - carryover
);
2957 buf
[carryover
] = proc_buffered_char
[channel
];
2958 proc_buffered_char
[channel
] = -1;
2959 nbytes
= emacs_read (channel
, buf
+ carryover
+ 1,
2960 (sizeof buf
) - carryover
- 1);
2964 nbytes
= nbytes
+ 1;
2967 #endif /* not VMS */
2969 XSETINT (p
->decoding_carryover
, 0);
2971 /* At this point, NBYTES holds number of characters just received
2972 (including the one in proc_buffered_char[channel]). */
2975 if (nbytes
< 0 || coding
->mode
& CODING_MODE_LAST_BLOCK
)
2977 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
2980 /* Now set NBYTES how many bytes we must decode. */
2981 nbytes
+= carryover
;
2984 if (CODING_MAY_REQUIRE_DECODING (coding
))
2986 int require
= decoding_buffer_size (coding
, nbytes
);
2989 if (STRING_BYTES (XSTRING (p
->decoding_buf
)) < require
)
2990 p
->decoding_buf
= make_uninit_string (require
);
2991 result
= decode_coding (coding
, chars
, XSTRING (p
->decoding_buf
)->data
,
2992 nbytes
, STRING_BYTES (XSTRING (p
->decoding_buf
)));
2993 carryover
= nbytes
- coding
->consumed
;
2996 /* Copy the carryover bytes to the end of p->decoding_buf, to
2997 be processed on the next read. Since decoding_buffer_size
2998 asks for an extra amount of space beyond the maximum
2999 expected for the output, there should always be sufficient
3000 space for the carryover (which is by definition a sequence
3001 of bytes that was not long enough to be decoded, and thus
3002 has a bounded length). */
3003 if (STRING_BYTES (XSTRING (p
->decoding_buf
))
3004 < coding
->produced
+ carryover
)
3006 bcopy (chars
+ coding
->consumed
,
3007 XSTRING (p
->decoding_buf
)->data
3008 + STRING_BYTES (XSTRING (p
->decoding_buf
)) - carryover
,
3010 XSETINT (p
->decoding_carryover
, carryover
);
3013 /* A new coding system might be found by `decode_coding'. */
3014 if (!EQ (p
->decode_coding_system
, coding
->symbol
))
3016 p
->decode_coding_system
= coding
->symbol
;
3018 /* Don't call setup_coding_system for
3019 proc_decode_coding_system[channel] here. It is done in
3020 detect_coding called via decode_coding above. */
3022 /* If a coding system for encoding is not yet decided, we set
3023 it as the same as coding-system for decoding.
3025 But, before doing that we must check if
3026 proc_encode_coding_system[p->outfd] surely points to a
3027 valid memory because p->outfd will be changed once EOF is
3028 sent to the process. */
3029 if (NILP (p
->encode_coding_system
)
3030 && proc_encode_coding_system
[XINT (p
->outfd
)])
3032 p
->encode_coding_system
= coding
->symbol
;
3033 setup_coding_system (coding
->symbol
,
3034 proc_encode_coding_system
[XINT (p
->outfd
)]);
3039 /* Now we don't need the contents of `chars'. */
3040 if (chars_allocated
)
3043 if (coding
->produced
== 0)
3045 chars
= (char *) XSTRING (p
->decoding_buf
)->data
;
3046 nbytes
= coding
->produced
;
3047 nchars
= (coding
->fake_multibyte
3048 ? multibyte_chars_in_text (chars
, nbytes
)
3049 : coding
->produced_char
);
3050 chars_in_decoding_buf
= 1;
3055 if (chars_allocated
)
3057 /* Although we don't have to decode the received data, we
3058 must move it to an area which we don't have to free. */
3059 if (! STRINGP (p
->decoding_buf
)
3060 || STRING_BYTES (XSTRING (p
->decoding_buf
)) < nbytes
)
3061 p
->decoding_buf
= make_uninit_string (nbytes
);
3062 bcopy (chars
, XSTRING (p
->decoding_buf
)->data
, nbytes
);
3064 chars
= XSTRING (p
->decoding_buf
)->data
;
3065 chars_in_decoding_buf
= 1;
3068 nchars
= multibyte_chars_in_text (chars
, nbytes
);
3071 Vlast_coding_system_used
= coding
->symbol
;
3073 /* If the caller required, let the process associated buffer
3074 inherit the coding-system used to decode the process output. */
3075 if (! NILP (p
->inherit_coding_system_flag
)
3076 && !NILP (p
->buffer
) && !NILP (XBUFFER (p
->buffer
)->name
))
3078 struct buffer
*prev_buf
= current_buffer
;
3080 Fset_buffer (p
->buffer
);
3081 call1 (intern ("after-insert-file-set-buffer-file-coding-system"),
3082 make_number (nbytes
));
3083 set_buffer_internal (prev_buf
);
3086 /* Read and dispose of the process output. */
3087 outstream
= p
->filter
;
3088 if (!NILP (outstream
))
3090 /* We inhibit quit here instead of just catching it so that
3091 hitting ^G when a filter happens to be running won't screw
3093 int count
= specpdl_ptr
- specpdl
;
3094 Lisp_Object odeactivate
;
3095 Lisp_Object obuffer
, okeymap
;
3097 int outer_running_asynch_code
= running_asynch_code
;
3098 int waiting
= waiting_for_user_input_p
;
3100 /* No need to gcpro these, because all we do with them later
3101 is test them for EQness, and none of them should be a string. */
3102 odeactivate
= Vdeactivate_mark
;
3103 XSETBUFFER (obuffer
, current_buffer
);
3104 okeymap
= current_buffer
->keymap
;
3106 specbind (Qinhibit_quit
, Qt
);
3107 specbind (Qlast_nonmenu_event
, Qt
);
3109 /* In case we get recursively called,
3110 and we already saved the match data nonrecursively,
3111 save the same match data in safely recursive fashion. */
3112 if (outer_running_asynch_code
)
3115 /* Don't clobber the CURRENT match data, either! */
3116 tem
= Fmatch_data (Qnil
, Qnil
);
3117 restore_match_data ();
3118 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
3119 Fset_match_data (tem
);
3122 /* For speed, if a search happens within this code,
3123 save the match data in a special nonrecursive fashion. */
3124 running_asynch_code
= 1;
3126 /* The multibyteness of a string given to the filter is decided
3127 by which coding system we used for decoding. */
3128 if (coding
->type
== coding_type_no_conversion
3129 || coding
->type
== coding_type_raw_text
)
3130 text
= make_unibyte_string (chars
, nbytes
);
3132 text
= make_multibyte_string (chars
, nchars
, nbytes
);
3134 internal_condition_case_1 (read_process_output_call
,
3136 Fcons (proc
, Fcons (text
, Qnil
))),
3137 !NILP (Vdebug_on_error
) ? Qnil
: Qerror
,
3138 read_process_output_error_handler
);
3140 /* If we saved the match data nonrecursively, restore it now. */
3141 restore_match_data ();
3142 running_asynch_code
= outer_running_asynch_code
;
3144 /* Handling the process output should not deactivate the mark. */
3145 Vdeactivate_mark
= odeactivate
;
3147 /* Restore waiting_for_user_input_p as it was
3148 when we were called, in case the filter clobbered it. */
3149 waiting_for_user_input_p
= waiting
;
3151 #if 0 /* Call record_asynch_buffer_change unconditionally,
3152 because we might have changed minor modes or other things
3153 that affect key bindings. */
3154 if (! EQ (Fcurrent_buffer (), obuffer
)
3155 || ! EQ (current_buffer
->keymap
, okeymap
))
3157 /* But do it only if the caller is actually going to read events.
3158 Otherwise there's no need to make him wake up, and it could
3159 cause trouble (for example it would make Fsit_for return). */
3160 if (waiting_for_user_input_p
== -1)
3161 record_asynch_buffer_change ();
3164 start_vms_process_read (vs
);
3166 unbind_to (count
, Qnil
);
3170 /* If no filter, write into buffer if it isn't dead. */
3171 if (!NILP (p
->buffer
) && !NILP (XBUFFER (p
->buffer
)->name
))
3173 Lisp_Object old_read_only
;
3174 int old_begv
, old_zv
;
3175 int old_begv_byte
, old_zv_byte
;
3176 Lisp_Object odeactivate
;
3177 int before
, before_byte
;
3180 odeactivate
= Vdeactivate_mark
;
3182 Fset_buffer (p
->buffer
);
3184 opoint_byte
= PT_BYTE
;
3185 old_read_only
= current_buffer
->read_only
;
3188 old_begv_byte
= BEGV_BYTE
;
3189 old_zv_byte
= ZV_BYTE
;
3191 current_buffer
->read_only
= Qnil
;
3193 /* Insert new output into buffer
3194 at the current end-of-output marker,
3195 thus preserving logical ordering of input and output. */
3196 if (XMARKER (p
->mark
)->buffer
)
3197 SET_PT_BOTH (clip_to_bounds (BEGV
, marker_position (p
->mark
), ZV
),
3198 clip_to_bounds (BEGV_BYTE
, marker_byte_position (p
->mark
),
3201 SET_PT_BOTH (ZV
, ZV_BYTE
);
3203 before_byte
= PT_BYTE
;
3205 /* If the output marker is outside of the visible region, save
3206 the restriction and widen. */
3207 if (! (BEGV
<= PT
&& PT
<= ZV
))
3210 if (NILP (current_buffer
->enable_multibyte_characters
))
3213 /* Insert before markers in case we are inserting where
3214 the buffer's mark is, and the user's next command is Meta-y. */
3215 if (chars_in_decoding_buf
)
3217 /* Since multibyteness of p->docoding_buf is corrupted, we
3218 can't use insert_from_string_before_markers. */
3221 temp_buf
= (char *) alloca (nbytes
);
3222 bcopy (XSTRING (p
->decoding_buf
)->data
, temp_buf
, nbytes
);
3223 insert_before_markers (temp_buf
, nbytes
);
3227 insert_1_both (chars
, nchars
, nbytes
, 0, 1, 1);
3228 signal_after_change (opoint
, 0, PT
- opoint
);
3230 set_marker_both (p
->mark
, p
->buffer
, PT
, PT_BYTE
);
3232 update_mode_lines
++;
3234 /* Make sure opoint and the old restrictions
3235 float ahead of any new text just as point would. */
3236 if (opoint
>= before
)
3238 opoint
+= PT
- before
;
3239 opoint_byte
+= PT_BYTE
- before_byte
;
3241 if (old_begv
> before
)
3243 old_begv
+= PT
- before
;
3244 old_begv_byte
+= PT_BYTE
- before_byte
;
3246 if (old_zv
>= before
)
3248 old_zv
+= PT
- before
;
3249 old_zv_byte
+= PT_BYTE
- before_byte
;
3252 /* If the restriction isn't what it should be, set it. */
3253 if (old_begv
!= BEGV
|| old_zv
!= ZV
)
3254 Fnarrow_to_region (make_number (old_begv
), make_number (old_zv
));
3256 /* Handling the process output should not deactivate the mark. */
3257 Vdeactivate_mark
= odeactivate
;
3259 current_buffer
->read_only
= old_read_only
;
3260 SET_PT_BOTH (opoint
, opoint_byte
);
3261 set_buffer_internal (old
);
3264 start_vms_process_read (vs
);
3269 DEFUN ("waiting-for-user-input-p", Fwaiting_for_user_input_p
, Swaiting_for_user_input_p
,
3271 "Returns non-nil if emacs is waiting for input from the user.\n\
3272 This is intended for use by asynchronous process output filters and sentinels.")
3275 return (waiting_for_user_input_p
? Qt
: Qnil
);
3278 /* Sending data to subprocess */
3280 jmp_buf send_process_frame
;
3283 send_process_trap ()
3289 longjmp (send_process_frame
, 1);
3292 /* Send some data to process PROC.
3293 BUF is the beginning of the data; LEN is the number of characters.
3294 OBJECT is the Lisp object that the data comes from.
3296 The data is encoded by PROC's coding-system for encoding before it
3297 is sent. But if the data ends at the middle of multi-byte
3298 representation, that incomplete sequence of bytes are sent without
3299 being encoded. Should we store them in a buffer to prepend them to
3300 the data send later? */
3303 send_process (proc
, buf
, len
, object
)
3304 volatile Lisp_Object proc
;
3309 /* Use volatile to protect variables from being clobbered by longjmp. */
3311 volatile unsigned char *procname
= XSTRING (XPROCESS (proc
)->name
)->data
;
3312 struct coding_system
*coding
;
3313 struct gcpro gcpro1
;
3314 int carryover
= XINT (XPROCESS (proc
)->encoding_carryover
);
3319 struct Lisp_Process
*p
= XPROCESS (proc
);
3320 VMS_PROC_STUFF
*vs
, *get_vms_process_pointer();
3323 if (! NILP (XPROCESS (proc
)->raw_status_low
))
3324 update_status (XPROCESS (proc
));
3325 if (! EQ (XPROCESS (proc
)->status
, Qrun
))
3326 error ("Process %s not running", procname
);
3327 if (XINT (XPROCESS (proc
)->outfd
) < 0)
3328 error ("Output file descriptor of %s is closed", procname
);
3330 coding
= proc_encode_coding_system
[XINT (XPROCESS (proc
)->outfd
)];
3331 Vlast_coding_system_used
= coding
->symbol
;
3333 if (CODING_REQUIRE_ENCODING (coding
))
3335 int require
= encoding_buffer_size (coding
, len
);
3337 unsigned char *temp_buf
= NULL
;
3339 /* Remember the offset of data because a string or a buffer may
3340 be relocated. Setting OFFSET to -1 means we don't have to
3341 care about relocation. */
3342 offset
= (BUFFERP (object
)
3343 ? BUF_PTR_BYTE_POS (XBUFFER (object
), buf
)
3345 ? buf
- XSTRING (object
)->data
3350 temp_buf
= (unsigned char *) xmalloc (len
+ carryover
);
3354 if (BUFFERP (object
))
3355 buf
= BUF_BYTE_ADDRESS (XBUFFER (object
), offset
);
3356 else if (STRINGP (object
))
3357 buf
= offset
+ XSTRING (object
)->data
;
3358 /* Now we don't have to care about relocation. */
3361 bcopy ((XSTRING (XPROCESS (proc
)->encoding_buf
)->data
3362 + STRING_BYTES (XSTRING (XPROCESS (proc
)->encoding_buf
))
3366 bcopy (buf
, temp_buf
+ carryover
, len
);
3370 if (STRING_BYTES (XSTRING (XPROCESS (proc
)->encoding_buf
)) < require
)
3372 XPROCESS (proc
)->encoding_buf
= make_uninit_string (require
);
3376 if (BUFFERP (object
))
3377 buf
= BUF_BYTE_ADDRESS (XBUFFER (object
), offset
);
3378 else if (STRINGP (object
))
3379 buf
= offset
+ XSTRING (object
)->data
;
3382 object
= XPROCESS (proc
)->encoding_buf
;
3383 encode_coding (coding
, buf
, XSTRING (object
)->data
,
3384 len
, STRING_BYTES (XSTRING (object
)));
3385 len
= coding
->produced
;
3386 buf
= XSTRING (object
)->data
;
3392 vs
= get_vms_process_pointer (p
->pid
);
3394 error ("Could not find this process: %x", p
->pid
);
3395 else if (write_to_vms_process (vs
, buf
, len
))
3399 if (pty_max_bytes
== 0)
3401 #if defined (HAVE_FPATHCONF) && defined (_PC_MAX_CANON)
3402 pty_max_bytes
= fpathconf (XFASTINT (XPROCESS (proc
)->outfd
),
3404 if (pty_max_bytes
< 0)
3405 pty_max_bytes
= 250;
3407 pty_max_bytes
= 250;
3409 /* Deduct one, to leave space for the eof. */
3413 if (!setjmp (send_process_frame
))
3417 SIGTYPE (*old_sigpipe
)();
3419 /* Decide how much data we can send in one batch.
3420 Long lines need to be split into multiple batches. */
3421 if (!NILP (XPROCESS (proc
)->pty_flag
))
3423 /* Starting this at zero is always correct when not the first iteration
3424 because the previous iteration ended by sending C-d.
3425 It may not be correct for the first iteration
3426 if a partial line was sent in a separate send_process call.
3427 If that proves worth handling, we need to save linepos
3428 in the process object. */
3430 unsigned char *ptr
= buf
;
3431 unsigned char *end
= buf
+ len
;
3433 /* Scan through this text for a line that is too long. */
3434 while (ptr
!= end
&& linepos
< pty_max_bytes
)
3442 /* If we found one, break the line there
3443 and put in a C-d to force the buffer through. */
3447 /* Send this batch, using one or more write calls. */
3450 old_sigpipe
= (SIGTYPE (*) ()) signal (SIGPIPE
, send_process_trap
);
3451 rv
= emacs_write (XINT (XPROCESS (proc
)->outfd
), buf
, this);
3452 signal (SIGPIPE
, old_sigpipe
);
3458 || errno
== EWOULDBLOCK
3464 /* Buffer is full. Wait, accepting input;
3465 that may allow the program
3466 to finish doing output and read more. */
3471 /* Running filters might relocate buffers or strings.
3472 Arrange to relocate BUF. */
3473 if (BUFFERP (object
))
3474 offset
= BUF_PTR_BYTE_POS (XBUFFER (object
), buf
);
3475 else if (STRINGP (object
))
3476 offset
= buf
- XSTRING (object
)->data
;
3478 XSETFASTINT (zero
, 0);
3479 #ifdef EMACS_HAS_USECS
3480 wait_reading_process_input (0, 20000, zero
, 0);
3482 wait_reading_process_input (1, 0, zero
, 0);
3485 if (BUFFERP (object
))
3486 buf
= BUF_BYTE_ADDRESS (XBUFFER (object
), offset
);
3487 else if (STRINGP (object
))
3488 buf
= offset
+ XSTRING (object
)->data
;
3493 /* This is a real error. */
3494 report_file_error ("writing to process", Fcons (proc
, Qnil
));
3501 /* If we sent just part of the string, put in an EOF
3502 to force it through, before we send the rest. */
3504 Fprocess_send_eof (proc
);
3509 XPROCESS (proc
)->raw_status_low
= Qnil
;
3510 XPROCESS (proc
)->raw_status_high
= Qnil
;
3511 XPROCESS (proc
)->status
= Fcons (Qexit
, Fcons (make_number (256), Qnil
));
3512 XSETINT (XPROCESS (proc
)->tick
, ++process_tick
);
3513 deactivate_process (proc
);
3515 error ("Error writing to process %s; closed it", procname
);
3517 error ("SIGPIPE raised on process %s; closed it", procname
);
3524 DEFUN ("process-send-region", Fprocess_send_region
, Sprocess_send_region
,
3526 "Send current contents of region as input to PROCESS.\n\
3527 PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
3528 nil, indicating the current buffer's process.\n\
3529 Called from program, takes three arguments, PROCESS, START and END.\n\
3530 If the region is more than 500 characters long,\n\
3531 it is sent in several bunches. This may happen even for shorter regions.\n\
3532 Output from processes can arrive in between bunches.")
3533 (process
, start
, end
)
3534 Lisp_Object process
, start
, end
;
3539 proc
= get_process (process
);
3540 validate_region (&start
, &end
);
3542 if (XINT (start
) < GPT
&& XINT (end
) > GPT
)
3543 move_gap (XINT (start
));
3545 start1
= CHAR_TO_BYTE (XINT (start
));
3546 end1
= CHAR_TO_BYTE (XINT (end
));
3547 send_process (proc
, BYTE_POS_ADDR (start1
), end1
- start1
,
3548 Fcurrent_buffer ());
3553 DEFUN ("process-send-string", Fprocess_send_string
, Sprocess_send_string
,
3555 "Send PROCESS the contents of STRING as input.\n\
3556 PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
3557 nil, indicating the current buffer's process.\n\
3558 If STRING is more than 500 characters long,\n\
3559 it is sent in several bunches. This may happen even for shorter strings.\n\
3560 Output from processes can arrive in between bunches.")
3562 Lisp_Object process
, string
;
3565 CHECK_STRING (string
, 1);
3566 proc
= get_process (process
);
3567 send_process (proc
, XSTRING (string
)->data
,
3568 STRING_BYTES (XSTRING (string
)), string
);
3572 DEFUN ("process-running-child-p", Fprocess_running_child_p
,
3573 Sprocess_running_child_p
, 0, 1, 0,
3574 "Return t if PROCESS has given the terminal to a child.\n\
3575 If the operating system does not make it possible to find out,\n\
3576 return t unconditionally.")
3578 Lisp_Object process
;
3580 /* Initialize in case ioctl doesn't exist or gives an error,
3581 in a way that will cause returning t. */
3584 struct Lisp_Process
*p
;
3586 proc
= get_process (process
);
3587 p
= XPROCESS (proc
);
3589 if (!EQ (p
->childp
, Qt
))
3590 error ("Process %s is not a subprocess",
3591 XSTRING (p
->name
)->data
);
3592 if (XINT (p
->infd
) < 0)
3593 error ("Process %s is not active",
3594 XSTRING (p
->name
)->data
);
3597 if (!NILP (p
->subtty
))
3598 ioctl (XFASTINT (p
->subtty
), TIOCGPGRP
, &gid
);
3600 ioctl (XINT (p
->infd
), TIOCGPGRP
, &gid
);
3601 #endif /* defined (TIOCGPGRP ) */
3603 if (gid
== XFASTINT (p
->pid
))
3608 /* send a signal number SIGNO to PROCESS.
3609 If CURRENT_GROUP is t, that means send to the process group
3610 that currently owns the terminal being used to communicate with PROCESS.
3611 This is used for various commands in shell mode.
3612 If CURRENT_GROUP is lambda, that means send to the process group
3613 that currently owns the terminal, but only if it is NOT the shell itself.
3615 If NOMSG is zero, insert signal-announcements into process's buffers
3618 If we can, we try to signal PROCESS by sending control characters
3619 down the pty. This allows us to signal inferiors who have changed
3620 their uid, for which killpg would return an EPERM error. */
3623 process_send_signal (process
, signo
, current_group
, nomsg
)
3624 Lisp_Object process
;
3626 Lisp_Object current_group
;
3630 register struct Lisp_Process
*p
;
3634 proc
= get_process (process
);
3635 p
= XPROCESS (proc
);
3637 if (!EQ (p
->childp
, Qt
))
3638 error ("Process %s is not a subprocess",
3639 XSTRING (p
->name
)->data
);
3640 if (XINT (p
->infd
) < 0)
3641 error ("Process %s is not active",
3642 XSTRING (p
->name
)->data
);
3644 if (NILP (p
->pty_flag
))
3645 current_group
= Qnil
;
3647 /* If we are using pgrps, get a pgrp number and make it negative. */
3648 if (!NILP (current_group
))
3650 #ifdef SIGNALS_VIA_CHARACTERS
3651 /* If possible, send signals to the entire pgrp
3652 by sending an input character to it. */
3654 /* TERMIOS is the latest and bestest, and seems most likely to
3655 work. If the system has it, use it. */
3662 tcgetattr (XINT (p
->infd
), &t
);
3663 send_process (proc
, &t
.c_cc
[VINTR
], 1, Qnil
);
3667 tcgetattr (XINT (p
->infd
), &t
);
3668 send_process (proc
, &t
.c_cc
[VQUIT
], 1, Qnil
);
3672 tcgetattr (XINT (p
->infd
), &t
);
3673 #if defined (VSWTCH) && !defined (PREFER_VSUSP)
3674 send_process (proc
, &t
.c_cc
[VSWTCH
], 1, Qnil
);
3676 send_process (proc
, &t
.c_cc
[VSUSP
], 1, Qnil
);
3681 #else /* ! HAVE_TERMIOS */
3683 /* On Berkeley descendants, the following IOCTL's retrieve the
3684 current control characters. */
3685 #if defined (TIOCGLTC) && defined (TIOCGETC)
3693 ioctl (XINT (p
->infd
), TIOCGETC
, &c
);
3694 send_process (proc
, &c
.t_intrc
, 1, Qnil
);
3697 ioctl (XINT (p
->infd
), TIOCGETC
, &c
);
3698 send_process (proc
, &c
.t_quitc
, 1, Qnil
);
3702 ioctl (XINT (p
->infd
), TIOCGLTC
, &lc
);
3703 send_process (proc
, &lc
.t_suspc
, 1, Qnil
);
3705 #endif /* ! defined (SIGTSTP) */
3708 #else /* ! defined (TIOCGLTC) && defined (TIOCGETC) */
3710 /* On SYSV descendants, the TCGETA ioctl retrieves the current control
3717 ioctl (XINT (p
->infd
), TCGETA
, &t
);
3718 send_process (proc
, &t
.c_cc
[VINTR
], 1, Qnil
);
3721 ioctl (XINT (p
->infd
), TCGETA
, &t
);
3722 send_process (proc
, &t
.c_cc
[VQUIT
], 1, Qnil
);
3726 ioctl (XINT (p
->infd
), TCGETA
, &t
);
3727 send_process (proc
, &t
.c_cc
[VSWTCH
], 1, Qnil
);
3729 #endif /* ! defined (SIGTSTP) */
3731 #else /* ! defined (TCGETA) */
3732 Your configuration files are messed up
.
3733 /* If your system configuration files define SIGNALS_VIA_CHARACTERS,
3734 you'd better be using one of the alternatives above! */
3735 #endif /* ! defined (TCGETA) */
3736 #endif /* ! defined (TIOCGLTC) && defined (TIOCGETC) */
3737 #endif /* ! defined HAVE_TERMIOS */
3738 #endif /* ! defined (SIGNALS_VIA_CHARACTERS) */
3741 /* Get the pgrp using the tty itself, if we have that.
3742 Otherwise, use the pty to get the pgrp.
3743 On pfa systems, saka@pfu.fujitsu.co.JP writes:
3744 "TIOCGPGRP symbol defined in sys/ioctl.h at E50.
3745 But, TIOCGPGRP does not work on E50 ;-P works fine on E60"
3746 His patch indicates that if TIOCGPGRP returns an error, then
3747 we should just assume that p->pid is also the process group id. */
3751 if (!NILP (p
->subtty
))
3752 err
= ioctl (XFASTINT (p
->subtty
), TIOCGPGRP
, &gid
);
3754 err
= ioctl (XINT (p
->infd
), TIOCGPGRP
, &gid
);
3758 gid
= - XFASTINT (p
->pid
);
3759 #endif /* ! defined (pfa) */
3765 #else /* ! defined (TIOCGPGRP ) */
3766 /* Can't select pgrps on this system, so we know that
3767 the child itself heads the pgrp. */
3768 gid
= - XFASTINT (p
->pid
);
3769 #endif /* ! defined (TIOCGPGRP ) */
3771 /* If current_group is lambda, and the shell owns the terminal,
3772 don't send any signal. */
3773 if (EQ (current_group
, Qlambda
) && gid
== - XFASTINT (p
->pid
))
3777 gid
= - XFASTINT (p
->pid
);
3783 p
->raw_status_low
= Qnil
;
3784 p
->raw_status_high
= Qnil
;
3786 XSETINT (p
->tick
, ++process_tick
);
3790 #endif /* ! defined (SIGCONT) */
3793 send_process (proc
, "\003", 1, Qnil
); /* ^C */
3798 send_process (proc
, "\031", 1, Qnil
); /* ^Y */
3803 sys$
forcex (&(XFASTINT (p
->pid
)), 0, 1);
3806 flush_pending_output (XINT (p
->infd
));
3810 /* If we don't have process groups, send the signal to the immediate
3811 subprocess. That isn't really right, but it's better than any
3812 obvious alternative. */
3815 kill (XFASTINT (p
->pid
), signo
);
3819 /* gid may be a pid, or minus a pgrp's number */
3821 if (!NILP (current_group
))
3822 ioctl (XINT (p
->infd
), TIOCSIGSEND
, signo
);
3825 gid
= - XFASTINT (p
->pid
);
3828 #else /* ! defined (TIOCSIGSEND) */
3829 EMACS_KILLPG (-gid
, signo
);
3830 #endif /* ! defined (TIOCSIGSEND) */
3833 DEFUN ("interrupt-process", Finterrupt_process
, Sinterrupt_process
, 0, 2, 0,
3834 "Interrupt process PROCESS.\n\
3835 PROCESS may be a process, a buffer, or the name of a process or buffer.\n\
3836 nil or no arg means current buffer's process.\n\
3837 Second arg CURRENT-GROUP non-nil means send signal to\n\
3838 the current process-group of the process's controlling terminal\n\
3839 rather than to the process's own process group.\n\
3840 If the process is a shell, this means interrupt current subjob\n\
3841 rather than the shell.\n\
3843 If CURRENT-GROUP is `lambda', and if the shell owns the terminal,\n\
3844 don't send the signal.")
3845 (process
, current_group
)
3846 Lisp_Object process
, current_group
;
3848 process_send_signal (process
, SIGINT
, current_group
, 0);
3852 DEFUN ("kill-process", Fkill_process
, Skill_process
, 0, 2, 0,
3853 "Kill process PROCESS. May be process or name of one.\n\
3854 See function `interrupt-process' for more details on usage.")
3855 (process
, current_group
)
3856 Lisp_Object process
, current_group
;
3858 process_send_signal (process
, SIGKILL
, current_group
, 0);
3862 DEFUN ("quit-process", Fquit_process
, Squit_process
, 0, 2, 0,
3863 "Send QUIT signal to process PROCESS. May be process or name of one.\n\
3864 See function `interrupt-process' for more details on usage.")
3865 (process
, current_group
)
3866 Lisp_Object process
, current_group
;
3868 process_send_signal (process
, SIGQUIT
, current_group
, 0);
3872 DEFUN ("stop-process", Fstop_process
, Sstop_process
, 0, 2, 0,
3873 "Stop process PROCESS. May be process or name of one.\n\
3874 See function `interrupt-process' for more details on usage.")
3875 (process
, current_group
)
3876 Lisp_Object process
, current_group
;
3879 error ("no SIGTSTP support");
3881 process_send_signal (process
, SIGTSTP
, current_group
, 0);
3886 DEFUN ("continue-process", Fcontinue_process
, Scontinue_process
, 0, 2, 0,
3887 "Continue process PROCESS. May be process or name of one.\n\
3888 See function `interrupt-process' for more details on usage.")
3889 (process
, current_group
)
3890 Lisp_Object process
, current_group
;
3893 process_send_signal (process
, SIGCONT
, current_group
, 0);
3895 error ("no SIGCONT support");
3900 DEFUN ("signal-process", Fsignal_process
, Ssignal_process
,
3901 2, 2, "nProcess number: \nnSignal code: ",
3902 "Send the process with process id PID the signal with code SIGCODE.\n\
3903 PID must be an integer. The process need not be a child of this Emacs.\n\
3904 SIGCODE may be an integer, or a symbol whose name is a signal name.")
3906 Lisp_Object pid
, sigcode
;
3908 CHECK_NUMBER (pid
, 0);
3910 #define handle_signal(NAME, VALUE) \
3911 else if (!strcmp (name, NAME)) \
3912 XSETINT (sigcode, VALUE)
3914 if (INTEGERP (sigcode
))
3918 unsigned char *name
;
3920 CHECK_SYMBOL (sigcode
, 1);
3921 name
= XSYMBOL (sigcode
)->name
->data
;
3926 handle_signal ("SIGHUP", SIGHUP
);
3929 handle_signal ("SIGINT", SIGINT
);
3932 handle_signal ("SIGQUIT", SIGQUIT
);
3935 handle_signal ("SIGILL", SIGILL
);
3938 handle_signal ("SIGABRT", SIGABRT
);
3941 handle_signal ("SIGEMT", SIGEMT
);
3944 handle_signal ("SIGKILL", SIGKILL
);
3947 handle_signal ("SIGFPE", SIGFPE
);
3950 handle_signal ("SIGBUS", SIGBUS
);
3953 handle_signal ("SIGSEGV", SIGSEGV
);
3956 handle_signal ("SIGSYS", SIGSYS
);
3959 handle_signal ("SIGPIPE", SIGPIPE
);
3962 handle_signal ("SIGALRM", SIGALRM
);
3965 handle_signal ("SIGTERM", SIGTERM
);
3968 handle_signal ("SIGURG", SIGURG
);
3971 handle_signal ("SIGSTOP", SIGSTOP
);
3974 handle_signal ("SIGTSTP", SIGTSTP
);
3977 handle_signal ("SIGCONT", SIGCONT
);
3980 handle_signal ("SIGCHLD", SIGCHLD
);
3983 handle_signal ("SIGTTIN", SIGTTIN
);
3986 handle_signal ("SIGTTOU", SIGTTOU
);
3989 handle_signal ("SIGIO", SIGIO
);
3992 handle_signal ("SIGXCPU", SIGXCPU
);
3995 handle_signal ("SIGXFSZ", SIGXFSZ
);
3998 handle_signal ("SIGVTALRM", SIGVTALRM
);
4001 handle_signal ("SIGPROF", SIGPROF
);
4004 handle_signal ("SIGWINCH", SIGWINCH
);
4007 handle_signal ("SIGINFO", SIGINFO
);
4010 handle_signal ("SIGUSR1", SIGUSR1
);
4013 handle_signal ("SIGUSR2", SIGUSR2
);
4016 error ("Undefined signal name %s", name
);
4019 #undef handle_signal
4021 return make_number (kill (XINT (pid
), XINT (sigcode
)));
4024 DEFUN ("process-send-eof", Fprocess_send_eof
, Sprocess_send_eof
, 0, 1, 0,
4025 "Make PROCESS see end-of-file in its input.\n\
4026 EOF comes after any text already sent to it.\n\
4027 PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
4028 nil, indicating the current buffer's process.\n\
4029 If PROCESS is a network connection, or is a process communicating\n\
4030 through a pipe (as opposed to a pty), then you cannot send any more\n\
4031 text to PROCESS after you call this function.")
4033 Lisp_Object process
;
4036 struct coding_system
*coding
;
4038 proc
= get_process (process
);
4039 coding
= proc_encode_coding_system
[XINT (XPROCESS (proc
)->outfd
)];
4041 /* Make sure the process is really alive. */
4042 if (! NILP (XPROCESS (proc
)->raw_status_low
))
4043 update_status (XPROCESS (proc
));
4044 if (! EQ (XPROCESS (proc
)->status
, Qrun
))
4045 error ("Process %s not running", XSTRING (XPROCESS (proc
)->name
)->data
);
4047 if (CODING_REQUIRE_FLUSHING (coding
))
4049 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
4050 send_process (proc
, "", 0, Qnil
);
4054 send_process (proc
, "\032", 1, Qnil
); /* ^z */
4056 if (!NILP (XPROCESS (proc
)->pty_flag
))
4057 send_process (proc
, "\004", 1, Qnil
);
4060 int old_outfd
, new_outfd
;
4062 #ifdef HAVE_SHUTDOWN
4063 /* If this is a network connection, or socketpair is used
4064 for communication with the subprocess, call shutdown to cause EOF.
4065 (In some old system, shutdown to socketpair doesn't work.
4066 Then we just can't win.) */
4067 if (NILP (XPROCESS (proc
)->pid
)
4068 || XINT (XPROCESS (proc
)->outfd
) == XINT (XPROCESS (proc
)->infd
))
4069 shutdown (XINT (XPROCESS (proc
)->outfd
), 1);
4070 /* In case of socketpair, outfd == infd, so don't close it. */
4071 if (XINT (XPROCESS (proc
)->outfd
) != XINT (XPROCESS (proc
)->infd
))
4072 emacs_close (XINT (XPROCESS (proc
)->outfd
));
4073 #else /* not HAVE_SHUTDOWN */
4074 emacs_close (XINT (XPROCESS (proc
)->outfd
));
4075 #endif /* not HAVE_SHUTDOWN */
4076 new_outfd
= emacs_open (NULL_DEVICE
, O_WRONLY
, 0);
4077 old_outfd
= XINT (XPROCESS (proc
)->outfd
);
4079 if (!proc_encode_coding_system
[new_outfd
])
4080 proc_encode_coding_system
[new_outfd
]
4081 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
4082 bcopy (proc_encode_coding_system
[old_outfd
],
4083 proc_encode_coding_system
[new_outfd
],
4084 sizeof (struct coding_system
));
4085 bzero (proc_encode_coding_system
[old_outfd
],
4086 sizeof (struct coding_system
));
4088 XSETINT (XPROCESS (proc
)->outfd
, new_outfd
);
4094 /* Kill all processes associated with `buffer'.
4095 If `buffer' is nil, kill all processes */
4098 kill_buffer_processes (buffer
)
4101 Lisp_Object tail
, proc
;
4103 for (tail
= Vprocess_alist
; GC_CONSP (tail
); tail
= XCDR (tail
))
4105 proc
= XCDR (XCAR (tail
));
4106 if (GC_PROCESSP (proc
)
4107 && (NILP (buffer
) || EQ (XPROCESS (proc
)->buffer
, buffer
)))
4109 if (NETCONN_P (proc
))
4110 Fdelete_process (proc
);
4111 else if (XINT (XPROCESS (proc
)->infd
) >= 0)
4112 process_send_signal (proc
, SIGHUP
, Qnil
, 1);
4117 /* On receipt of a signal that a child status has changed,
4118 loop asking about children with changed statuses until
4119 the system says there are no more.
4120 All we do is change the status;
4121 we do not run sentinels or print notifications.
4122 That is saved for the next time keyboard input is done,
4123 in order to avoid timing errors. */
4125 /** WARNING: this can be called during garbage collection.
4126 Therefore, it must not be fooled by the presence of mark bits in
4129 /** USG WARNING: Although it is not obvious from the documentation
4130 in signal(2), on a USG system the SIGCLD handler MUST NOT call
4131 signal() before executing at least one wait(), otherwise the handler
4132 will be called again, resulting in an infinite loop. The relevant
4133 portion of the documentation reads "SIGCLD signals will be queued
4134 and the signal-catching function will be continually reentered until
4135 the queue is empty". Invoking signal() causes the kernel to reexamine
4136 the SIGCLD queue. Fred Fish, UniSoft Systems Inc. */
4139 sigchld_handler (signo
)
4142 int old_errno
= errno
;
4144 register struct Lisp_Process
*p
;
4145 extern EMACS_TIME
*input_available_clear_time
;
4149 sigheld
|= sigbit (SIGCHLD
);
4161 #endif /* no WUNTRACED */
4162 /* Keep trying to get a status until we get a definitive result. */
4166 pid
= wait3 (&w
, WNOHANG
| WUNTRACED
, 0);
4168 while (pid
<= 0 && errno
== EINTR
);
4172 /* A real failure. We have done all our job, so return. */
4174 /* USG systems forget handlers when they are used;
4175 must reestablish each time */
4176 #if defined (USG) && !defined (POSIX_SIGNALS)
4177 signal (signo
, sigchld_handler
); /* WARNING - must come after wait3() */
4180 sigheld
&= ~sigbit (SIGCHLD
);
4188 #endif /* no WNOHANG */
4190 /* Find the process that signaled us, and record its status. */
4193 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
4195 proc
= XCDR (XCAR (tail
));
4196 p
= XPROCESS (proc
);
4197 if (EQ (p
->childp
, Qt
) && XFASTINT (p
->pid
) == pid
)
4202 /* Look for an asynchronous process whose pid hasn't been filled
4205 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
4207 proc
= XCDR (XCAR (tail
));
4208 p
= XPROCESS (proc
);
4209 if (INTEGERP (p
->pid
) && XINT (p
->pid
) == -1)
4214 /* Change the status of the process that was found. */
4217 union { int i
; WAITTYPE wt
; } u
;
4218 int clear_desc_flag
= 0;
4220 XSETINT (p
->tick
, ++process_tick
);
4222 XSETINT (p
->raw_status_low
, u
.i
& 0xffff);
4223 XSETINT (p
->raw_status_high
, u
.i
>> 16);
4225 /* If process has terminated, stop waiting for its output. */
4226 if ((WIFSIGNALED (w
) || WIFEXITED (w
))
4227 && XINT (p
->infd
) >= 0)
4228 clear_desc_flag
= 1;
4230 /* We use clear_desc_flag to avoid a compiler bug in Microsoft C. */
4231 if (clear_desc_flag
)
4233 FD_CLR (XINT (p
->infd
), &input_wait_mask
);
4234 FD_CLR (XINT (p
->infd
), &non_keyboard_wait_mask
);
4237 /* Tell wait_reading_process_input that it needs to wake up and
4239 if (input_available_clear_time
)
4240 EMACS_SET_SECS_USECS (*input_available_clear_time
, 0, 0);
4243 /* There was no asynchronous process found for that id. Check
4244 if we have a synchronous process. */
4247 synch_process_alive
= 0;
4249 /* Report the status of the synchronous process. */
4251 synch_process_retcode
= WRETCODE (w
);
4252 else if (WIFSIGNALED (w
))
4254 int code
= WTERMSIG (w
);
4257 synchronize_messages_locale ();
4258 signame
= strsignal (code
);
4261 signame
= "unknown";
4263 synch_process_death
= signame
;
4266 /* Tell wait_reading_process_input that it needs to wake up and
4268 if (input_available_clear_time
)
4269 EMACS_SET_SECS_USECS (*input_available_clear_time
, 0, 0);
4272 /* On some systems, we must return right away.
4273 If any more processes want to signal us, we will
4275 Otherwise (on systems that have WNOHANG), loop around
4276 to use up all the processes that have something to tell us. */
4277 #if defined (USG) && ! (defined (HPUX) && defined (WNOHANG)) || defined (WINDOWSNT)
4278 #if defined (USG) && ! defined (POSIX_SIGNALS)
4279 signal (signo
, sigchld_handler
);
4283 #endif /* USG, but not HPUX with WNOHANG */
4289 exec_sentinel_unwind (data
)
4292 XPROCESS (XCAR (data
))->sentinel
= XCDR (data
);
4297 exec_sentinel_error_handler (error
)
4300 cmd_error_internal (error
, "error in process sentinel: ");
4302 update_echo_area ();
4303 Fsleep_for (make_number (2), Qnil
);
4307 exec_sentinel (proc
, reason
)
4308 Lisp_Object proc
, reason
;
4310 Lisp_Object sentinel
, obuffer
, odeactivate
, okeymap
;
4311 register struct Lisp_Process
*p
= XPROCESS (proc
);
4312 int count
= specpdl_ptr
- specpdl
;
4313 int outer_running_asynch_code
= running_asynch_code
;
4314 int waiting
= waiting_for_user_input_p
;
4316 /* No need to gcpro these, because all we do with them later
4317 is test them for EQness, and none of them should be a string. */
4318 odeactivate
= Vdeactivate_mark
;
4319 XSETBUFFER (obuffer
, current_buffer
);
4320 okeymap
= current_buffer
->keymap
;
4322 sentinel
= p
->sentinel
;
4323 if (NILP (sentinel
))
4326 /* Zilch the sentinel while it's running, to avoid recursive invocations;
4327 assure that it gets restored no matter how the sentinel exits. */
4329 record_unwind_protect (exec_sentinel_unwind
, Fcons (proc
, sentinel
));
4330 /* Inhibit quit so that random quits don't screw up a running filter. */
4331 specbind (Qinhibit_quit
, Qt
);
4332 specbind (Qlast_nonmenu_event
, Qt
);
4334 /* In case we get recursively called,
4335 and we already saved the match data nonrecursively,
4336 save the same match data in safely recursive fashion. */
4337 if (outer_running_asynch_code
)
4340 tem
= Fmatch_data (Qnil
, Qnil
);
4341 restore_match_data ();
4342 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
4343 Fset_match_data (tem
);
4346 /* For speed, if a search happens within this code,
4347 save the match data in a special nonrecursive fashion. */
4348 running_asynch_code
= 1;
4350 internal_condition_case_1 (read_process_output_call
,
4352 Fcons (proc
, Fcons (reason
, Qnil
))),
4353 !NILP (Vdebug_on_error
) ? Qnil
: Qerror
,
4354 exec_sentinel_error_handler
);
4356 /* If we saved the match data nonrecursively, restore it now. */
4357 restore_match_data ();
4358 running_asynch_code
= outer_running_asynch_code
;
4360 Vdeactivate_mark
= odeactivate
;
4362 /* Restore waiting_for_user_input_p as it was
4363 when we were called, in case the filter clobbered it. */
4364 waiting_for_user_input_p
= waiting
;
4367 if (! EQ (Fcurrent_buffer (), obuffer
)
4368 || ! EQ (current_buffer
->keymap
, okeymap
))
4370 /* But do it only if the caller is actually going to read events.
4371 Otherwise there's no need to make him wake up, and it could
4372 cause trouble (for example it would make Fsit_for return). */
4373 if (waiting_for_user_input_p
== -1)
4374 record_asynch_buffer_change ();
4376 unbind_to (count
, Qnil
);
4379 /* Report all recent events of a change in process status
4380 (either run the sentinel or output a message).
4381 This is done while Emacs is waiting for keyboard input. */
4386 register Lisp_Object proc
, buffer
;
4387 Lisp_Object tail
, msg
;
4388 struct gcpro gcpro1
, gcpro2
;
4392 /* We need to gcpro tail; if read_process_output calls a filter
4393 which deletes a process and removes the cons to which tail points
4394 from Vprocess_alist, and then causes a GC, tail is an unprotected
4398 /* Set this now, so that if new processes are created by sentinels
4399 that we run, we get called again to handle their status changes. */
4400 update_tick
= process_tick
;
4402 for (tail
= Vprocess_alist
; !NILP (tail
); tail
= Fcdr (tail
))
4405 register struct Lisp_Process
*p
;
4407 proc
= Fcdr (Fcar (tail
));
4408 p
= XPROCESS (proc
);
4410 if (XINT (p
->tick
) != XINT (p
->update_tick
))
4412 XSETINT (p
->update_tick
, XINT (p
->tick
));
4414 /* If process is still active, read any output that remains. */
4415 while (! EQ (p
->filter
, Qt
)
4416 && XINT (p
->infd
) >= 0
4417 && read_process_output (proc
, XINT (p
->infd
)) > 0);
4421 /* Get the text to use for the message. */
4422 if (!NILP (p
->raw_status_low
))
4424 msg
= status_message (p
->status
);
4426 /* If process is terminated, deactivate it or delete it. */
4428 if (CONSP (p
->status
))
4429 symbol
= XCAR (p
->status
);
4431 if (EQ (symbol
, Qsignal
) || EQ (symbol
, Qexit
)
4432 || EQ (symbol
, Qclosed
))
4434 if (delete_exited_processes
)
4435 remove_process (proc
);
4437 deactivate_process (proc
);
4440 /* The actions above may have further incremented p->tick.
4441 So set p->update_tick again
4442 so that an error in the sentinel will not cause
4443 this code to be run again. */
4444 XSETINT (p
->update_tick
, XINT (p
->tick
));
4445 /* Now output the message suitably. */
4446 if (!NILP (p
->sentinel
))
4447 exec_sentinel (proc
, msg
);
4448 /* Don't bother with a message in the buffer
4449 when a process becomes runnable. */
4450 else if (!EQ (symbol
, Qrun
) && !NILP (buffer
))
4452 Lisp_Object ro
, tem
;
4453 struct buffer
*old
= current_buffer
;
4454 int opoint
, opoint_byte
;
4455 int before
, before_byte
;
4457 ro
= XBUFFER (buffer
)->read_only
;
4459 /* Avoid error if buffer is deleted
4460 (probably that's why the process is dead, too) */
4461 if (NILP (XBUFFER (buffer
)->name
))
4463 Fset_buffer (buffer
);
4466 opoint_byte
= PT_BYTE
;
4467 /* Insert new output into buffer
4468 at the current end-of-output marker,
4469 thus preserving logical ordering of input and output. */
4470 if (XMARKER (p
->mark
)->buffer
)
4471 Fgoto_char (p
->mark
);
4473 SET_PT_BOTH (ZV
, ZV_BYTE
);
4476 before_byte
= PT_BYTE
;
4478 tem
= current_buffer
->read_only
;
4479 current_buffer
->read_only
= Qnil
;
4480 insert_string ("\nProcess ");
4481 Finsert (1, &p
->name
);
4482 insert_string (" ");
4484 current_buffer
->read_only
= tem
;
4485 set_marker_both (p
->mark
, p
->buffer
, PT
, PT_BYTE
);
4487 if (opoint
>= before
)
4488 SET_PT_BOTH (opoint
+ (PT
- before
),
4489 opoint_byte
+ (PT_BYTE
- before_byte
));
4491 SET_PT_BOTH (opoint
, opoint_byte
);
4493 set_buffer_internal (old
);
4498 update_mode_lines
++; /* in case buffers use %s in mode-line-format */
4499 redisplay_preserve_echo_area ();
4505 DEFUN ("set-process-coding-system", Fset_process_coding_system
,
4506 Sset_process_coding_system
, 1, 3, 0,
4507 "Set coding systems of PROCESS to DECODING and ENCODING.\n\
4508 DECODING will be used to decode subprocess output and ENCODING to\n\
4509 encode subprocess input.")
4510 (proc
, decoding
, encoding
)
4511 register Lisp_Object proc
, decoding
, encoding
;
4513 register struct Lisp_Process
*p
;
4515 CHECK_PROCESS (proc
, 0);
4516 p
= XPROCESS (proc
);
4517 if (XINT (p
->infd
) < 0)
4518 error ("Input file descriptor of %s closed", XSTRING (p
->name
)->data
);
4519 if (XINT (p
->outfd
) < 0)
4520 error ("Output file descriptor of %s closed", XSTRING (p
->name
)->data
);
4522 p
->decode_coding_system
= Fcheck_coding_system (decoding
);
4523 p
->encode_coding_system
= Fcheck_coding_system (encoding
);
4524 setup_coding_system (decoding
,
4525 proc_decode_coding_system
[XINT (p
->infd
)]);
4526 setup_coding_system (encoding
,
4527 proc_encode_coding_system
[XINT (p
->outfd
)]);
4532 DEFUN ("process-coding-system",
4533 Fprocess_coding_system
, Sprocess_coding_system
, 1, 1, 0,
4534 "Return a cons of coding systems for decoding and encoding of PROCESS.")
4536 register Lisp_Object proc
;
4538 CHECK_PROCESS (proc
, 0);
4539 return Fcons (XPROCESS (proc
)->decode_coding_system
,
4540 XPROCESS (proc
)->encode_coding_system
);
4543 /* The first time this is called, assume keyboard input comes from DESC
4544 instead of from where we used to expect it.
4545 Subsequent calls mean assume input keyboard can come from DESC
4546 in addition to other places. */
4548 static int add_keyboard_wait_descriptor_called_flag
;
4551 add_keyboard_wait_descriptor (desc
)
4554 if (! add_keyboard_wait_descriptor_called_flag
)
4555 FD_CLR (0, &input_wait_mask
);
4556 add_keyboard_wait_descriptor_called_flag
= 1;
4557 FD_SET (desc
, &input_wait_mask
);
4558 FD_SET (desc
, &non_process_wait_mask
);
4559 if (desc
> max_keyboard_desc
)
4560 max_keyboard_desc
= desc
;
4563 /* From now on, do not expect DESC to give keyboard input. */
4566 delete_keyboard_wait_descriptor (desc
)
4570 int lim
= max_keyboard_desc
;
4572 FD_CLR (desc
, &input_wait_mask
);
4573 FD_CLR (desc
, &non_process_wait_mask
);
4575 if (desc
== max_keyboard_desc
)
4576 for (fd
= 0; fd
< lim
; fd
++)
4577 if (FD_ISSET (fd
, &input_wait_mask
)
4578 && !FD_ISSET (fd
, &non_keyboard_wait_mask
))
4579 max_keyboard_desc
= fd
;
4582 /* Return nonzero if *MASK has a bit set
4583 that corresponds to one of the keyboard input descriptors. */
4586 keyboard_bit_set (mask
)
4591 for (fd
= 0; fd
<= max_keyboard_desc
; fd
++)
4592 if (FD_ISSET (fd
, mask
) && FD_ISSET (fd
, &input_wait_mask
)
4593 && !FD_ISSET (fd
, &non_keyboard_wait_mask
))
4606 if (! noninteractive
|| initialized
)
4608 signal (SIGCHLD
, sigchld_handler
);
4611 FD_ZERO (&input_wait_mask
);
4612 FD_ZERO (&non_keyboard_wait_mask
);
4613 FD_ZERO (&non_process_wait_mask
);
4614 max_process_desc
= 0;
4616 FD_SET (0, &input_wait_mask
);
4618 Vprocess_alist
= Qnil
;
4619 for (i
= 0; i
< MAXDESC
; i
++)
4621 chan_process
[i
] = Qnil
;
4622 proc_buffered_char
[i
] = -1;
4624 bzero (proc_decode_coding_system
, sizeof proc_decode_coding_system
);
4625 bzero (proc_encode_coding_system
, sizeof proc_encode_coding_system
);
4627 Vdefault_process_coding_system
4628 = (NILP (buffer_defaults
.enable_multibyte_characters
)
4629 ? Fcons (Qraw_text
, Qnil
)
4630 : Fcons (Qemacs_mule
, Qnil
));
4636 Qprocessp
= intern ("processp");
4637 staticpro (&Qprocessp
);
4638 Qrun
= intern ("run");
4640 Qstop
= intern ("stop");
4642 Qsignal
= intern ("signal");
4643 staticpro (&Qsignal
);
4645 /* Qexit is already staticpro'd by syms_of_eval; don't staticpro it
4648 Qexit = intern ("exit");
4649 staticpro (&Qexit); */
4651 Qopen
= intern ("open");
4653 Qclosed
= intern ("closed");
4654 staticpro (&Qclosed
);
4656 Qlast_nonmenu_event
= intern ("last-nonmenu-event");
4657 staticpro (&Qlast_nonmenu_event
);
4659 staticpro (&Vprocess_alist
);
4661 DEFVAR_BOOL ("delete-exited-processes", &delete_exited_processes
,
4662 "*Non-nil means delete processes immediately when they exit.\n\
4663 nil means don't delete them until `list-processes' is run.");
4665 delete_exited_processes
= 1;
4667 DEFVAR_LISP ("process-connection-type", &Vprocess_connection_type
,
4668 "Control type of device used to communicate with subprocesses.\n\
4669 Values are nil to use a pipe, or t or `pty' to use a pty.\n\
4670 The value has no effect if the system has no ptys or if all ptys are busy:\n\
4671 then a pipe is used in any case.\n\
4672 The value takes effect when `start-process' is called.");
4673 Vprocess_connection_type
= Qt
;
4675 defsubr (&Sprocessp
);
4676 defsubr (&Sget_process
);
4677 defsubr (&Sget_buffer_process
);
4678 defsubr (&Sdelete_process
);
4679 defsubr (&Sprocess_status
);
4680 defsubr (&Sprocess_exit_status
);
4681 defsubr (&Sprocess_id
);
4682 defsubr (&Sprocess_name
);
4683 defsubr (&Sprocess_tty_name
);
4684 defsubr (&Sprocess_command
);
4685 defsubr (&Sset_process_buffer
);
4686 defsubr (&Sprocess_buffer
);
4687 defsubr (&Sprocess_mark
);
4688 defsubr (&Sset_process_filter
);
4689 defsubr (&Sprocess_filter
);
4690 defsubr (&Sset_process_sentinel
);
4691 defsubr (&Sprocess_sentinel
);
4692 defsubr (&Sset_process_window_size
);
4693 defsubr (&Sset_process_inherit_coding_system_flag
);
4694 defsubr (&Sprocess_inherit_coding_system_flag
);
4695 defsubr (&Sprocess_kill_without_query
);
4696 defsubr (&Sprocess_contact
);
4697 defsubr (&Slist_processes
);
4698 defsubr (&Sprocess_list
);
4699 defsubr (&Sstart_process
);
4701 defsubr (&Sopen_network_stream
);
4702 #endif /* HAVE_SOCKETS */
4703 defsubr (&Saccept_process_output
);
4704 defsubr (&Sprocess_send_region
);
4705 defsubr (&Sprocess_send_string
);
4706 defsubr (&Sinterrupt_process
);
4707 defsubr (&Skill_process
);
4708 defsubr (&Squit_process
);
4709 defsubr (&Sstop_process
);
4710 defsubr (&Scontinue_process
);
4711 defsubr (&Sprocess_running_child_p
);
4712 defsubr (&Sprocess_send_eof
);
4713 defsubr (&Ssignal_process
);
4714 defsubr (&Swaiting_for_user_input_p
);
4715 /* defsubr (&Sprocess_connection); */
4716 defsubr (&Sset_process_coding_system
);
4717 defsubr (&Sprocess_coding_system
);
4721 #else /* not subprocesses */
4723 #include <sys/types.h>
4727 #include "systime.h"
4728 #include "charset.h"
4730 #include "termopts.h"
4731 #include "sysselect.h"
4733 extern int frame_garbaged
;
4735 extern EMACS_TIME
timer_check ();
4736 extern int timers_run
;
4738 /* As described above, except assuming that there are no subprocesses:
4740 Wait for timeout to elapse and/or keyboard input to be available.
4743 timeout in seconds, or
4744 zero for no limit, or
4745 -1 means gobble data immediately available but don't wait for any.
4747 read_kbd is a Lisp_Object:
4748 0 to ignore keyboard input, or
4749 1 to return when input is available, or
4750 -1 means caller will actually read the input, so don't throw to
4752 a cons cell, meaning wait until its car is non-nil
4753 (and gobble terminal input into the buffer if any arrives), or
4754 We know that read_kbd will never be a Lisp_Process, since
4755 `subprocesses' isn't defined.
4757 do_display != 0 means redisplay should be done to show subprocess
4758 output that arrives.
4760 Return true iff we received input from any process. */
4763 wait_reading_process_input (time_limit
, microsecs
, read_kbd
, do_display
)
4764 int time_limit
, microsecs
;
4765 Lisp_Object read_kbd
;
4769 EMACS_TIME end_time
, timeout
;
4770 SELECT_TYPE waitchannels
;
4772 Lisp_Object
*wait_for_cell
= 0;
4774 /* If waiting for non-nil in a cell, record where. */
4775 if (CONSP (read_kbd
))
4777 wait_for_cell
= &XCAR (read_kbd
);
4778 XSETFASTINT (read_kbd
, 0);
4781 /* What does time_limit really mean? */
4782 if (time_limit
|| microsecs
)
4784 EMACS_GET_TIME (end_time
);
4785 EMACS_SET_SECS_USECS (timeout
, time_limit
, microsecs
);
4786 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
4789 /* Turn off periodic alarms (in case they are in use)
4790 because the select emulator uses alarms. */
4795 int timeout_reduced_for_timers
= 0;
4797 /* If calling from keyboard input, do not quit
4798 since we want to return C-g as an input character.
4799 Otherwise, do pending quit if requested. */
4800 if (XINT (read_kbd
) >= 0)
4803 /* Exit now if the cell we're waiting for became non-nil. */
4804 if (wait_for_cell
&& ! NILP (*wait_for_cell
))
4807 /* Compute time from now till when time limit is up */
4808 /* Exit if already run out */
4809 if (time_limit
== -1)
4811 /* -1 specified for timeout means
4812 gobble output available now
4813 but don't wait at all. */
4815 EMACS_SET_SECS_USECS (timeout
, 0, 0);
4817 else if (time_limit
|| microsecs
)
4819 EMACS_GET_TIME (timeout
);
4820 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
4821 if (EMACS_TIME_NEG_P (timeout
))
4826 EMACS_SET_SECS_USECS (timeout
, 100000, 0);
4829 /* If our caller will not immediately handle keyboard events,
4830 run timer events directly.
4831 (Callers that will immediately read keyboard events
4832 call timer_delay on their own.) */
4833 if (! wait_for_cell
)
4835 EMACS_TIME timer_delay
;
4839 old_timers_run
= timers_run
;
4840 timer_delay
= timer_check (1);
4841 if (timers_run
!= old_timers_run
&& do_display
)
4843 redisplay_preserve_echo_area ();
4844 /* We must retry, since a timer may have requeued itself
4845 and that could alter the time delay. */
4849 /* If there is unread keyboard input, also return. */
4850 if (XINT (read_kbd
) != 0
4851 && requeued_events_pending_p ())
4854 if (! EMACS_TIME_NEG_P (timer_delay
) && time_limit
!= -1)
4856 EMACS_TIME difference
;
4857 EMACS_SUB_TIME (difference
, timer_delay
, timeout
);
4858 if (EMACS_TIME_NEG_P (difference
))
4860 timeout
= timer_delay
;
4861 timeout_reduced_for_timers
= 1;
4866 /* Cause C-g and alarm signals to take immediate action,
4867 and cause input available signals to zero out timeout. */
4868 if (XINT (read_kbd
) < 0)
4869 set_waiting_for_input (&timeout
);
4871 /* Wait till there is something to do. */
4873 if (! XINT (read_kbd
) && wait_for_cell
== 0)
4874 FD_ZERO (&waitchannels
);
4876 FD_SET (0, &waitchannels
);
4878 /* If a frame has been newly mapped and needs updating,
4879 reprocess its display stuff. */
4880 if (frame_garbaged
&& do_display
)
4882 clear_waiting_for_input ();
4883 redisplay_preserve_echo_area ();
4884 if (XINT (read_kbd
) < 0)
4885 set_waiting_for_input (&timeout
);
4888 if (XINT (read_kbd
) && detect_input_pending ())
4891 FD_ZERO (&waitchannels
);
4894 nfds
= select (1, &waitchannels
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0,
4899 /* Make C-g and alarm signals set flags again */
4900 clear_waiting_for_input ();
4902 /* If we woke up due to SIGWINCH, actually change size now. */
4903 do_pending_window_change (0);
4905 if (time_limit
&& nfds
== 0 && ! timeout_reduced_for_timers
)
4906 /* We waited the full specified time, so return now. */
4911 /* If the system call was interrupted, then go around the
4913 if (xerrno
== EINTR
)
4914 FD_ZERO (&waitchannels
);
4916 error ("select error: %s", emacs_strerror (xerrno
));
4919 else if (nfds
> 0 && (waitchannels
& 1) && interrupt_input
)
4920 /* System sometimes fails to deliver SIGIO. */
4921 kill (getpid (), SIGIO
);
4924 if (XINT (read_kbd
) && interrupt_input
&& (waitchannels
& 1))
4925 kill (getpid (), SIGIO
);
4928 /* Check for keyboard input */
4930 if ((XINT (read_kbd
) != 0)
4931 && detect_input_pending_run_timers (do_display
))
4933 swallow_events (do_display
);
4934 if (detect_input_pending_run_timers (do_display
))
4938 /* If there is unread keyboard input, also return. */
4939 if (XINT (read_kbd
) != 0
4940 && requeued_events_pending_p ())
4943 /* If wait_for_cell. check for keyboard input
4944 but don't run any timers.
4945 ??? (It seems wrong to me to check for keyboard
4946 input at all when wait_for_cell, but the code
4947 has been this way since July 1994.
4948 Try changing this after version 19.31.) */
4950 && detect_input_pending ())
4952 swallow_events (do_display
);
4953 if (detect_input_pending ())
4957 /* Exit now if the cell we're waiting for became non-nil. */
4958 if (wait_for_cell
&& ! NILP (*wait_for_cell
))
4968 DEFUN ("get-buffer-process", Fget_buffer_process
, Sget_buffer_process
, 1, 1, 0,
4969 /* Don't confuse make-docfile by having two doc strings for this function.
4970 make-docfile does not pay attention to #if, for good reason! */
4973 register Lisp_Object name
;
4978 DEFUN ("process-inherit-coding-system-flag",
4979 Fprocess_inherit_coding_system_flag
, Sprocess_inherit_coding_system_flag
,
4981 /* Don't confuse make-docfile by having two doc strings for this function.
4982 make-docfile does not pay attention to #if, for good reason! */
4985 register Lisp_Object process
;
4987 /* Ignore the argument and return the value of
4988 inherit-process-coding-system. */
4989 return inherit_process_coding_system
? Qt
: Qnil
;
4992 /* Kill all processes associated with `buffer'.
4993 If `buffer' is nil, kill all processes.
4994 Since we have no subprocesses, this does nothing. */
4997 kill_buffer_processes (buffer
)
5010 defsubr (&Sget_buffer_process
);
5011 defsubr (&Sprocess_inherit_coding_system_flag
);
5015 #endif /* not subprocesses */