1 /* Asynchronous subprocess control for GNU Emacs.
2 Copyright (C) 1985, 86, 87, 88, 93, 94, 95, 96, 98, 1999
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 #define _GNU_SOURCE /* to get strsignal declared with glibc 2 */
27 /* This file is split into two parts by the following preprocessor
28 conditional. The 'then' clause contains all of the support for
29 asynchronous subprocesses. The 'else' clause contains stub
30 versions of some of the asynchronous subprocess routines that are
31 often called elsewhere in Emacs, so we don't have to #ifdef the
32 sections that call them. */
40 #include <sys/types.h> /* some typedefs are used in sys/file.h */
50 #endif /* not WINDOWSNT */
52 #ifdef HAVE_SOCKETS /* TCP connection support, if kernel can do it */
53 #include <sys/socket.h>
55 #include <netinet/in.h>
56 #include <arpa/inet.h>
57 #ifdef NEED_NET_ERRNO_H
58 #include <net/errno.h>
59 #endif /* NEED_NET_ERRNO_H */
60 #endif /* HAVE_SOCKETS */
62 /* TERM is a poor-man's SLIP, used on GNU/Linux. */
67 /* On some systems, e.g. DGUX, inet_addr returns a 'struct in_addr'. */
68 #ifdef HAVE_BROKEN_INET_ADDR
69 #define IN_ADDR struct in_addr
70 #define NUMERIC_ADDR_ERROR (numeric_addr.s_addr == -1)
72 #define IN_ADDR unsigned long
73 #define NUMERIC_ADDR_ERROR (numeric_addr == -1)
76 #if defined(BSD_SYSTEM) || defined(STRIDE)
77 #include <sys/ioctl.h>
78 #if !defined (O_NDELAY) && defined (HAVE_PTYS) && !defined(USG5)
80 #endif /* HAVE_PTYS and no O_NDELAY */
81 #endif /* BSD_SYSTEM || STRIDE */
83 #ifdef BROKEN_O_NONBLOCK
85 #endif /* BROKEN_O_NONBLOCK */
92 #include <sys/sysmacros.h> /* for "minor" */
104 #include "termhooks.h"
105 #include "termopts.h"
106 #include "commands.h"
108 #include "blockinput.h"
109 #include "keyboard.h"
110 #include "dispextern.h"
111 #include "composite.h"
114 #define max(a, b) ((a) > (b) ? (a) : (b))
116 Lisp_Object Qprocessp
;
117 Lisp_Object Qrun
, Qstop
, Qsignal
, Qopen
, Qclosed
;
118 Lisp_Object Qlast_nonmenu_event
;
119 /* Qexit is declared and initialized in eval.c. */
121 /* a process object is a network connection when its childp field is neither
122 Qt nor Qnil but is instead a cons cell (HOSTNAME PORTNUM). */
125 #define NETCONN_P(p) (GC_CONSP (XPROCESS (p)->childp))
127 #define NETCONN_P(p) 0
128 #endif /* HAVE_SOCKETS */
130 /* Define first descriptor number available for subprocesses. */
132 #define FIRST_PROC_DESC 1
134 #define FIRST_PROC_DESC 3
137 /* Define SIGCHLD as an alias for SIGCLD. There are many conditionals
140 #if !defined (SIGCHLD) && defined (SIGCLD)
141 #define SIGCHLD SIGCLD
144 #include "syssignal.h"
148 extern void set_waiting_for_input
P_ ((EMACS_TIME
*));
152 extern char *sys_errlist
[];
159 /* t means use pty, nil means use a pipe,
160 maybe other values to come. */
161 static Lisp_Object Vprocess_connection_type
;
165 #include <sys/socket.h>
169 /* These next two vars are non-static since sysdep.c uses them in the
170 emulation of `select'. */
171 /* Number of events of change of status of a process. */
173 /* Number of events for which the user or sentinel has been notified. */
176 #include "sysselect.h"
178 extern int keyboard_bit_set
P_ ((SELECT_TYPE
*));
180 /* If we support a window system, turn on the code to poll periodically
181 to detect C-g. It isn't actually used when doing interrupt input. */
182 #ifdef HAVE_WINDOW_SYSTEM
183 #define POLL_FOR_INPUT
186 /* Mask of bits indicating the descriptors that we wait for input on. */
188 static SELECT_TYPE input_wait_mask
;
190 /* Mask that excludes keyboard input descriptor (s). */
192 static SELECT_TYPE non_keyboard_wait_mask
;
194 /* Mask that excludes process input descriptor (s). */
196 static SELECT_TYPE non_process_wait_mask
;
198 /* The largest descriptor currently in use for a process object. */
199 static int max_process_desc
;
201 /* The largest descriptor currently in use for keyboard input. */
202 static int max_keyboard_desc
;
204 /* Nonzero means delete a process right away if it exits. */
205 static int delete_exited_processes
;
207 /* Indexed by descriptor, gives the process (if any) for that descriptor */
208 Lisp_Object chan_process
[MAXDESC
];
210 /* Alist of elements (NAME . PROCESS) */
211 Lisp_Object Vprocess_alist
;
213 /* Buffered-ahead input char from process, indexed by channel.
214 -1 means empty (no char is buffered).
215 Used on sys V where the only way to tell if there is any
216 output from the process is to read at least one char.
217 Always -1 on systems that support FIONREAD. */
219 /* Don't make static; need to access externally. */
220 int proc_buffered_char
[MAXDESC
];
222 /* Table of `struct coding-system' for each process. */
223 static struct coding_system
*proc_decode_coding_system
[MAXDESC
];
224 static struct coding_system
*proc_encode_coding_system
[MAXDESC
];
226 static Lisp_Object
get_process ();
228 extern EMACS_TIME
timer_check ();
229 extern int timers_run
;
231 /* Maximum number of bytes to send to a pty without an eof. */
232 static int pty_max_bytes
;
234 extern Lisp_Object Vfile_name_coding_system
, Vdefault_file_name_coding_system
;
237 /* The file name of the pty opened by allocate_pty. */
239 static char pty_name
[24];
242 /* Compute the Lisp form of the process status, p->status, from
243 the numeric status that was returned by `wait'. */
245 Lisp_Object
status_convert ();
249 struct Lisp_Process
*p
;
251 union { int i
; WAITTYPE wt
; } u
;
252 u
.i
= XFASTINT (p
->raw_status_low
) + (XFASTINT (p
->raw_status_high
) << 16);
253 p
->status
= status_convert (u
.wt
);
254 p
->raw_status_low
= Qnil
;
255 p
->raw_status_high
= Qnil
;
258 /* Convert a process status word in Unix format to
259 the list that we use internally. */
266 return Fcons (Qstop
, Fcons (make_number (WSTOPSIG (w
)), Qnil
));
267 else if (WIFEXITED (w
))
268 return Fcons (Qexit
, Fcons (make_number (WRETCODE (w
)),
269 WCOREDUMP (w
) ? Qt
: Qnil
));
270 else if (WIFSIGNALED (w
))
271 return Fcons (Qsignal
, Fcons (make_number (WTERMSIG (w
)),
272 WCOREDUMP (w
) ? Qt
: Qnil
));
277 /* Given a status-list, extract the three pieces of information
278 and store them individually through the three pointers. */
281 decode_status (l
, symbol
, code
, coredump
)
299 *code
= XFASTINT (XCAR (tem
));
301 *coredump
= !NILP (tem
);
305 /* Return a string describing a process status list. */
308 status_message (status
)
313 Lisp_Object string
, string2
;
315 decode_status (status
, &symbol
, &code
, &coredump
);
317 if (EQ (symbol
, Qsignal
) || EQ (symbol
, Qstop
))
320 synchronize_system_messages_locale ();
321 signame
= strsignal (code
);
324 string
= build_string (signame
);
325 string2
= build_string (coredump
? " (core dumped)\n" : "\n");
326 XSTRING (string
)->data
[0] = DOWNCASE (XSTRING (string
)->data
[0]);
327 return concat2 (string
, string2
);
329 else if (EQ (symbol
, Qexit
))
332 return build_string ("finished\n");
333 string
= Fnumber_to_string (make_number (code
));
334 string2
= build_string (coredump
? " (core dumped)\n" : "\n");
335 return concat2 (build_string ("exited abnormally with code "),
336 concat2 (string
, string2
));
339 return Fcopy_sequence (Fsymbol_name (symbol
));
344 /* Open an available pty, returning a file descriptor.
345 Return -1 on failure.
346 The file name of the terminal corresponding to the pty
347 is left in the variable pty_name. */
356 /* Some systems name their pseudoterminals so that there are gaps in
357 the usual sequence - for example, on HP9000/S700 systems, there
358 are no pseudoterminals with names ending in 'f'. So we wait for
359 three failures in a row before deciding that we've reached the
361 int failed_count
= 0;
366 for (c
= FIRST_PTY_LETTER
; c
<= 'z'; c
++)
367 for (i
= 0; i
< 16; i
++)
370 #ifdef PTY_NAME_SPRINTF
373 sprintf (pty_name
, "/dev/pty%c%x", c
, i
);
374 #endif /* no PTY_NAME_SPRINTF */
378 #else /* no PTY_OPEN */
380 /* Unusual IRIS code */
381 *ptyv
= emacs_open ("/dev/ptc", O_RDWR
| O_NDELAY
, 0);
384 if (fstat (fd
, &stb
) < 0)
387 if (stat (pty_name
, &stb
) < 0)
390 if (failed_count
>= 3)
396 fd
= emacs_open (pty_name
, O_RDWR
| O_NONBLOCK
, 0);
398 fd
= emacs_open (pty_name
, O_RDWR
| O_NDELAY
, 0);
400 #endif /* not IRIS */
401 #endif /* no PTY_OPEN */
405 /* check to make certain that both sides are available
406 this avoids a nasty yet stupid bug in rlogins */
407 #ifdef PTY_TTY_NAME_SPRINTF
410 sprintf (pty_name
, "/dev/tty%c%x", c
, i
);
411 #endif /* no PTY_TTY_NAME_SPRINTF */
413 if (access (pty_name
, 6) != 0)
416 #if !defined(IRIS) && !defined(__sgi)
422 #endif /* not UNIPLUS */
429 #endif /* HAVE_PTYS */
435 struct Lisp_Vector
*vec
;
436 register Lisp_Object val
, tem
, name1
;
437 register struct Lisp_Process
*p
;
441 vec
= allocate_vectorlike ((EMACS_INT
) VECSIZE (struct Lisp_Process
));
442 for (i
= 0; i
< VECSIZE (struct Lisp_Process
); i
++)
443 vec
->contents
[i
] = Qnil
;
444 vec
->size
= VECSIZE (struct Lisp_Process
);
445 p
= (struct Lisp_Process
*)vec
;
447 XSETINT (p
->infd
, -1);
448 XSETINT (p
->outfd
, -1);
449 XSETFASTINT (p
->pid
, 0);
450 XSETFASTINT (p
->tick
, 0);
451 XSETFASTINT (p
->update_tick
, 0);
452 p
->raw_status_low
= Qnil
;
453 p
->raw_status_high
= Qnil
;
455 p
->mark
= Fmake_marker ();
457 /* If name is already in use, modify it until it is unused. */
462 tem
= Fget_process (name1
);
463 if (NILP (tem
)) break;
464 sprintf (suffix
, "<%d>", i
);
465 name1
= concat2 (name
, build_string (suffix
));
469 XSETPROCESS (val
, p
);
470 Vprocess_alist
= Fcons (Fcons (name
, val
), Vprocess_alist
);
475 remove_process (proc
)
476 register Lisp_Object proc
;
478 register Lisp_Object pair
;
480 pair
= Frassq (proc
, Vprocess_alist
);
481 Vprocess_alist
= Fdelq (pair
, Vprocess_alist
);
483 deactivate_process (proc
);
486 DEFUN ("processp", Fprocessp
, Sprocessp
, 1, 1, 0,
487 "Return t if OBJECT is a process.")
491 return PROCESSP (object
) ? Qt
: Qnil
;
494 DEFUN ("get-process", Fget_process
, Sget_process
, 1, 1, 0,
495 "Return the process named NAME, or nil if there is none.")
497 register Lisp_Object name
;
501 CHECK_STRING (name
, 0);
502 return Fcdr (Fassoc (name
, Vprocess_alist
));
505 DEFUN ("get-buffer-process", Fget_buffer_process
, Sget_buffer_process
, 1, 1, 0,
506 "Return the (or a) process associated with BUFFER.\n\
507 BUFFER may be a buffer or the name of one.")
509 register Lisp_Object buffer
;
511 register Lisp_Object buf
, tail
, proc
;
513 if (NILP (buffer
)) return Qnil
;
514 buf
= Fget_buffer (buffer
);
515 if (NILP (buf
)) return Qnil
;
517 for (tail
= Vprocess_alist
; !NILP (tail
); tail
= Fcdr (tail
))
519 proc
= Fcdr (Fcar (tail
));
520 if (PROCESSP (proc
) && EQ (XPROCESS (proc
)->buffer
, buf
))
526 /* This is how commands for the user decode process arguments. It
527 accepts a process, a process name, a buffer, a buffer name, or nil.
528 Buffers denote the first process in the buffer, and nil denotes the
533 register Lisp_Object name
;
535 register Lisp_Object proc
, obj
;
538 obj
= Fget_process (name
);
540 obj
= Fget_buffer (name
);
542 error ("Process %s does not exist", XSTRING (name
)->data
);
544 else if (NILP (name
))
545 obj
= Fcurrent_buffer ();
549 /* Now obj should be either a buffer object or a process object.
553 proc
= Fget_buffer_process (obj
);
555 error ("Buffer %s has no process", XSTRING (XBUFFER (obj
)->name
)->data
);
559 CHECK_PROCESS (obj
, 0);
565 DEFUN ("delete-process", Fdelete_process
, Sdelete_process
, 1, 1, 0,
566 "Delete PROCESS: kill it and forget about it immediately.\n\
567 PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
568 nil, indicating the current buffer's process.")
570 register Lisp_Object process
;
572 process
= get_process (process
);
573 XPROCESS (process
)->raw_status_low
= Qnil
;
574 XPROCESS (process
)->raw_status_high
= Qnil
;
575 if (NETCONN_P (process
))
577 XPROCESS (process
)->status
= Fcons (Qexit
, Fcons (make_number (0), Qnil
));
578 XSETINT (XPROCESS (process
)->tick
, ++process_tick
);
580 else if (XINT (XPROCESS (process
)->infd
) >= 0)
582 Fkill_process (process
, Qnil
);
583 /* Do this now, since remove_process will make sigchld_handler do nothing. */
584 XPROCESS (process
)->status
585 = Fcons (Qsignal
, Fcons (make_number (SIGKILL
), Qnil
));
586 XSETINT (XPROCESS (process
)->tick
, ++process_tick
);
589 remove_process (process
);
593 DEFUN ("process-status", Fprocess_status
, Sprocess_status
, 1, 1, 0,
594 "Return the status of PROCESS.\n\
595 The returned value is one of the following symbols:\n\
596 run -- for a process that is running.\n\
597 stop -- for a process stopped but continuable.\n\
598 exit -- for a process that has exited.\n\
599 signal -- for a process that has got a fatal signal.\n\
600 open -- for a network stream connection that is open.\n\
601 closed -- for a network stream connection that is closed.\n\
602 nil -- if arg is a process name and no such process exists.\n\
603 PROCESS may be a process, a buffer, the name of a process, or\n\
604 nil, indicating the current buffer's process.")
606 register Lisp_Object process
;
608 register struct Lisp_Process
*p
;
609 register Lisp_Object status
;
611 if (STRINGP (process
))
612 process
= Fget_process (process
);
614 process
= get_process (process
);
619 p
= XPROCESS (process
);
620 if (!NILP (p
->raw_status_low
))
624 status
= XCAR (status
);
625 if (NETCONN_P (process
))
627 if (EQ (status
, Qrun
))
629 else if (EQ (status
, Qexit
))
635 DEFUN ("process-exit-status", Fprocess_exit_status
, Sprocess_exit_status
,
637 "Return the exit status of PROCESS or the signal number that killed it.\n\
638 If PROCESS has not yet exited or died, return 0.")
640 register Lisp_Object process
;
642 CHECK_PROCESS (process
, 0);
643 if (!NILP (XPROCESS (process
)->raw_status_low
))
644 update_status (XPROCESS (process
));
645 if (CONSP (XPROCESS (process
)->status
))
646 return XCAR (XCDR (XPROCESS (process
)->status
));
647 return make_number (0);
650 DEFUN ("process-id", Fprocess_id
, Sprocess_id
, 1, 1, 0,
651 "Return the process id of PROCESS.\n\
652 This is the pid of the Unix process which PROCESS uses or talks to.\n\
653 For a network connection, this value is nil.")
655 register Lisp_Object process
;
657 CHECK_PROCESS (process
, 0);
658 return XPROCESS (process
)->pid
;
661 DEFUN ("process-name", Fprocess_name
, Sprocess_name
, 1, 1, 0,
662 "Return the name of PROCESS, as a string.\n\
663 This is the name of the program invoked in PROCESS,\n\
664 possibly modified to make it unique among process names.")
666 register Lisp_Object process
;
668 CHECK_PROCESS (process
, 0);
669 return XPROCESS (process
)->name
;
672 DEFUN ("process-command", Fprocess_command
, Sprocess_command
, 1, 1, 0,
673 "Return the command that was executed to start PROCESS.\n\
674 This is a list of strings, the first string being the program executed\n\
675 and the rest of the strings being the arguments given to it.\n\
676 For a non-child channel, this is nil.")
678 register Lisp_Object process
;
680 CHECK_PROCESS (process
, 0);
681 return XPROCESS (process
)->command
;
684 DEFUN ("process-tty-name", Fprocess_tty_name
, Sprocess_tty_name
, 1, 1, 0,
685 "Return the name of the terminal PROCESS uses, or nil if none.\n\
686 This is the terminal that the process itself reads and writes on,\n\
687 not the name of the pty that Emacs uses to talk with that terminal.")
689 register Lisp_Object process
;
691 CHECK_PROCESS (process
, 0);
692 return XPROCESS (process
)->tty_name
;
695 DEFUN ("set-process-buffer", Fset_process_buffer
, Sset_process_buffer
,
697 "Set buffer associated with PROCESS to BUFFER (a buffer, or nil).")
699 register Lisp_Object process
, buffer
;
701 CHECK_PROCESS (process
, 0);
703 CHECK_BUFFER (buffer
, 1);
704 XPROCESS (process
)->buffer
= buffer
;
708 DEFUN ("process-buffer", Fprocess_buffer
, Sprocess_buffer
,
710 "Return the buffer PROCESS is associated with.\n\
711 Output from PROCESS is inserted in this buffer unless PROCESS has a filter.")
713 register Lisp_Object process
;
715 CHECK_PROCESS (process
, 0);
716 return XPROCESS (process
)->buffer
;
719 DEFUN ("process-mark", Fprocess_mark
, Sprocess_mark
,
721 "Return the marker for the end of the last output from PROCESS.")
723 register Lisp_Object process
;
725 CHECK_PROCESS (process
, 0);
726 return XPROCESS (process
)->mark
;
729 DEFUN ("set-process-filter", Fset_process_filter
, Sset_process_filter
,
731 "Give PROCESS the filter function FILTER; nil means no filter.\n\
732 t means stop accepting output from the process.\n\
733 When a process has a filter, each time it does output\n\
734 the entire string of output is passed to the filter.\n\
735 The filter gets two arguments: the process and the string of output.\n\
736 If the process has a filter, its buffer is not used for output.")
738 register Lisp_Object process
, filter
;
740 CHECK_PROCESS (process
, 0);
743 FD_CLR (XINT (XPROCESS (process
)->infd
), &input_wait_mask
);
744 FD_CLR (XINT (XPROCESS (process
)->infd
), &non_keyboard_wait_mask
);
746 else if (EQ (XPROCESS (process
)->filter
, Qt
))
748 FD_SET (XINT (XPROCESS (process
)->infd
), &input_wait_mask
);
749 FD_SET (XINT (XPROCESS (process
)->infd
), &non_keyboard_wait_mask
);
751 XPROCESS (process
)->filter
= filter
;
755 DEFUN ("process-filter", Fprocess_filter
, Sprocess_filter
,
757 "Returns the filter function of PROCESS; nil if none.\n\
758 See `set-process-filter' for more info on filter functions.")
760 register Lisp_Object process
;
762 CHECK_PROCESS (process
, 0);
763 return XPROCESS (process
)->filter
;
766 DEFUN ("set-process-sentinel", Fset_process_sentinel
, Sset_process_sentinel
,
768 "Give PROCESS the sentinel SENTINEL; nil for none.\n\
769 The sentinel is called as a function when the process changes state.\n\
770 It gets two arguments: the process, and a string describing the change.")
772 register Lisp_Object process
, sentinel
;
774 CHECK_PROCESS (process
, 0);
775 XPROCESS (process
)->sentinel
= sentinel
;
779 DEFUN ("process-sentinel", Fprocess_sentinel
, Sprocess_sentinel
,
781 "Return the sentinel of PROCESS; nil if none.\n\
782 See `set-process-sentinel' for more info on sentinels.")
784 register Lisp_Object process
;
786 CHECK_PROCESS (process
, 0);
787 return XPROCESS (process
)->sentinel
;
790 DEFUN ("set-process-window-size", Fset_process_window_size
,
791 Sset_process_window_size
, 3, 3, 0,
792 "Tell PROCESS that it has logical window size HEIGHT and WIDTH.")
793 (process
, height
, width
)
794 register Lisp_Object process
, height
, width
;
796 CHECK_PROCESS (process
, 0);
797 CHECK_NATNUM (height
, 0);
798 CHECK_NATNUM (width
, 0);
799 if (set_window_size (XINT (XPROCESS (process
)->infd
),
800 XINT (height
), XINT (width
)) <= 0)
806 DEFUN ("set-process-inherit-coding-system-flag",
807 Fset_process_inherit_coding_system_flag
,
808 Sset_process_inherit_coding_system_flag
, 2, 2, 0,
809 "Determine whether buffer of PROCESS will inherit coding-system.\n\
810 If the second argument FLAG is non-nil, then the variable\n\
811 `buffer-file-coding-system' of the buffer associated with PROCESS\n\
812 will be bound to the value of the coding system used to decode\n\
813 the process output.\n\
815 This is useful when the coding system specified for the process buffer\n\
816 leaves either the character code conversion or the end-of-line conversion\n\
817 unspecified, or if the coding system used to decode the process output\n\
818 is more appropriate for saving the process buffer.\n\
820 Binding the variable `inherit-process-coding-system' to non-nil before\n\
821 starting the process is an alternative way of setting the inherit flag\n\
822 for the process which will run.")
824 register Lisp_Object process
, flag
;
826 CHECK_PROCESS (process
, 0);
827 XPROCESS (process
)->inherit_coding_system_flag
= flag
;
831 DEFUN ("process-inherit-coding-system-flag",
832 Fprocess_inherit_coding_system_flag
, Sprocess_inherit_coding_system_flag
,
834 "Return the value of inherit-coding-system flag for PROCESS.\n\
835 If this flag is t, `buffer-file-coding-system' of the buffer\n\
836 associated with PROCESS will inherit the coding system used to decode\n\
837 the process output.")
839 register Lisp_Object process
;
841 CHECK_PROCESS (process
, 0);
842 return XPROCESS (process
)->inherit_coding_system_flag
;
845 DEFUN ("process-kill-without-query", Fprocess_kill_without_query
,
846 Sprocess_kill_without_query
, 1, 2, 0,
847 "Say no query needed if PROCESS is running when Emacs is exited.\n\
848 Optional second argument if non-nil says to require a query.\n\
849 Value is t if a query was formerly required.")
851 register Lisp_Object process
, value
;
855 CHECK_PROCESS (process
, 0);
856 tem
= XPROCESS (process
)->kill_without_query
;
857 XPROCESS (process
)->kill_without_query
= Fnull (value
);
862 DEFUN ("process-contact", Fprocess_contact
, Sprocess_contact
,
864 "Return the contact info of PROCESS; t for a real child.\n\
865 For a net connection, the value is a cons cell of the form (HOST SERVICE).")
867 register Lisp_Object process
;
869 CHECK_PROCESS (process
, 0);
870 return XPROCESS (process
)->childp
;
873 #if 0 /* Turned off because we don't currently record this info
874 in the process. Perhaps add it. */
875 DEFUN ("process-connection", Fprocess_connection
, Sprocess_connection
, 1, 1, 0,
876 "Return the connection type of PROCESS.\n\
877 The value is nil for a pipe, t or `pty' for a pty, or `stream' for\n\
878 a socket connection.")
882 return XPROCESS (process
)->type
;
889 register Lisp_Object tail
, tem
;
890 Lisp_Object proc
, minspace
, tem1
;
891 register struct Lisp_Process
*p
;
894 XSETFASTINT (minspace
, 1);
896 set_buffer_internal (XBUFFER (Vstandard_output
));
897 Fbuffer_disable_undo (Vstandard_output
);
899 current_buffer
->truncate_lines
= Qt
;
902 Proc Status Buffer Tty Command\n\
903 ---- ------ ------ --- -------\n", -1);
905 for (tail
= Vprocess_alist
; !NILP (tail
); tail
= Fcdr (tail
))
909 proc
= Fcdr (Fcar (tail
));
911 if (NILP (p
->childp
))
914 Finsert (1, &p
->name
);
915 Findent_to (make_number (13), minspace
);
917 if (!NILP (p
->raw_status_low
))
920 if (CONSP (p
->status
))
921 symbol
= XCAR (p
->status
);
924 if (EQ (symbol
, Qsignal
))
927 tem
= Fcar (Fcdr (p
->status
));
929 if (XINT (tem
) < NSIG
)
930 write_string (sys_errlist
[XINT (tem
)], -1);
933 Fprinc (symbol
, Qnil
);
935 else if (NETCONN_P (proc
))
937 if (EQ (symbol
, Qrun
))
938 write_string ("open", -1);
939 else if (EQ (symbol
, Qexit
))
940 write_string ("closed", -1);
942 Fprinc (symbol
, Qnil
);
945 Fprinc (symbol
, Qnil
);
947 if (EQ (symbol
, Qexit
))
950 tem
= Fcar (Fcdr (p
->status
));
953 sprintf (tembuf
, " %d", (int) XFASTINT (tem
));
954 write_string (tembuf
, -1);
958 if (EQ (symbol
, Qsignal
) || EQ (symbol
, Qexit
))
959 remove_process (proc
);
961 Findent_to (make_number (22), minspace
);
962 if (NILP (p
->buffer
))
963 insert_string ("(none)");
964 else if (NILP (XBUFFER (p
->buffer
)->name
))
965 insert_string ("(Killed)");
967 Finsert (1, &XBUFFER (p
->buffer
)->name
);
969 Findent_to (make_number (37), minspace
);
971 if (STRINGP (p
->tty_name
))
972 Finsert (1, &p
->tty_name
);
974 insert_string ("(none)");
976 Findent_to (make_number (49), minspace
);
978 if (NETCONN_P (proc
))
980 sprintf (tembuf
, "(network stream connection to %s)\n",
981 XSTRING (XCAR (p
->childp
))->data
);
982 insert_string (tembuf
);
996 insert_string ("\n");
1002 DEFUN ("list-processes", Flist_processes
, Slist_processes
, 0, 0, "",
1003 "Display a list of all processes.\n\
1004 Any process listed as exited or signaled is actually eliminated\n\
1005 after the listing is made.")
1008 internal_with_output_to_temp_buffer ("*Process List*",
1009 list_processes_1
, Qnil
);
1013 DEFUN ("process-list", Fprocess_list
, Sprocess_list
, 0, 0, 0,
1014 "Return a list of all processes.")
1017 return Fmapcar (Qcdr
, Vprocess_alist
);
1020 /* Starting asynchronous inferior processes. */
1022 static Lisp_Object
start_process_unwind ();
1024 DEFUN ("start-process", Fstart_process
, Sstart_process
, 3, MANY
, 0,
1025 "Start a program in a subprocess. Return the process object for it.\n\
1026 NAME is name for process. It is modified if necessary to make it unique.\n\
1027 BUFFER is the buffer or (buffer-name) to associate with the process.\n\
1028 Process output goes at end of that buffer, unless you specify\n\
1029 an output stream or filter function to handle the output.\n\
1030 BUFFER may be also nil, meaning that this process is not associated\n\
1032 Third arg is program file name. It is searched for in PATH.\n\
1033 Remaining arguments are strings to give program as arguments.")
1036 register Lisp_Object
*args
;
1038 Lisp_Object buffer
, name
, program
, proc
, current_dir
, tem
;
1040 register unsigned char *new_argv
;
1043 register unsigned char **new_argv
;
1046 int count
= specpdl_ptr
- specpdl
;
1050 buffer
= Fget_buffer_create (buffer
);
1052 /* Make sure that the child will be able to chdir to the current
1053 buffer's current directory, or its unhandled equivalent. We
1054 can't just have the child check for an error when it does the
1055 chdir, since it's in a vfork.
1057 We have to GCPRO around this because Fexpand_file_name and
1058 Funhandled_file_name_directory might call a file name handling
1059 function. The argument list is protected by the caller, so all
1060 we really have to worry about is buffer. */
1062 struct gcpro gcpro1
, gcpro2
;
1064 current_dir
= current_buffer
->directory
;
1066 GCPRO2 (buffer
, current_dir
);
1069 = expand_and_dir_to_file (Funhandled_file_name_directory (current_dir
),
1071 if (NILP (Ffile_accessible_directory_p (current_dir
)))
1072 report_file_error ("Setting current directory",
1073 Fcons (current_buffer
->directory
, Qnil
));
1079 CHECK_STRING (name
, 0);
1083 CHECK_STRING (program
, 2);
1086 /* Make a one member argv with all args concatenated
1087 together separated by a blank. */
1088 len
= STRING_BYTES (XSTRING (program
)) + 2;
1089 for (i
= 3; i
< nargs
; i
++)
1092 CHECK_STRING (tem
, i
);
1093 len
+= STRING_BYTES (XSTRING (tem
)) + 1; /* count the blank */
1095 new_argv
= (unsigned char *) alloca (len
);
1096 strcpy (new_argv
, XSTRING (program
)->data
);
1097 for (i
= 3; i
< nargs
; i
++)
1100 CHECK_STRING (tem
, i
);
1101 strcat (new_argv
, " ");
1102 strcat (new_argv
, XSTRING (tem
)->data
);
1104 /* Need to add code here to check for program existence on VMS */
1107 new_argv
= (unsigned char **) alloca ((nargs
- 1) * sizeof (char *));
1109 /* If program file name is not absolute, search our path for it */
1110 if (!IS_DIRECTORY_SEP (XSTRING (program
)->data
[0])
1111 && !(XSTRING (program
)->size
> 1
1112 && IS_DEVICE_SEP (XSTRING (program
)->data
[1])))
1114 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1117 GCPRO4 (name
, program
, buffer
, current_dir
);
1118 openp (Vexec_path
, program
, EXEC_SUFFIXES
, &tem
, 1);
1121 report_file_error ("Searching for program", Fcons (program
, Qnil
));
1122 tem
= Fexpand_file_name (tem
, Qnil
);
1123 new_argv
[0] = XSTRING (tem
)->data
;
1127 if (!NILP (Ffile_directory_p (program
)))
1128 error ("Specified program for new process is a directory");
1130 new_argv
[0] = XSTRING (program
)->data
;
1133 for (i
= 3; i
< nargs
; i
++)
1136 CHECK_STRING (tem
, i
);
1137 new_argv
[i
- 2] = XSTRING (tem
)->data
;
1139 new_argv
[i
- 2] = 0;
1140 #endif /* not VMS */
1142 proc
= make_process (name
);
1143 /* If an error occurs and we can't start the process, we want to
1144 remove it from the process list. This means that each error
1145 check in create_process doesn't need to call remove_process
1146 itself; it's all taken care of here. */
1147 record_unwind_protect (start_process_unwind
, proc
);
1149 XPROCESS (proc
)->childp
= Qt
;
1150 XPROCESS (proc
)->command_channel_p
= Qnil
;
1151 XPROCESS (proc
)->buffer
= buffer
;
1152 XPROCESS (proc
)->sentinel
= Qnil
;
1153 XPROCESS (proc
)->filter
= Qnil
;
1154 XPROCESS (proc
)->command
= Flist (nargs
- 2, args
+ 2);
1156 /* Make the process marker point into the process buffer (if any). */
1158 set_marker_both (XPROCESS (proc
)->mark
, buffer
,
1159 BUF_ZV (XBUFFER (buffer
)),
1160 BUF_ZV_BYTE (XBUFFER (buffer
)));
1163 /* Decide coding systems for communicating with the process. Here
1164 we don't setup the structure coding_system nor pay attention to
1165 unibyte mode. They are done in create_process. */
1167 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
1168 Lisp_Object coding_systems
= Qt
;
1169 Lisp_Object val
, *args2
;
1170 struct gcpro gcpro1
;
1172 val
= Vcoding_system_for_read
;
1175 args2
= (Lisp_Object
*) alloca ((nargs
+ 1) * sizeof *args2
);
1176 args2
[0] = Qstart_process
;
1177 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
1179 coding_systems
= Ffind_operation_coding_system (nargs
+ 1, args2
);
1181 if (CONSP (coding_systems
))
1182 val
= XCAR (coding_systems
);
1183 else if (CONSP (Vdefault_process_coding_system
))
1184 val
= XCAR (Vdefault_process_coding_system
);
1186 XPROCESS (proc
)->decode_coding_system
= val
;
1188 val
= Vcoding_system_for_write
;
1191 if (EQ (coding_systems
, Qt
))
1193 args2
= (Lisp_Object
*) alloca ((nargs
+ 1) * sizeof args2
);
1194 args2
[0] = Qstart_process
;
1195 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
1197 coding_systems
= Ffind_operation_coding_system (nargs
+ 1, args2
);
1200 if (CONSP (coding_systems
))
1201 val
= XCDR (coding_systems
);
1202 else if (CONSP (Vdefault_process_coding_system
))
1203 val
= XCDR (Vdefault_process_coding_system
);
1205 XPROCESS (proc
)->encode_coding_system
= val
;
1208 XPROCESS (proc
)->decoding_buf
= make_uninit_string (0);
1209 XPROCESS (proc
)->decoding_carryover
= make_number (0);
1210 XPROCESS (proc
)->encoding_buf
= make_uninit_string (0);
1211 XPROCESS (proc
)->encoding_carryover
= make_number (0);
1213 XPROCESS (proc
)->inherit_coding_system_flag
1214 = (NILP (buffer
) || !inherit_process_coding_system
1217 create_process (proc
, (char **) new_argv
, current_dir
);
1219 return unbind_to (count
, proc
);
1222 /* This function is the unwind_protect form for Fstart_process. If
1223 PROC doesn't have its pid set, then we know someone has signaled
1224 an error and the process wasn't started successfully, so we should
1225 remove it from the process list. */
1227 start_process_unwind (proc
)
1230 if (!PROCESSP (proc
))
1233 /* Was PROC started successfully? */
1234 if (XINT (XPROCESS (proc
)->pid
) <= 0)
1235 remove_process (proc
);
1241 create_process_1 (timer
)
1242 struct atimer
*timer
;
1244 /* Nothing to do. */
1248 #if 0 /* This doesn't work; see the note before sigchld_handler. */
1251 /* Mimic blocking of signals on system V, which doesn't really have it. */
1253 /* Nonzero means we got a SIGCHLD when it was supposed to be blocked. */
1254 int sigchld_deferred
;
1257 create_process_sigchld ()
1259 signal (SIGCHLD
, create_process_sigchld
);
1261 sigchld_deferred
= 1;
1267 #ifndef VMS /* VMS version of this function is in vmsproc.c. */
1269 create_process (process
, new_argv
, current_dir
)
1270 Lisp_Object process
;
1272 Lisp_Object current_dir
;
1274 int pid
, inchannel
, outchannel
;
1276 #ifdef POSIX_SIGNALS
1279 struct sigaction sigint_action
;
1280 struct sigaction sigquit_action
;
1282 struct sigaction sighup_action
;
1284 #else /* !POSIX_SIGNALS */
1287 SIGTYPE (*sigchld
)();
1290 #endif /* !POSIX_SIGNALS */
1291 /* Use volatile to protect variables from being clobbered by longjmp. */
1292 volatile int forkin
, forkout
;
1293 volatile int pty_flag
= 0;
1294 extern char **environ
;
1295 Lisp_Object buffer
= XPROCESS (process
)->buffer
;
1297 inchannel
= outchannel
= -1;
1300 if (!NILP (Vprocess_connection_type
))
1301 outchannel
= inchannel
= allocate_pty ();
1306 /* On USG systems it does not work to open the pty's tty here
1307 and then close and reopen it in the child. */
1309 /* Don't let this terminal become our controlling terminal
1310 (in case we don't have one). */
1311 forkout
= forkin
= emacs_open (pty_name
, O_RDWR
| O_NOCTTY
, 0);
1313 forkout
= forkin
= emacs_open (pty_name
, O_RDWR
, 0);
1316 report_file_error ("Opening pty", Qnil
);
1318 forkin
= forkout
= -1;
1319 #endif /* not USG */
1323 #endif /* HAVE_PTYS */
1326 if (socketpair (AF_UNIX
, SOCK_STREAM
, 0, sv
) < 0)
1327 report_file_error ("Opening socketpair", Qnil
);
1328 outchannel
= inchannel
= sv
[0];
1329 forkout
= forkin
= sv
[1];
1331 #else /* not SKTPAIR */
1336 report_file_error ("Creating pipe", Qnil
);
1342 emacs_close (inchannel
);
1343 emacs_close (forkout
);
1344 report_file_error ("Creating pipe", Qnil
);
1349 #endif /* not SKTPAIR */
1352 /* Replaced by close_process_descs */
1353 set_exclusive_use (inchannel
);
1354 set_exclusive_use (outchannel
);
1357 /* Stride people say it's a mystery why this is needed
1358 as well as the O_NDELAY, but that it fails without this. */
1359 #if defined (STRIDE) || (defined (pfa) && defined (HAVE_PTYS))
1362 ioctl (inchannel
, FIONBIO
, &one
);
1367 fcntl (inchannel
, F_SETFL
, O_NONBLOCK
);
1368 fcntl (outchannel
, F_SETFL
, O_NONBLOCK
);
1371 fcntl (inchannel
, F_SETFL
, O_NDELAY
);
1372 fcntl (outchannel
, F_SETFL
, O_NDELAY
);
1376 /* Record this as an active process, with its channels.
1377 As a result, child_setup will close Emacs's side of the pipes. */
1378 chan_process
[inchannel
] = process
;
1379 XSETINT (XPROCESS (process
)->infd
, inchannel
);
1380 XSETINT (XPROCESS (process
)->outfd
, outchannel
);
1381 /* Record the tty descriptor used in the subprocess. */
1383 XPROCESS (process
)->subtty
= Qnil
;
1385 XSETFASTINT (XPROCESS (process
)->subtty
, forkin
);
1386 XPROCESS (process
)->pty_flag
= (pty_flag
? Qt
: Qnil
);
1387 XPROCESS (process
)->status
= Qrun
;
1388 if (!proc_decode_coding_system
[inchannel
])
1389 proc_decode_coding_system
[inchannel
]
1390 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
1391 setup_coding_system (XPROCESS (process
)->decode_coding_system
,
1392 proc_decode_coding_system
[inchannel
]);
1393 if (!proc_encode_coding_system
[outchannel
])
1394 proc_encode_coding_system
[outchannel
]
1395 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
1396 setup_coding_system (XPROCESS (process
)->encode_coding_system
,
1397 proc_encode_coding_system
[outchannel
]);
1399 if ((!NILP (buffer
) && NILP (XBUFFER (buffer
)->enable_multibyte_characters
))
1400 || (NILP (buffer
) && NILP (buffer_defaults
.enable_multibyte_characters
)))
1402 /* In unibyte mode, character code conversion should not take
1403 place but EOL conversion should. So, setup raw-text or one
1404 of the subsidiary according to the information just setup. */
1405 if (!NILP (XPROCESS (process
)->decode_coding_system
))
1406 setup_raw_text_coding_system (proc_decode_coding_system
[inchannel
]);
1407 if (!NILP (XPROCESS (process
)->encode_coding_system
))
1408 setup_raw_text_coding_system (proc_encode_coding_system
[outchannel
]);
1411 if (CODING_REQUIRE_ENCODING (proc_encode_coding_system
[outchannel
]))
1413 /* Here we encode arguments by the coding system used for
1414 sending data to the process. We don't support using
1415 different coding systems for encoding arguments and for
1416 encoding data sent to the process. */
1417 struct gcpro gcpro1
;
1419 struct coding_system
*coding
= proc_encode_coding_system
[outchannel
];
1421 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
1423 while (new_argv
[i
] != 0)
1425 int len
= strlen (new_argv
[i
]);
1426 int size
= encoding_buffer_size (coding
, len
);
1427 unsigned char *buf
= (unsigned char *) alloca (size
);
1429 encode_coding (coding
, (unsigned char *)new_argv
[i
], buf
, len
, size
);
1430 buf
[coding
->produced
] = 0;
1431 /* We don't have to free new_argv[i] because it points to a
1432 Lisp string given as an argument to `start-process'. */
1433 new_argv
[i
++] = (char *) buf
;
1436 coding
->mode
&= ~CODING_MODE_LAST_BLOCK
;
1439 /* Delay interrupts until we have a chance to store
1440 the new fork's pid in its process structure */
1441 #ifdef POSIX_SIGNALS
1442 sigemptyset (&blocked
);
1444 sigaddset (&blocked
, SIGCHLD
);
1447 /* On many hosts (e.g. Solaris 2.4), if a vforked child calls `signal',
1448 this sets the parent's signal handlers as well as the child's.
1449 So delay all interrupts whose handlers the child might munge,
1450 and record the current handlers so they can be restored later. */
1451 sigaddset (&blocked
, SIGINT
); sigaction (SIGINT
, 0, &sigint_action
);
1452 sigaddset (&blocked
, SIGQUIT
); sigaction (SIGQUIT
, 0, &sigquit_action
);
1454 sigaddset (&blocked
, SIGHUP
); sigaction (SIGHUP
, 0, &sighup_action
);
1456 #endif /* HAVE_VFORK */
1457 sigprocmask (SIG_BLOCK
, &blocked
, &procmask
);
1458 #else /* !POSIX_SIGNALS */
1462 #else /* not BSD4_1 */
1463 #if defined (BSD_SYSTEM) || defined (UNIPLUS) || defined (HPUX)
1464 sigsetmask (sigmask (SIGCHLD
));
1465 #else /* ordinary USG */
1467 sigchld_deferred
= 0;
1468 sigchld
= signal (SIGCHLD
, create_process_sigchld
);
1470 #endif /* ordinary USG */
1471 #endif /* not BSD4_1 */
1472 #endif /* SIGCHLD */
1473 #endif /* !POSIX_SIGNALS */
1475 FD_SET (inchannel
, &input_wait_mask
);
1476 FD_SET (inchannel
, &non_keyboard_wait_mask
);
1477 if (inchannel
> max_process_desc
)
1478 max_process_desc
= inchannel
;
1480 /* Until we store the proper pid, enable sigchld_handler
1481 to recognize an unknown pid as standing for this process.
1482 It is very important not to let this `marker' value stay
1483 in the table after this function has returned; if it does
1484 it might cause call-process to hang and subsequent asynchronous
1485 processes to get their return values scrambled. */
1486 XSETINT (XPROCESS (process
)->pid
, -1);
1491 /* child_setup must clobber environ on systems with true vfork.
1492 Protect it from permanent change. */
1493 char **save_environ
= environ
;
1495 current_dir
= ENCODE_FILE (current_dir
);
1500 #endif /* not WINDOWSNT */
1502 int xforkin
= forkin
;
1503 int xforkout
= forkout
;
1505 #if 0 /* This was probably a mistake--it duplicates code later on,
1506 but fails to handle all the cases. */
1507 /* Make sure SIGCHLD is not blocked in the child. */
1508 sigsetmask (SIGEMPTYMASK
);
1511 /* Make the pty be the controlling terminal of the process. */
1513 /* First, disconnect its current controlling terminal. */
1515 /* We tried doing setsid only if pty_flag, but it caused
1516 process_set_signal to fail on SGI when using a pipe. */
1518 /* Make the pty's terminal the controlling terminal. */
1522 /* We ignore the return value
1523 because faith@cs.unc.edu says that is necessary on Linux. */
1524 ioctl (xforkin
, TIOCSCTTY
, 0);
1527 #else /* not HAVE_SETSID */
1529 /* It's very important to call setpgrp here and no time
1530 afterwards. Otherwise, we lose our controlling tty which
1531 is set when we open the pty. */
1534 #endif /* not HAVE_SETSID */
1535 #if defined (HAVE_TERMIOS) && defined (LDISC1)
1536 if (pty_flag
&& xforkin
>= 0)
1539 tcgetattr (xforkin
, &t
);
1541 if (tcsetattr (xforkin
, TCSANOW
, &t
) < 0)
1542 emacs_write (1, "create_process/tcsetattr LDISC1 failed\n", 39);
1545 #if defined (NTTYDISC) && defined (TIOCSETD)
1546 if (pty_flag
&& xforkin
>= 0)
1548 /* Use new line discipline. */
1549 int ldisc
= NTTYDISC
;
1550 ioctl (xforkin
, TIOCSETD
, &ldisc
);
1555 /* In 4.3BSD, the TIOCSPGRP bug has been fixed, and now you
1556 can do TIOCSPGRP only to the process's controlling tty. */
1559 /* I wonder: would just ioctl (0, TIOCNOTTY, 0) work here?
1560 I can't test it since I don't have 4.3. */
1561 int j
= emacs_open ("/dev/tty", O_RDWR
, 0);
1562 ioctl (j
, TIOCNOTTY
, 0);
1565 /* In order to get a controlling terminal on some versions
1566 of BSD, it is necessary to put the process in pgrp 0
1567 before it opens the terminal. */
1575 #endif /* TIOCNOTTY */
1577 #if !defined (RTU) && !defined (UNIPLUS) && !defined (DONT_REOPEN_PTY)
1578 /*** There is a suggestion that this ought to be a
1579 conditional on TIOCSPGRP,
1580 or !(defined (HAVE_SETSID) && defined (TIOCSCTTY)).
1581 Trying the latter gave the wrong results on Debian GNU/Linux 1.1;
1582 that system does seem to need this code, even though
1583 both HAVE_SETSID and TIOCSCTTY are defined. */
1584 /* Now close the pty (if we had it open) and reopen it.
1585 This makes the pty the controlling terminal of the subprocess. */
1588 #ifdef SET_CHILD_PTY_PGRP
1589 int pgrp
= getpid ();
1592 /* I wonder if emacs_close (emacs_open (pty_name, ...))
1595 emacs_close (xforkin
);
1596 xforkout
= xforkin
= emacs_open (pty_name
, O_RDWR
, 0);
1600 emacs_write (1, "Couldn't open the pty terminal ", 31);
1601 emacs_write (1, pty_name
, strlen (pty_name
));
1602 emacs_write (1, "\n", 1);
1606 #ifdef SET_CHILD_PTY_PGRP
1607 ioctl (xforkin
, TIOCSPGRP
, &pgrp
);
1608 ioctl (xforkout
, TIOCSPGRP
, &pgrp
);
1611 #endif /* not UNIPLUS and not RTU and not DONT_REOPEN_PTY */
1613 #ifdef SETUP_SLAVE_PTY
1618 #endif /* SETUP_SLAVE_PTY */
1620 /* On AIX, we've disabled SIGHUP above once we start a child on a pty.
1621 Now reenable it in the child, so it will die when we want it to. */
1623 signal (SIGHUP
, SIG_DFL
);
1625 #endif /* HAVE_PTYS */
1627 signal (SIGINT
, SIG_DFL
);
1628 signal (SIGQUIT
, SIG_DFL
);
1630 /* Stop blocking signals in the child. */
1631 #ifdef POSIX_SIGNALS
1632 sigprocmask (SIG_SETMASK
, &procmask
, 0);
1633 #else /* !POSIX_SIGNALS */
1637 #else /* not BSD4_1 */
1638 #if defined (BSD_SYSTEM) || defined (UNIPLUS) || defined (HPUX)
1639 sigsetmask (SIGEMPTYMASK
);
1640 #else /* ordinary USG */
1642 signal (SIGCHLD
, sigchld
);
1644 #endif /* ordinary USG */
1645 #endif /* not BSD4_1 */
1646 #endif /* SIGCHLD */
1647 #endif /* !POSIX_SIGNALS */
1650 child_setup_tty (xforkout
);
1652 pid
= child_setup (xforkin
, xforkout
, xforkout
,
1653 new_argv
, 1, current_dir
);
1654 #else /* not WINDOWSNT */
1655 child_setup (xforkin
, xforkout
, xforkout
,
1656 new_argv
, 1, current_dir
);
1657 #endif /* not WINDOWSNT */
1659 environ
= save_environ
;
1664 /* This runs in the Emacs process. */
1668 emacs_close (forkin
);
1669 if (forkin
!= forkout
&& forkout
>= 0)
1670 emacs_close (forkout
);
1674 /* vfork succeeded. */
1675 XSETFASTINT (XPROCESS (process
)->pid
, pid
);
1678 register_child (pid
, inchannel
);
1679 #endif /* WINDOWSNT */
1681 /* If the subfork execv fails, and it exits,
1682 this close hangs. I don't know why.
1683 So have an interrupt jar it loose. */
1685 struct atimer
*timer
;
1689 EMACS_SET_SECS_USECS (offset
, 1, 0);
1690 timer
= start_atimer (ATIMER_RELATIVE
, offset
, create_process_1
, 0);
1692 XPROCESS (process
)->subtty
= Qnil
;
1694 emacs_close (forkin
);
1696 cancel_atimer (timer
);
1700 if (forkin
!= forkout
&& forkout
>= 0)
1701 emacs_close (forkout
);
1705 XPROCESS (process
)->tty_name
= build_string (pty_name
);
1708 XPROCESS (process
)->tty_name
= Qnil
;
1711 /* Restore the signal state whether vfork succeeded or not.
1712 (We will signal an error, below, if it failed.) */
1713 #ifdef POSIX_SIGNALS
1715 /* Restore the parent's signal handlers. */
1716 sigaction (SIGINT
, &sigint_action
, 0);
1717 sigaction (SIGQUIT
, &sigquit_action
, 0);
1719 sigaction (SIGHUP
, &sighup_action
, 0);
1721 #endif /* HAVE_VFORK */
1722 /* Stop blocking signals in the parent. */
1723 sigprocmask (SIG_SETMASK
, &procmask
, 0);
1724 #else /* !POSIX_SIGNALS */
1728 #else /* not BSD4_1 */
1729 #if defined (BSD_SYSTEM) || defined (UNIPLUS) || defined (HPUX)
1730 sigsetmask (SIGEMPTYMASK
);
1731 #else /* ordinary USG */
1733 signal (SIGCHLD
, sigchld
);
1734 /* Now really handle any of these signals
1735 that came in during this function. */
1736 if (sigchld_deferred
)
1737 kill (getpid (), SIGCHLD
);
1739 #endif /* ordinary USG */
1740 #endif /* not BSD4_1 */
1741 #endif /* SIGCHLD */
1742 #endif /* !POSIX_SIGNALS */
1744 /* Now generate the error if vfork failed. */
1746 report_file_error ("Doing vfork", Qnil
);
1748 #endif /* not VMS */
1752 /* open a TCP network connection to a given HOST/SERVICE. Treated
1753 exactly like a normal process when reading and writing. Only
1754 differences are in status display and process deletion. A network
1755 connection has no PID; you cannot signal it. All you can do is
1756 deactivate and close it via delete-process */
1758 DEFUN ("open-network-stream", Fopen_network_stream
, Sopen_network_stream
,
1760 "Open a TCP connection for a service to a host.\n\
1761 Returns a subprocess-object to represent the connection.\n\
1762 Input and output work as for subprocesses; `delete-process' closes it.\n\
1763 Args are NAME BUFFER HOST SERVICE.\n\
1764 NAME is name for process. It is modified if necessary to make it unique.\n\
1765 BUFFER is the buffer (or buffer-name) to associate with the process.\n\
1766 Process output goes at end of that buffer, unless you specify\n\
1767 an output stream or filter function to handle the output.\n\
1768 BUFFER may be also nil, meaning that this process is not associated\n\
1770 Third arg is name of the host to connect to, or its IP address.\n\
1771 Fourth arg SERVICE is name of the service desired, or an integer\n\
1772 specifying a port number to connect to.")
1773 (name
, buffer
, host
, service
)
1774 Lisp_Object name
, buffer
, host
, service
;
1777 #ifndef HAVE_GETADDRINFO
1778 struct sockaddr_in address
;
1779 struct servent
*svc_info
;
1780 struct hostent
*host_info_ptr
, host_info
;
1781 char *(addr_list
[2]);
1782 IN_ADDR numeric_addr
;
1784 #else /* HAVE_GETADDRINFO */
1785 struct addrinfo hints
, *res
, *lres
;
1788 char *portstring
, portbuf
[128];
1789 #endif /* HAVE_GETADDRINFO */
1790 int s
= -1, outch
, inch
;
1791 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1793 int count
= specpdl_ptr
- specpdl
;
1797 /* Ensure socket support is loaded if available. */
1798 init_winsock (TRUE
);
1801 GCPRO4 (name
, buffer
, host
, service
);
1802 CHECK_STRING (name
, 0);
1803 CHECK_STRING (host
, 0);
1805 #ifdef HAVE_GETADDRINFO
1807 * SERVICE can either be a string or int.
1808 * Convert to a C string for later use by getaddrinfo.
1810 if (INTEGERP (service
))
1812 sprintf (portbuf
, "%d", XINT (service
));
1813 portstring
= portbuf
;
1817 CHECK_STRING (service
, 0);
1818 portstring
= XSTRING (service
)->data
;
1820 #else /* ! HAVE_GETADDRINFO */
1821 if (INTEGERP (service
))
1822 port
= htons ((unsigned short) XINT (service
));
1825 CHECK_STRING (service
, 0);
1826 svc_info
= getservbyname (XSTRING (service
)->data
, "tcp");
1828 error ("Unknown service \"%s\"", XSTRING (service
)->data
);
1829 port
= svc_info
->s_port
;
1831 #endif /* ! HAVE_GETADDRINFO */
1834 /* Slow down polling to every ten seconds.
1835 Some kernels have a bug which causes retrying connect to fail
1836 after a connect. Polling can interfere with gethostbyname too. */
1837 #ifdef POLL_FOR_INPUT
1838 record_unwind_protect (unwind_stop_other_atimers
, Qnil
);
1839 bind_polling_period (10);
1843 #ifdef HAVE_GETADDRINFO
1847 memset (&hints
, 0, sizeof (hints
));
1849 hints
.ai_family
= AF_UNSPEC
;
1850 hints
.ai_socktype
= SOCK_STREAM
;
1851 hints
.ai_protocol
= 0;
1852 ret
= getaddrinfo (XSTRING (host
)->data
, portstring
, &hints
, &res
);
1855 error ("%s/%s %s", XSTRING (host
)->data
, portstring
,
1862 count1
= specpdl_ptr
- specpdl
;
1863 record_unwind_protect (close_file_unwind
, make_number (s
));
1865 for (lres
= res
; lres
; lres
= lres
->ai_next
)
1867 s
= socket (lres
->ai_family
, lres
->ai_socktype
, lres
->ai_protocol
);
1871 /* Kernel bugs (on Ultrix at least) cause lossage (not just EINTR)
1872 when connect is interrupted. So let's not let it get interrupted.
1873 Note we do not turn off polling, because polling is only used
1874 when not interrupt_input, and thus not normally used on the systems
1875 which have this bug. On systems which use polling, there's no way
1876 to quit if polling is turned off. */
1877 if (interrupt_input
)
1883 ret
= connect (s
, lres
->ai_addr
, lres
->ai_addrlen
);
1893 if (interrupt_input
)
1897 report_file_error ("connection failed",
1898 Fcons (host
, Fcons (name
, Qnil
)));
1900 #else /* ! HAVE_GETADDRINFO */
1911 host_info_ptr
= gethostbyname (XSTRING (host
)->data
);
1915 if (! (host_info_ptr
== 0 && h_errno
== TRY_AGAIN
))
1919 Fsleep_for (make_number (1), Qnil
);
1921 if (host_info_ptr
== 0)
1922 /* Attempt to interpret host as numeric inet address */
1924 numeric_addr
= inet_addr ((char *) XSTRING (host
)->data
);
1925 if (NUMERIC_ADDR_ERROR
)
1926 error ("Unknown host \"%s\"", XSTRING (host
)->data
);
1928 host_info_ptr
= &host_info
;
1929 host_info
.h_name
= 0;
1930 host_info
.h_aliases
= 0;
1931 host_info
.h_addrtype
= AF_INET
;
1933 /* Older machines have only one address slot called h_addr.
1934 Newer machines have h_addr_list, but #define h_addr to
1935 be its first element. */
1936 host_info
.h_addr_list
= &(addr_list
[0]);
1938 host_info
.h_addr
= (char*)(&numeric_addr
);
1940 /* numeric_addr isn't null-terminated; it has fixed length. */
1941 host_info
.h_length
= sizeof (numeric_addr
);
1944 bzero (&address
, sizeof address
);
1945 bcopy (host_info_ptr
->h_addr
, (char *) &address
.sin_addr
,
1946 host_info_ptr
->h_length
);
1947 address
.sin_family
= host_info_ptr
->h_addrtype
;
1948 address
.sin_port
= port
;
1950 s
= socket (host_info_ptr
->h_addrtype
, SOCK_STREAM
, 0);
1952 report_file_error ("error creating socket", Fcons (name
, Qnil
));
1954 count1
= specpdl_ptr
- specpdl
;
1955 record_unwind_protect (close_file_unwind
, make_number (s
));
1957 /* Kernel bugs (on Ultrix at least) cause lossage (not just EINTR)
1958 when connect is interrupted. So let's not let it get interrupted.
1959 Note we do not turn off polling, because polling is only used
1960 when not interrupt_input, and thus not normally used on the systems
1961 which have this bug. On systems which use polling, there's no way
1962 to quit if polling is turned off. */
1963 if (interrupt_input
)
1971 if (connect (s
, (struct sockaddr
*) &address
, sizeof address
) == -1
1972 && errno
!= EISCONN
)
1980 if (errno
== EADDRINUSE
&& retry
< 20)
1982 /* A delay here is needed on some FreeBSD systems,
1983 and it is harmless, since this retrying takes time anyway
1984 and should be infrequent. */
1985 Fsleep_for (make_number (1), Qnil
);
1990 /* Discard the unwind protect. */
1991 specpdl_ptr
= specpdl
+ count1
;
1995 if (interrupt_input
)
1999 report_file_error ("connection failed",
2000 Fcons (host
, Fcons (name
, Qnil
)));
2002 #endif /* ! HAVE_GETADDRINFO */
2006 /* Discard the unwind protect. */
2007 specpdl_ptr
= specpdl
+ count1
;
2009 #ifdef POLL_FOR_INPUT
2010 unbind_to (count
, Qnil
);
2013 if (interrupt_input
)
2017 s
= connect_server (0);
2019 report_file_error ("error creating socket", Fcons (name
, Qnil
));
2020 send_command (s
, C_PORT
, 0, "%s:%d", XSTRING (host
)->data
, ntohs (port
));
2021 send_command (s
, C_DUMB
, 1, 0);
2028 buffer
= Fget_buffer_create (buffer
);
2029 proc
= make_process (name
);
2031 chan_process
[inch
] = proc
;
2034 fcntl (inch
, F_SETFL
, O_NONBLOCK
);
2037 fcntl (inch
, F_SETFL
, O_NDELAY
);
2041 XPROCESS (proc
)->childp
= Fcons (host
, Fcons (service
, Qnil
));
2042 XPROCESS (proc
)->command_channel_p
= Qnil
;
2043 XPROCESS (proc
)->buffer
= buffer
;
2044 XPROCESS (proc
)->sentinel
= Qnil
;
2045 XPROCESS (proc
)->filter
= Qnil
;
2046 XPROCESS (proc
)->command
= Qnil
;
2047 XPROCESS (proc
)->pid
= Qnil
;
2048 XSETINT (XPROCESS (proc
)->infd
, inch
);
2049 XSETINT (XPROCESS (proc
)->outfd
, outch
);
2050 XPROCESS (proc
)->status
= Qrun
;
2051 FD_SET (inch
, &input_wait_mask
);
2052 FD_SET (inch
, &non_keyboard_wait_mask
);
2053 if (inch
> max_process_desc
)
2054 max_process_desc
= inch
;
2057 /* Setup coding systems for communicating with the network stream. */
2058 struct gcpro gcpro1
;
2059 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
2060 Lisp_Object coding_systems
= Qt
;
2061 Lisp_Object args
[5], val
;
2063 if (!NILP (Vcoding_system_for_read
))
2064 val
= Vcoding_system_for_read
;
2065 else if ((!NILP (buffer
) && NILP (XBUFFER (buffer
)->enable_multibyte_characters
))
2066 || (NILP (buffer
) && NILP (buffer_defaults
.enable_multibyte_characters
)))
2067 /* We dare not decode end-of-line format by setting VAL to
2068 Qraw_text, because the existing Emacs Lisp libraries
2069 assume that they receive bare code including a sequene of
2074 args
[0] = Qopen_network_stream
, args
[1] = name
,
2075 args
[2] = buffer
, args
[3] = host
, args
[4] = service
;
2077 coding_systems
= Ffind_operation_coding_system (5, args
);
2079 if (CONSP (coding_systems
))
2080 val
= XCAR (coding_systems
);
2081 else if (CONSP (Vdefault_process_coding_system
))
2082 val
= XCAR (Vdefault_process_coding_system
);
2086 XPROCESS (proc
)->decode_coding_system
= val
;
2088 if (!NILP (Vcoding_system_for_write
))
2089 val
= Vcoding_system_for_write
;
2090 else if (NILP (current_buffer
->enable_multibyte_characters
))
2094 if (EQ (coding_systems
, Qt
))
2096 args
[0] = Qopen_network_stream
, args
[1] = name
,
2097 args
[2] = buffer
, args
[3] = host
, args
[4] = service
;
2099 coding_systems
= Ffind_operation_coding_system (5, args
);
2102 if (CONSP (coding_systems
))
2103 val
= XCDR (coding_systems
);
2104 else if (CONSP (Vdefault_process_coding_system
))
2105 val
= XCDR (Vdefault_process_coding_system
);
2109 XPROCESS (proc
)->encode_coding_system
= val
;
2112 if (!proc_decode_coding_system
[inch
])
2113 proc_decode_coding_system
[inch
]
2114 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
2115 setup_coding_system (XPROCESS (proc
)->decode_coding_system
,
2116 proc_decode_coding_system
[inch
]);
2117 if (!proc_encode_coding_system
[outch
])
2118 proc_encode_coding_system
[outch
]
2119 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
2120 setup_coding_system (XPROCESS (proc
)->encode_coding_system
,
2121 proc_encode_coding_system
[outch
]);
2123 XPROCESS (proc
)->decoding_buf
= make_uninit_string (0);
2124 XPROCESS (proc
)->decoding_carryover
= make_number (0);
2125 XPROCESS (proc
)->encoding_buf
= make_uninit_string (0);
2126 XPROCESS (proc
)->encoding_carryover
= make_number (0);
2128 XPROCESS (proc
)->inherit_coding_system_flag
2129 = (NILP (buffer
) || !inherit_process_coding_system
2135 #endif /* HAVE_SOCKETS */
2138 deactivate_process (proc
)
2141 register int inchannel
, outchannel
;
2142 register struct Lisp_Process
*p
= XPROCESS (proc
);
2144 inchannel
= XINT (p
->infd
);
2145 outchannel
= XINT (p
->outfd
);
2149 /* Beware SIGCHLD hereabouts. */
2150 flush_pending_output (inchannel
);
2153 VMS_PROC_STUFF
*get_vms_process_pointer (), *vs
;
2154 sys$
dassgn (outchannel
);
2155 vs
= get_vms_process_pointer (p
->pid
);
2157 give_back_vms_process_stuff (vs
);
2160 emacs_close (inchannel
);
2161 if (outchannel
>= 0 && outchannel
!= inchannel
)
2162 emacs_close (outchannel
);
2165 XSETINT (p
->infd
, -1);
2166 XSETINT (p
->outfd
, -1);
2167 chan_process
[inchannel
] = Qnil
;
2168 FD_CLR (inchannel
, &input_wait_mask
);
2169 FD_CLR (inchannel
, &non_keyboard_wait_mask
);
2170 if (inchannel
== max_process_desc
)
2173 /* We just closed the highest-numbered process input descriptor,
2174 so recompute the highest-numbered one now. */
2175 max_process_desc
= 0;
2176 for (i
= 0; i
< MAXDESC
; i
++)
2177 if (!NILP (chan_process
[i
]))
2178 max_process_desc
= i
;
2183 /* Close all descriptors currently in use for communication
2184 with subprocess. This is used in a newly-forked subprocess
2185 to get rid of irrelevant descriptors. */
2188 close_process_descs ()
2192 for (i
= 0; i
< MAXDESC
; i
++)
2194 Lisp_Object process
;
2195 process
= chan_process
[i
];
2196 if (!NILP (process
))
2198 int in
= XINT (XPROCESS (process
)->infd
);
2199 int out
= XINT (XPROCESS (process
)->outfd
);
2202 if (out
>= 0 && in
!= out
)
2209 DEFUN ("accept-process-output", Faccept_process_output
, Saccept_process_output
,
2211 "Allow any pending output from subprocesses to be read by Emacs.\n\
2212 It is read into the process' buffers or given to their filter functions.\n\
2213 Non-nil arg PROCESS means do not return until some output has been received\n\
2215 Non-nil second arg TIMEOUT and third arg TIMEOUT-MSECS are number of\n\
2216 seconds and microseconds to wait; return after that much time whether\n\
2217 or not there is input.\n\
2218 Return non-nil iff we received any output before the timeout expired.")
2219 (process
, timeout
, timeout_msecs
)
2220 register Lisp_Object process
, timeout
, timeout_msecs
;
2225 if (! NILP (process
))
2226 CHECK_PROCESS (process
, 0);
2228 if (! NILP (timeout_msecs
))
2230 CHECK_NUMBER (timeout_msecs
, 2);
2231 useconds
= XINT (timeout_msecs
);
2232 if (!INTEGERP (timeout
))
2233 XSETINT (timeout
, 0);
2236 int carry
= useconds
/ 1000000;
2238 XSETINT (timeout
, XINT (timeout
) + carry
);
2239 useconds
-= carry
* 1000000;
2241 /* I think this clause is necessary because C doesn't
2242 guarantee a particular rounding direction for negative
2246 XSETINT (timeout
, XINT (timeout
) - 1);
2247 useconds
+= 1000000;
2254 if (! NILP (timeout
))
2256 CHECK_NUMBER (timeout
, 1);
2257 seconds
= XINT (timeout
);
2258 if (seconds
< 0 || (seconds
== 0 && useconds
== 0))
2270 XSETFASTINT (process
, 0);
2273 (wait_reading_process_input (seconds
, useconds
, process
, 0)
2277 /* This variable is different from waiting_for_input in keyboard.c.
2278 It is used to communicate to a lisp process-filter/sentinel (via the
2279 function Fwaiting_for_user_input_p below) whether emacs was waiting
2280 for user-input when that process-filter was called.
2281 waiting_for_input cannot be used as that is by definition 0 when
2282 lisp code is being evalled.
2283 This is also used in record_asynch_buffer_change.
2284 For that purpose, this must be 0
2285 when not inside wait_reading_process_input. */
2286 static int waiting_for_user_input_p
;
2288 /* This is here so breakpoints can be put on it. */
2290 wait_reading_process_input_1 ()
2294 /* Read and dispose of subprocess output while waiting for timeout to
2295 elapse and/or keyboard input to be available.
2298 timeout in seconds, or
2299 zero for no limit, or
2300 -1 means gobble data immediately available but don't wait for any.
2303 an additional duration to wait, measured in microseconds.
2304 If this is nonzero and time_limit is 0, then the timeout
2305 consists of MICROSECS only.
2307 READ_KBD is a lisp value:
2308 0 to ignore keyboard input, or
2309 1 to return when input is available, or
2310 -1 meaning caller will actually read the input, so don't throw to
2311 the quit handler, or
2312 a cons cell, meaning wait until its car is non-nil
2313 (and gobble terminal input into the buffer if any arrives), or
2314 a process object, meaning wait until something arrives from that
2315 process. The return value is true iff we read some input from
2318 DO_DISPLAY != 0 means redisplay should be done to show subprocess
2319 output that arrives.
2321 If READ_KBD is a pointer to a struct Lisp_Process, then the
2322 function returns true iff we received input from that process
2323 before the timeout elapsed.
2324 Otherwise, return true iff we received input from any process. */
2327 wait_reading_process_input (time_limit
, microsecs
, read_kbd
, do_display
)
2328 int time_limit
, microsecs
;
2329 Lisp_Object read_kbd
;
2332 register int channel
, nfds
;
2333 static SELECT_TYPE Available
;
2336 EMACS_TIME timeout
, end_time
;
2338 int wait_channel
= -1;
2339 struct Lisp_Process
*wait_proc
= 0;
2340 int got_some_input
= 0;
2341 Lisp_Object
*wait_for_cell
= 0;
2343 FD_ZERO (&Available
);
2345 /* If read_kbd is a process to watch, set wait_proc and wait_channel
2347 if (PROCESSP (read_kbd
))
2349 wait_proc
= XPROCESS (read_kbd
);
2350 wait_channel
= XINT (wait_proc
->infd
);
2351 XSETFASTINT (read_kbd
, 0);
2354 /* If waiting for non-nil in a cell, record where. */
2355 if (CONSP (read_kbd
))
2357 wait_for_cell
= &XCAR (read_kbd
);
2358 XSETFASTINT (read_kbd
, 0);
2361 waiting_for_user_input_p
= XINT (read_kbd
);
2363 /* Since we may need to wait several times,
2364 compute the absolute time to return at. */
2365 if (time_limit
|| microsecs
)
2367 EMACS_GET_TIME (end_time
);
2368 EMACS_SET_SECS_USECS (timeout
, time_limit
, microsecs
);
2369 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
2372 /* AlainF 5-Jul-1996
2373 HP-UX 10.10 seem to have problems with signals coming in
2374 Causes "poll: interrupted system call" messages when Emacs is run
2376 Turn off periodic alarms (in case they are in use) */
2377 turn_on_atimers (0);
2382 int timeout_reduced_for_timers
= 0;
2384 /* If calling from keyboard input, do not quit
2385 since we want to return C-g as an input character.
2386 Otherwise, do pending quit if requested. */
2387 if (XINT (read_kbd
) >= 0)
2390 /* Exit now if the cell we're waiting for became non-nil. */
2391 if (wait_for_cell
&& ! NILP (*wait_for_cell
))
2394 /* Compute time from now till when time limit is up */
2395 /* Exit if already run out */
2396 if (time_limit
== -1)
2398 /* -1 specified for timeout means
2399 gobble output available now
2400 but don't wait at all. */
2402 EMACS_SET_SECS_USECS (timeout
, 0, 0);
2404 else if (time_limit
|| microsecs
)
2406 EMACS_GET_TIME (timeout
);
2407 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
2408 if (EMACS_TIME_NEG_P (timeout
))
2413 EMACS_SET_SECS_USECS (timeout
, 100000, 0);
2416 /* Normally we run timers here.
2417 But not if wait_for_cell; in those cases,
2418 the wait is supposed to be short,
2419 and those callers cannot handle running arbitrary Lisp code here. */
2420 if (! wait_for_cell
)
2422 EMACS_TIME timer_delay
;
2426 old_timers_run
= timers_run
;
2427 timer_delay
= timer_check (1);
2428 if (timers_run
!= old_timers_run
&& do_display
)
2430 redisplay_preserve_echo_area ();
2431 /* We must retry, since a timer may have requeued itself
2432 and that could alter the time_delay. */
2436 /* If there is unread keyboard input, also return. */
2437 if (XINT (read_kbd
) != 0
2438 && requeued_events_pending_p ())
2441 if (! EMACS_TIME_NEG_P (timer_delay
) && time_limit
!= -1)
2443 EMACS_TIME difference
;
2444 EMACS_SUB_TIME (difference
, timer_delay
, timeout
);
2445 if (EMACS_TIME_NEG_P (difference
))
2447 timeout
= timer_delay
;
2448 timeout_reduced_for_timers
= 1;
2451 /* If time_limit is -1, we are not going to wait at all. */
2452 else if (time_limit
!= -1)
2454 /* This is so a breakpoint can be put here. */
2455 wait_reading_process_input_1 ();
2459 /* Cause C-g and alarm signals to take immediate action,
2460 and cause input available signals to zero out timeout.
2462 It is important that we do this before checking for process
2463 activity. If we get a SIGCHLD after the explicit checks for
2464 process activity, timeout is the only way we will know. */
2465 if (XINT (read_kbd
) < 0)
2466 set_waiting_for_input (&timeout
);
2468 /* If status of something has changed, and no input is
2469 available, notify the user of the change right away. After
2470 this explicit check, we'll let the SIGCHLD handler zap
2471 timeout to get our attention. */
2472 if (update_tick
!= process_tick
&& do_display
)
2474 Atemp
= input_wait_mask
;
2475 EMACS_SET_SECS_USECS (timeout
, 0, 0);
2476 if ((select (max (max_process_desc
, max_keyboard_desc
) + 1,
2477 &Atemp
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0,
2481 /* It's okay for us to do this and then continue with
2482 the loop, since timeout has already been zeroed out. */
2483 clear_waiting_for_input ();
2488 /* Don't wait for output from a non-running process. */
2489 if (wait_proc
!= 0 && !NILP (wait_proc
->raw_status_low
))
2490 update_status (wait_proc
);
2492 && ! EQ (wait_proc
->status
, Qrun
))
2494 int nread
, total_nread
= 0;
2496 clear_waiting_for_input ();
2497 XSETPROCESS (proc
, wait_proc
);
2499 /* Read data from the process, until we exhaust it. */
2500 while (XINT (wait_proc
->infd
) >= 0)
2502 nread
= read_process_output (proc
, XINT (wait_proc
->infd
));
2508 total_nread
+= nread
;
2510 else if (nread
== -1 && EIO
== errno
)
2514 else if (nread
== -1 && EAGAIN
== errno
)
2518 else if (nread
== -1 && EWOULDBLOCK
== errno
)
2522 if (total_nread
> 0 && do_display
)
2523 redisplay_preserve_echo_area ();
2528 /* Wait till there is something to do */
2531 Available
= non_process_wait_mask
;
2532 else if (! XINT (read_kbd
))
2533 Available
= non_keyboard_wait_mask
;
2535 Available
= input_wait_mask
;
2537 /* If frame size has changed or the window is newly mapped,
2538 redisplay now, before we start to wait. There is a race
2539 condition here; if a SIGIO arrives between now and the select
2540 and indicates that a frame is trashed, the select may block
2541 displaying a trashed screen. */
2542 if (frame_garbaged
&& do_display
)
2544 clear_waiting_for_input ();
2545 redisplay_preserve_echo_area ();
2546 if (XINT (read_kbd
) < 0)
2547 set_waiting_for_input (&timeout
);
2550 if (XINT (read_kbd
) && detect_input_pending ())
2553 FD_ZERO (&Available
);
2556 nfds
= select (max (max_process_desc
, max_keyboard_desc
) + 1,
2557 &Available
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0,
2562 /* Make C-g and alarm signals set flags again */
2563 clear_waiting_for_input ();
2565 /* If we woke up due to SIGWINCH, actually change size now. */
2566 do_pending_window_change (0);
2568 if (time_limit
&& nfds
== 0 && ! timeout_reduced_for_timers
)
2569 /* We wanted the full specified time, so return now. */
2573 if (xerrno
== EINTR
)
2574 FD_ZERO (&Available
);
2576 /* Ultrix select seems to return ENOMEM when it is
2577 interrupted. Treat it just like EINTR. Bleah. Note
2578 that we want to test for the "ultrix" CPP symbol, not
2579 "__ultrix__"; the latter is only defined under GCC, but
2580 not by DEC's bundled CC. -JimB */
2581 else if (xerrno
== ENOMEM
)
2582 FD_ZERO (&Available
);
2585 /* This happens for no known reason on ALLIANT.
2586 I am guessing that this is the right response. -- RMS. */
2587 else if (xerrno
== EFAULT
)
2588 FD_ZERO (&Available
);
2590 else if (xerrno
== EBADF
)
2593 /* AIX doesn't handle PTY closure the same way BSD does. On AIX,
2594 the child's closure of the pts gives the parent a SIGHUP, and
2595 the ptc file descriptor is automatically closed,
2596 yielding EBADF here or at select() call above.
2597 So, SIGHUP is ignored (see def of PTY_TTY_NAME_SPRINTF
2598 in m/ibmrt-aix.h), and here we just ignore the select error.
2599 Cleanup occurs c/o status_notify after SIGCLD. */
2600 FD_ZERO (&Available
); /* Cannot depend on values returned */
2606 error ("select error: %s", emacs_strerror (xerrno
));
2608 #if defined(sun) && !defined(USG5_4)
2609 else if (nfds
> 0 && keyboard_bit_set (&Available
)
2611 /* System sometimes fails to deliver SIGIO.
2613 David J. Mackenzie says that Emacs doesn't compile under
2614 Solaris if this code is enabled, thus the USG5_4 in the CPP
2615 conditional. "I haven't noticed any ill effects so far.
2616 If you find a Solaris expert somewhere, they might know
2618 kill (getpid (), SIGIO
);
2621 #if 0 /* When polling is used, interrupt_input is 0,
2622 so get_input_pending should read the input.
2623 So this should not be needed. */
2624 /* If we are using polling for input,
2625 and we see input available, make it get read now.
2626 Otherwise it might not actually get read for a second.
2627 And on hpux, since we turn off polling in wait_reading_process_input,
2628 it might never get read at all if we don't spend much time
2629 outside of wait_reading_process_input. */
2630 if (XINT (read_kbd
) && interrupt_input
2631 && keyboard_bit_set (&Available
)
2632 && input_polling_used ())
2633 kill (getpid (), SIGALRM
);
2636 /* Check for keyboard input */
2637 /* If there is any, return immediately
2638 to give it higher priority than subprocesses */
2640 if (XINT (read_kbd
) != 0
2641 && detect_input_pending_run_timers (do_display
))
2643 swallow_events (do_display
);
2644 if (detect_input_pending_run_timers (do_display
))
2648 /* If there is unread keyboard input, also return. */
2649 if (XINT (read_kbd
) != 0
2650 && requeued_events_pending_p ())
2653 /* If we are not checking for keyboard input now,
2654 do process events (but don't run any timers).
2655 This is so that X events will be processed.
2656 Otherwise they may have to wait until polling takes place.
2657 That would causes delays in pasting selections, for example.
2659 (We used to do this only if wait_for_cell.) */
2660 if (XINT (read_kbd
) == 0 && detect_input_pending ())
2662 swallow_events (do_display
);
2663 #if 0 /* Exiting when read_kbd doesn't request that seems wrong, though. */
2664 if (detect_input_pending ())
2669 /* Exit now if the cell we're waiting for became non-nil. */
2670 if (wait_for_cell
&& ! NILP (*wait_for_cell
))
2674 /* If we think we have keyboard input waiting, but didn't get SIGIO,
2675 go read it. This can happen with X on BSD after logging out.
2676 In that case, there really is no input and no SIGIO,
2677 but select says there is input. */
2679 if (XINT (read_kbd
) && interrupt_input
2680 && keyboard_bit_set (&Available
))
2681 kill (getpid (), SIGIO
);
2685 got_some_input
|= nfds
> 0;
2687 /* If checking input just got us a size-change event from X,
2688 obey it now if we should. */
2689 if (XINT (read_kbd
) || wait_for_cell
)
2690 do_pending_window_change (0);
2692 /* Check for data from a process. */
2693 /* Really FIRST_PROC_DESC should be 0 on Unix,
2694 but this is safer in the short run. */
2695 for (channel
= 0; channel
<= max_process_desc
; channel
++)
2697 if (FD_ISSET (channel
, &Available
)
2698 && FD_ISSET (channel
, &non_keyboard_wait_mask
))
2702 /* If waiting for this channel, arrange to return as
2703 soon as no more input to be processed. No more
2705 if (wait_channel
== channel
)
2711 proc
= chan_process
[channel
];
2715 /* Read data from the process, starting with our
2716 buffered-ahead character if we have one. */
2718 nread
= read_process_output (proc
, channel
);
2721 /* Since read_process_output can run a filter,
2722 which can call accept-process-output,
2723 don't try to read from any other processes
2724 before doing the select again. */
2725 FD_ZERO (&Available
);
2728 redisplay_preserve_echo_area ();
2731 else if (nread
== -1 && errno
== EWOULDBLOCK
)
2734 /* ISC 4.1 defines both EWOULDBLOCK and O_NONBLOCK,
2735 and Emacs uses O_NONBLOCK, so what we get is EAGAIN. */
2737 else if (nread
== -1 && errno
== EAGAIN
)
2741 else if (nread
== -1 && errno
== EAGAIN
)
2743 /* Note that we cannot distinguish between no input
2744 available now and a closed pipe.
2745 With luck, a closed pipe will be accompanied by
2746 subprocess termination and SIGCHLD. */
2747 else if (nread
== 0 && !NETCONN_P (proc
))
2749 #endif /* O_NDELAY */
2750 #endif /* O_NONBLOCK */
2752 /* On some OSs with ptys, when the process on one end of
2753 a pty exits, the other end gets an error reading with
2754 errno = EIO instead of getting an EOF (0 bytes read).
2755 Therefore, if we get an error reading and errno =
2756 EIO, just continue, because the child process has
2757 exited and should clean itself up soon (e.g. when we
2760 However, it has been known to happen that the SIGCHLD
2761 got lost. So raise the signl again just in case.
2763 else if (nread
== -1 && errno
== EIO
)
2764 kill (getpid (), SIGCHLD
);
2765 #endif /* HAVE_PTYS */
2766 /* If we can detect process termination, don't consider the process
2767 gone just because its pipe is closed. */
2769 else if (nread
== 0 && !NETCONN_P (proc
))
2774 /* Preserve status of processes already terminated. */
2775 XSETINT (XPROCESS (proc
)->tick
, ++process_tick
);
2776 deactivate_process (proc
);
2777 if (!NILP (XPROCESS (proc
)->raw_status_low
))
2778 update_status (XPROCESS (proc
));
2779 if (EQ (XPROCESS (proc
)->status
, Qrun
))
2780 XPROCESS (proc
)->status
2781 = Fcons (Qexit
, Fcons (make_number (256), Qnil
));
2784 } /* end for each file descriptor */
2785 } /* end while exit conditions not met */
2787 waiting_for_user_input_p
= 0;
2789 /* If calling from keyboard input, do not quit
2790 since we want to return C-g as an input character.
2791 Otherwise, do pending quit if requested. */
2792 if (XINT (read_kbd
) >= 0)
2794 /* Prevent input_pending from remaining set if we quit. */
2795 clear_input_pending ();
2799 /* AlainF 5-Jul-1996
2800 HP-UX 10.10 seems to have problems with signals coming in
2801 Causes "poll: interrupted system call" messages when Emacs is run
2803 Turn periodic alarms back on */
2807 return got_some_input
;
2810 /* Given a list (FUNCTION ARGS...), apply FUNCTION to the ARGS. */
2813 read_process_output_call (fun_and_args
)
2814 Lisp_Object fun_and_args
;
2816 return apply1 (XCAR (fun_and_args
), XCDR (fun_and_args
));
2820 read_process_output_error_handler (error
)
2823 cmd_error_internal (error
, "error in process filter: ");
2825 update_echo_area ();
2826 Fsleep_for (make_number (2), Qnil
);
2830 /* Read pending output from the process channel,
2831 starting with our buffered-ahead character if we have one.
2832 Yield number of decoded characters read.
2834 This function reads at most 1024 characters.
2835 If you want to read all available subprocess output,
2836 you must call it repeatedly until it returns zero.
2838 The characters read are decoded according to PROC's coding-system
2842 read_process_output (proc
, channel
)
2844 register int channel
;
2846 register int nchars
, nbytes
;
2849 int chars_allocated
= 0; /* If 1, `chars' should be freed later. */
2853 register Lisp_Object outstream
;
2854 register struct buffer
*old
= current_buffer
;
2855 register struct Lisp_Process
*p
= XPROCESS (proc
);
2856 register int opoint
;
2857 struct coding_system
*coding
= proc_decode_coding_system
[channel
];
2858 int chars_in_decoding_buf
= 0; /* If 1, `chars' points
2859 XSTRING (p->decoding_buf)->data. */
2860 int carryover
= XINT (p
->decoding_carryover
);
2863 VMS_PROC_STUFF
*vs
, *get_vms_process_pointer();
2865 vs
= get_vms_process_pointer (p
->pid
);
2869 return (0); /* Really weird if it does this */
2870 if (!(vs
->iosb
[0] & 1))
2871 return -1; /* I/O error */
2874 error ("Could not get VMS process pointer");
2875 chars
= vs
->inputBuffer
;
2876 nbytes
= clean_vms_buffer (chars
, vs
->iosb
[1]);
2879 start_vms_process_read (vs
); /* Crank up the next read on the process */
2880 return 1; /* Nothing worth printing, say we got 1 */
2884 /* The data carried over in the previous decoding (which are at
2885 the tail of decoding buffer) should be prepended to the new
2886 data read to decode all together. */
2887 char *buf
= (char *) xmalloc (nbytes
+ carryover
);
2889 bcopy (XSTRING (p
->decoding_buf
)->data
2890 + STRING_BYTES (XSTRING (p
->decoding_buf
)) - carryover
,
2892 bcopy (chars
, buf
+ carryover
, nbytes
);
2894 chars_allocated
= 1;
2899 /* See the comment above. */
2900 bcopy (XSTRING (p
->decoding_buf
)->data
2901 + STRING_BYTES (XSTRING (p
->decoding_buf
)) - carryover
,
2904 if (proc_buffered_char
[channel
] < 0)
2905 nbytes
= emacs_read (channel
, buf
+ carryover
, (sizeof buf
) - carryover
);
2908 buf
[carryover
] = proc_buffered_char
[channel
];
2909 proc_buffered_char
[channel
] = -1;
2910 nbytes
= emacs_read (channel
, buf
+ carryover
+ 1,
2911 (sizeof buf
) - carryover
- 1);
2915 nbytes
= nbytes
+ 1;
2918 #endif /* not VMS */
2920 XSETINT (p
->decoding_carryover
, 0);
2922 /* At this point, NBYTES holds number of characters just received
2923 (including the one in proc_buffered_char[channel]). */
2926 if (nbytes
< 0 || coding
->mode
& CODING_MODE_LAST_BLOCK
)
2928 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
2931 /* Now set NBYTES how many bytes we must decode. */
2932 nbytes
+= carryover
;
2935 if (CODING_MAY_REQUIRE_DECODING (coding
))
2937 int require
= decoding_buffer_size (coding
, nbytes
);
2940 if (STRING_BYTES (XSTRING (p
->decoding_buf
)) < require
)
2941 p
->decoding_buf
= make_uninit_string (require
);
2942 result
= decode_coding (coding
, chars
, XSTRING (p
->decoding_buf
)->data
,
2943 nbytes
, STRING_BYTES (XSTRING (p
->decoding_buf
)));
2944 carryover
= nbytes
- coding
->consumed
;
2947 /* Copy the carryover bytes to the end of p->decoding_buf, to
2948 be processed on the next read. Since decoding_buffer_size
2949 asks for an extra amount of space beyond the maximum
2950 expected for the output, there should always be sufficient
2951 space for the carryover (which is by definition a sequence
2952 of bytes that was not long enough to be decoded, and thus
2953 has a bounded length). */
2954 if (STRING_BYTES (XSTRING (p
->decoding_buf
))
2955 < coding
->produced
+ carryover
)
2957 bcopy (chars
+ coding
->consumed
,
2958 XSTRING (p
->decoding_buf
)->data
2959 + STRING_BYTES (XSTRING (p
->decoding_buf
)) - carryover
,
2961 XSETINT (p
->decoding_carryover
, carryover
);
2964 /* A new coding system might be found by `decode_coding'. */
2965 if (!EQ (p
->decode_coding_system
, coding
->symbol
))
2967 p
->decode_coding_system
= coding
->symbol
;
2969 /* Don't call setup_coding_system for
2970 proc_decode_coding_system[channel] here. It is done in
2971 detect_coding called via decode_coding above. */
2973 /* If a coding system for encoding is not yet decided, we set
2974 it as the same as coding-system for decoding.
2976 But, before doing that we must check if
2977 proc_encode_coding_system[p->outfd] surely points to a
2978 valid memory because p->outfd will be changed once EOF is
2979 sent to the process. */
2980 if (NILP (p
->encode_coding_system
)
2981 && proc_encode_coding_system
[XINT (p
->outfd
)])
2983 p
->encode_coding_system
= coding
->symbol
;
2984 setup_coding_system (coding
->symbol
,
2985 proc_encode_coding_system
[XINT (p
->outfd
)]);
2990 /* Now we don't need the contents of `chars'. */
2991 if (chars_allocated
)
2994 if (coding
->produced
== 0)
2996 chars
= (char *) XSTRING (p
->decoding_buf
)->data
;
2997 nbytes
= coding
->produced
;
2998 nchars
= (coding
->fake_multibyte
2999 ? multibyte_chars_in_text (chars
, nbytes
)
3000 : coding
->produced_char
);
3001 chars_in_decoding_buf
= 1;
3006 if (chars_allocated
)
3008 /* Although we don't have to decode the received data, we
3009 must move it to an area which we don't have to free. */
3010 if (! STRINGP (p
->decoding_buf
)
3011 || STRING_BYTES (XSTRING (p
->decoding_buf
)) < nbytes
)
3012 p
->decoding_buf
= make_uninit_string (nbytes
);
3013 bcopy (chars
, XSTRING (p
->decoding_buf
)->data
, nbytes
);
3015 chars
= XSTRING (p
->decoding_buf
)->data
;
3016 chars_in_decoding_buf
= 1;
3019 nchars
= multibyte_chars_in_text (chars
, nbytes
);
3022 Vlast_coding_system_used
= coding
->symbol
;
3024 /* If the caller required, let the process associated buffer
3025 inherit the coding-system used to decode the process output. */
3026 if (! NILP (p
->inherit_coding_system_flag
)
3027 && !NILP (p
->buffer
) && !NILP (XBUFFER (p
->buffer
)->name
))
3029 struct buffer
*prev_buf
= current_buffer
;
3031 Fset_buffer (p
->buffer
);
3032 call1 (intern ("after-insert-file-set-buffer-file-coding-system"),
3033 make_number (nbytes
));
3034 set_buffer_internal (prev_buf
);
3037 /* Read and dispose of the process output. */
3038 outstream
= p
->filter
;
3039 if (!NILP (outstream
))
3041 /* We inhibit quit here instead of just catching it so that
3042 hitting ^G when a filter happens to be running won't screw
3044 int count
= specpdl_ptr
- specpdl
;
3045 Lisp_Object odeactivate
;
3046 Lisp_Object obuffer
, okeymap
;
3048 int outer_running_asynch_code
= running_asynch_code
;
3049 int waiting
= waiting_for_user_input_p
;
3051 /* No need to gcpro these, because all we do with them later
3052 is test them for EQness, and none of them should be a string. */
3053 odeactivate
= Vdeactivate_mark
;
3054 XSETBUFFER (obuffer
, current_buffer
);
3055 okeymap
= current_buffer
->keymap
;
3057 specbind (Qinhibit_quit
, Qt
);
3058 specbind (Qlast_nonmenu_event
, Qt
);
3060 /* In case we get recursively called,
3061 and we already saved the match data nonrecursively,
3062 save the same match data in safely recursive fashion. */
3063 if (outer_running_asynch_code
)
3066 /* Don't clobber the CURRENT match data, either! */
3067 tem
= Fmatch_data (Qnil
, Qnil
);
3068 restore_match_data ();
3069 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
3070 Fset_match_data (tem
);
3073 /* For speed, if a search happens within this code,
3074 save the match data in a special nonrecursive fashion. */
3075 running_asynch_code
= 1;
3077 /* The multibyteness of a string given to the filter is decided
3078 by which coding system we used for decoding. */
3079 if (coding
->type
== coding_type_no_conversion
3080 || coding
->type
== coding_type_raw_text
)
3081 text
= make_unibyte_string (chars
, nbytes
);
3083 text
= make_multibyte_string (chars
, nchars
, nbytes
);
3085 internal_condition_case_1 (read_process_output_call
,
3087 Fcons (proc
, Fcons (text
, Qnil
))),
3088 !NILP (Vdebug_on_error
) ? Qnil
: Qerror
,
3089 read_process_output_error_handler
);
3091 /* If we saved the match data nonrecursively, restore it now. */
3092 restore_match_data ();
3093 running_asynch_code
= outer_running_asynch_code
;
3095 /* Handling the process output should not deactivate the mark. */
3096 Vdeactivate_mark
= odeactivate
;
3098 /* Restore waiting_for_user_input_p as it was
3099 when we were called, in case the filter clobbered it. */
3100 waiting_for_user_input_p
= waiting
;
3102 #if 0 /* Call record_asynch_buffer_change unconditionally,
3103 because we might have changed minor modes or other things
3104 that affect key bindings. */
3105 if (! EQ (Fcurrent_buffer (), obuffer
)
3106 || ! EQ (current_buffer
->keymap
, okeymap
))
3108 /* But do it only if the caller is actually going to read events.
3109 Otherwise there's no need to make him wake up, and it could
3110 cause trouble (for example it would make Fsit_for return). */
3111 if (waiting_for_user_input_p
== -1)
3112 record_asynch_buffer_change ();
3115 start_vms_process_read (vs
);
3117 unbind_to (count
, Qnil
);
3121 /* If no filter, write into buffer if it isn't dead. */
3122 if (!NILP (p
->buffer
) && !NILP (XBUFFER (p
->buffer
)->name
))
3124 Lisp_Object old_read_only
;
3125 int old_begv
, old_zv
;
3126 int old_begv_byte
, old_zv_byte
;
3127 Lisp_Object odeactivate
;
3128 int before
, before_byte
;
3131 odeactivate
= Vdeactivate_mark
;
3133 Fset_buffer (p
->buffer
);
3135 opoint_byte
= PT_BYTE
;
3136 old_read_only
= current_buffer
->read_only
;
3139 old_begv_byte
= BEGV_BYTE
;
3140 old_zv_byte
= ZV_BYTE
;
3142 current_buffer
->read_only
= Qnil
;
3144 /* Insert new output into buffer
3145 at the current end-of-output marker,
3146 thus preserving logical ordering of input and output. */
3147 if (XMARKER (p
->mark
)->buffer
)
3148 SET_PT_BOTH (clip_to_bounds (BEGV
, marker_position (p
->mark
), ZV
),
3149 clip_to_bounds (BEGV_BYTE
, marker_byte_position (p
->mark
),
3152 SET_PT_BOTH (ZV
, ZV_BYTE
);
3154 before_byte
= PT_BYTE
;
3156 /* If the output marker is outside of the visible region, save
3157 the restriction and widen. */
3158 if (! (BEGV
<= PT
&& PT
<= ZV
))
3161 if (NILP (current_buffer
->enable_multibyte_characters
))
3164 /* Insert before markers in case we are inserting where
3165 the buffer's mark is, and the user's next command is Meta-y. */
3166 if (chars_in_decoding_buf
)
3168 /* Since multibyteness of p->docoding_buf is corrupted, we
3169 can't use insert_from_string_before_markers. */
3172 temp_buf
= (char *) alloca (nbytes
);
3173 bcopy (XSTRING (p
->decoding_buf
)->data
, temp_buf
, nbytes
);
3174 insert_before_markers (temp_buf
, nbytes
);
3178 insert_1_both (chars
, nchars
, nbytes
, 0, 1, 1);
3179 signal_after_change (before
, 0, PT
- before
);
3180 update_compositions (before
, PT
, CHECK_BORDER
);
3182 set_marker_both (p
->mark
, p
->buffer
, PT
, PT_BYTE
);
3184 update_mode_lines
++;
3186 /* Make sure opoint and the old restrictions
3187 float ahead of any new text just as point would. */
3188 if (opoint
>= before
)
3190 opoint
+= PT
- before
;
3191 opoint_byte
+= PT_BYTE
- before_byte
;
3193 if (old_begv
> before
)
3195 old_begv
+= PT
- before
;
3196 old_begv_byte
+= PT_BYTE
- before_byte
;
3198 if (old_zv
>= before
)
3200 old_zv
+= PT
- before
;
3201 old_zv_byte
+= PT_BYTE
- before_byte
;
3204 /* If the restriction isn't what it should be, set it. */
3205 if (old_begv
!= BEGV
|| old_zv
!= ZV
)
3206 Fnarrow_to_region (make_number (old_begv
), make_number (old_zv
));
3208 /* Handling the process output should not deactivate the mark. */
3209 Vdeactivate_mark
= odeactivate
;
3211 current_buffer
->read_only
= old_read_only
;
3212 SET_PT_BOTH (opoint
, opoint_byte
);
3213 set_buffer_internal (old
);
3216 start_vms_process_read (vs
);
3221 DEFUN ("waiting-for-user-input-p", Fwaiting_for_user_input_p
, Swaiting_for_user_input_p
,
3223 "Returns non-nil if emacs is waiting for input from the user.\n\
3224 This is intended for use by asynchronous process output filters and sentinels.")
3227 return (waiting_for_user_input_p
? Qt
: Qnil
);
3230 /* Sending data to subprocess */
3232 jmp_buf send_process_frame
;
3235 send_process_trap ()
3241 longjmp (send_process_frame
, 1);
3244 /* Send some data to process PROC.
3245 BUF is the beginning of the data; LEN is the number of characters.
3246 OBJECT is the Lisp object that the data comes from.
3248 The data is encoded by PROC's coding-system for encoding before it
3249 is sent. But if the data ends at the middle of multi-byte
3250 representation, that incomplete sequence of bytes are sent without
3251 being encoded. Should we store them in a buffer to prepend them to
3252 the data send later? */
3255 send_process (proc
, buf
, len
, object
)
3256 volatile Lisp_Object proc
;
3261 /* Use volatile to protect variables from being clobbered by longjmp. */
3263 struct coding_system
*coding
;
3264 struct gcpro gcpro1
;
3265 int carryover
= XINT (XPROCESS (proc
)->encoding_carryover
);
3270 struct Lisp_Process
*p
= XPROCESS (proc
);
3271 VMS_PROC_STUFF
*vs
, *get_vms_process_pointer();
3274 if (! NILP (XPROCESS (proc
)->raw_status_low
))
3275 update_status (XPROCESS (proc
));
3276 if (! EQ (XPROCESS (proc
)->status
, Qrun
))
3277 error ("Process %s not running",
3278 XSTRING (XPROCESS (proc
)->name
)->data
);
3279 if (XINT (XPROCESS (proc
)->outfd
) < 0)
3280 error ("Output file descriptor of %s is closed",
3281 XSTRING (XPROCESS (proc
)->name
)->data
);
3283 coding
= proc_encode_coding_system
[XINT (XPROCESS (proc
)->outfd
)];
3284 Vlast_coding_system_used
= coding
->symbol
;
3286 if (CODING_REQUIRE_ENCODING (coding
))
3288 int require
= encoding_buffer_size (coding
, len
);
3290 unsigned char *temp_buf
= NULL
;
3292 /* Remember the offset of data because a string or a buffer may
3293 be relocated. Setting OFFSET to -1 means we don't have to
3294 care about relocation. */
3295 offset
= (BUFFERP (object
)
3296 ? BUF_PTR_BYTE_POS (XBUFFER (object
), buf
)
3298 ? buf
- XSTRING (object
)->data
3303 temp_buf
= (unsigned char *) xmalloc (len
+ carryover
);
3307 if (BUFFERP (object
))
3308 buf
= BUF_BYTE_ADDRESS (XBUFFER (object
), offset
);
3309 else if (STRINGP (object
))
3310 buf
= offset
+ XSTRING (object
)->data
;
3311 /* Now we don't have to care about relocation. */
3314 bcopy ((XSTRING (XPROCESS (proc
)->encoding_buf
)->data
3315 + STRING_BYTES (XSTRING (XPROCESS (proc
)->encoding_buf
))
3319 bcopy (buf
, temp_buf
+ carryover
, len
);
3323 if (STRING_BYTES (XSTRING (XPROCESS (proc
)->encoding_buf
)) < require
)
3325 XPROCESS (proc
)->encoding_buf
= make_uninit_string (require
);
3329 if (BUFFERP (object
))
3330 buf
= BUF_BYTE_ADDRESS (XBUFFER (object
), offset
);
3331 else if (STRINGP (object
))
3332 buf
= offset
+ XSTRING (object
)->data
;
3335 object
= XPROCESS (proc
)->encoding_buf
;
3336 encode_coding (coding
, buf
, XSTRING (object
)->data
,
3337 len
, STRING_BYTES (XSTRING (object
)));
3338 len
= coding
->produced
;
3339 buf
= XSTRING (object
)->data
;
3345 vs
= get_vms_process_pointer (p
->pid
);
3347 error ("Could not find this process: %x", p
->pid
);
3348 else if (write_to_vms_process (vs
, buf
, len
))
3352 if (pty_max_bytes
== 0)
3354 #if defined (HAVE_FPATHCONF) && defined (_PC_MAX_CANON)
3355 pty_max_bytes
= fpathconf (XFASTINT (XPROCESS (proc
)->outfd
),
3357 if (pty_max_bytes
< 0)
3358 pty_max_bytes
= 250;
3360 pty_max_bytes
= 250;
3362 /* Deduct one, to leave space for the eof. */
3366 if (!setjmp (send_process_frame
))
3370 SIGTYPE (*old_sigpipe
)();
3372 /* Decide how much data we can send in one batch.
3373 Long lines need to be split into multiple batches. */
3374 if (!NILP (XPROCESS (proc
)->pty_flag
))
3376 /* Starting this at zero is always correct when not the first iteration
3377 because the previous iteration ended by sending C-d.
3378 It may not be correct for the first iteration
3379 if a partial line was sent in a separate send_process call.
3380 If that proves worth handling, we need to save linepos
3381 in the process object. */
3383 unsigned char *ptr
= buf
;
3384 unsigned char *end
= buf
+ len
;
3386 /* Scan through this text for a line that is too long. */
3387 while (ptr
!= end
&& linepos
< pty_max_bytes
)
3395 /* If we found one, break the line there
3396 and put in a C-d to force the buffer through. */
3400 /* Send this batch, using one or more write calls. */
3403 old_sigpipe
= (SIGTYPE (*) ()) signal (SIGPIPE
, send_process_trap
);
3404 rv
= emacs_write (XINT (XPROCESS (proc
)->outfd
), buf
, this);
3405 signal (SIGPIPE
, old_sigpipe
);
3411 || errno
== EWOULDBLOCK
3417 /* Buffer is full. Wait, accepting input;
3418 that may allow the program
3419 to finish doing output and read more. */
3424 #ifdef BROKEN_PTY_READ_AFTER_EAGAIN
3425 /* A gross hack to work around a bug in FreeBSD.
3426 In the following sequence, read(2) returns
3430 write(2) 954 bytes, get EAGAIN
3431 read(2) 1024 bytes in process_read_output
3432 read(2) 11 bytes in process_read_output
3434 That is, read(2) returns more bytes than have
3435 ever been written successfully. The 1033 bytes
3436 read are the 1022 bytes written successfully
3437 after processing (for example with CRs added if
3438 the terminal is set up that way which it is
3439 here). The same bytes will be seen again in a
3440 later read(2), without the CRs. */
3442 if (errno
== EAGAIN
)
3445 ioctl (XINT (XPROCESS (proc
)->outfd
), TIOCFLUSH
,
3448 #endif /* BROKEN_PTY_READ_AFTER_EAGAIN */
3450 /* Running filters might relocate buffers or strings.
3451 Arrange to relocate BUF. */
3452 if (BUFFERP (object
))
3453 offset
= BUF_PTR_BYTE_POS (XBUFFER (object
), buf
);
3454 else if (STRINGP (object
))
3455 offset
= buf
- XSTRING (object
)->data
;
3457 XSETFASTINT (zero
, 0);
3458 #ifdef EMACS_HAS_USECS
3459 wait_reading_process_input (0, 20000, zero
, 0);
3461 wait_reading_process_input (1, 0, zero
, 0);
3464 if (BUFFERP (object
))
3465 buf
= BUF_BYTE_ADDRESS (XBUFFER (object
), offset
);
3466 else if (STRINGP (object
))
3467 buf
= offset
+ XSTRING (object
)->data
;
3472 /* This is a real error. */
3473 report_file_error ("writing to process", Fcons (proc
, Qnil
));
3480 /* If we sent just part of the string, put in an EOF
3481 to force it through, before we send the rest. */
3483 Fprocess_send_eof (proc
);
3488 XPROCESS (proc
)->raw_status_low
= Qnil
;
3489 XPROCESS (proc
)->raw_status_high
= Qnil
;
3490 XPROCESS (proc
)->status
= Fcons (Qexit
, Fcons (make_number (256), Qnil
));
3491 XSETINT (XPROCESS (proc
)->tick
, ++process_tick
);
3492 deactivate_process (proc
);
3494 error ("Error writing to process %s; closed it",
3495 XSTRING (XPROCESS (proc
)->name
)->data
);
3497 error ("SIGPIPE raised on process %s; closed it",
3498 XSTRING (XPROCESS (proc
)->name
)->data
);
3505 DEFUN ("process-send-region", Fprocess_send_region
, Sprocess_send_region
,
3507 "Send current contents of region as input to PROCESS.\n\
3508 PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
3509 nil, indicating the current buffer's process.\n\
3510 Called from program, takes three arguments, PROCESS, START and END.\n\
3511 If the region is more than 500 characters long,\n\
3512 it is sent in several bunches. This may happen even for shorter regions.\n\
3513 Output from processes can arrive in between bunches.")
3514 (process
, start
, end
)
3515 Lisp_Object process
, start
, end
;
3520 proc
= get_process (process
);
3521 validate_region (&start
, &end
);
3523 if (XINT (start
) < GPT
&& XINT (end
) > GPT
)
3524 move_gap (XINT (start
));
3526 start1
= CHAR_TO_BYTE (XINT (start
));
3527 end1
= CHAR_TO_BYTE (XINT (end
));
3528 send_process (proc
, BYTE_POS_ADDR (start1
), end1
- start1
,
3529 Fcurrent_buffer ());
3534 DEFUN ("process-send-string", Fprocess_send_string
, Sprocess_send_string
,
3536 "Send PROCESS the contents of STRING as input.\n\
3537 PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
3538 nil, indicating the current buffer's process.\n\
3539 If STRING is more than 500 characters long,\n\
3540 it is sent in several bunches. This may happen even for shorter strings.\n\
3541 Output from processes can arrive in between bunches.")
3543 Lisp_Object process
, string
;
3546 CHECK_STRING (string
, 1);
3547 proc
= get_process (process
);
3548 send_process (proc
, XSTRING (string
)->data
,
3549 STRING_BYTES (XSTRING (string
)), string
);
3553 DEFUN ("process-running-child-p", Fprocess_running_child_p
,
3554 Sprocess_running_child_p
, 0, 1, 0,
3555 "Return t if PROCESS has given the terminal to a child.\n\
3556 If the operating system does not make it possible to find out,\n\
3557 return t unconditionally.")
3559 Lisp_Object process
;
3561 /* Initialize in case ioctl doesn't exist or gives an error,
3562 in a way that will cause returning t. */
3565 struct Lisp_Process
*p
;
3567 proc
= get_process (process
);
3568 p
= XPROCESS (proc
);
3570 if (!EQ (p
->childp
, Qt
))
3571 error ("Process %s is not a subprocess",
3572 XSTRING (p
->name
)->data
);
3573 if (XINT (p
->infd
) < 0)
3574 error ("Process %s is not active",
3575 XSTRING (p
->name
)->data
);
3578 if (!NILP (p
->subtty
))
3579 ioctl (XFASTINT (p
->subtty
), TIOCGPGRP
, &gid
);
3581 ioctl (XINT (p
->infd
), TIOCGPGRP
, &gid
);
3582 #endif /* defined (TIOCGPGRP ) */
3584 if (gid
== XFASTINT (p
->pid
))
3589 /* send a signal number SIGNO to PROCESS.
3590 If CURRENT_GROUP is t, that means send to the process group
3591 that currently owns the terminal being used to communicate with PROCESS.
3592 This is used for various commands in shell mode.
3593 If CURRENT_GROUP is lambda, that means send to the process group
3594 that currently owns the terminal, but only if it is NOT the shell itself.
3596 If NOMSG is zero, insert signal-announcements into process's buffers
3599 If we can, we try to signal PROCESS by sending control characters
3600 down the pty. This allows us to signal inferiors who have changed
3601 their uid, for which killpg would return an EPERM error. */
3604 process_send_signal (process
, signo
, current_group
, nomsg
)
3605 Lisp_Object process
;
3607 Lisp_Object current_group
;
3611 register struct Lisp_Process
*p
;
3615 proc
= get_process (process
);
3616 p
= XPROCESS (proc
);
3618 if (!EQ (p
->childp
, Qt
))
3619 error ("Process %s is not a subprocess",
3620 XSTRING (p
->name
)->data
);
3621 if (XINT (p
->infd
) < 0)
3622 error ("Process %s is not active",
3623 XSTRING (p
->name
)->data
);
3625 if (NILP (p
->pty_flag
))
3626 current_group
= Qnil
;
3628 /* If we are using pgrps, get a pgrp number and make it negative. */
3629 if (!NILP (current_group
))
3631 #ifdef SIGNALS_VIA_CHARACTERS
3632 /* If possible, send signals to the entire pgrp
3633 by sending an input character to it. */
3635 /* TERMIOS is the latest and bestest, and seems most likely to
3636 work. If the system has it, use it. */
3643 tcgetattr (XINT (p
->infd
), &t
);
3644 send_process (proc
, &t
.c_cc
[VINTR
], 1, Qnil
);
3648 tcgetattr (XINT (p
->infd
), &t
);
3649 send_process (proc
, &t
.c_cc
[VQUIT
], 1, Qnil
);
3653 tcgetattr (XINT (p
->infd
), &t
);
3654 #if defined (VSWTCH) && !defined (PREFER_VSUSP)
3655 send_process (proc
, &t
.c_cc
[VSWTCH
], 1, Qnil
);
3657 send_process (proc
, &t
.c_cc
[VSUSP
], 1, Qnil
);
3662 #else /* ! HAVE_TERMIOS */
3664 /* On Berkeley descendants, the following IOCTL's retrieve the
3665 current control characters. */
3666 #if defined (TIOCGLTC) && defined (TIOCGETC)
3674 ioctl (XINT (p
->infd
), TIOCGETC
, &c
);
3675 send_process (proc
, &c
.t_intrc
, 1, Qnil
);
3678 ioctl (XINT (p
->infd
), TIOCGETC
, &c
);
3679 send_process (proc
, &c
.t_quitc
, 1, Qnil
);
3683 ioctl (XINT (p
->infd
), TIOCGLTC
, &lc
);
3684 send_process (proc
, &lc
.t_suspc
, 1, Qnil
);
3686 #endif /* ! defined (SIGTSTP) */
3689 #else /* ! defined (TIOCGLTC) && defined (TIOCGETC) */
3691 /* On SYSV descendants, the TCGETA ioctl retrieves the current control
3698 ioctl (XINT (p
->infd
), TCGETA
, &t
);
3699 send_process (proc
, &t
.c_cc
[VINTR
], 1, Qnil
);
3702 ioctl (XINT (p
->infd
), TCGETA
, &t
);
3703 send_process (proc
, &t
.c_cc
[VQUIT
], 1, Qnil
);
3707 ioctl (XINT (p
->infd
), TCGETA
, &t
);
3708 send_process (proc
, &t
.c_cc
[VSWTCH
], 1, Qnil
);
3710 #endif /* ! defined (SIGTSTP) */
3712 #else /* ! defined (TCGETA) */
3713 Your configuration files are messed up
.
3714 /* If your system configuration files define SIGNALS_VIA_CHARACTERS,
3715 you'd better be using one of the alternatives above! */
3716 #endif /* ! defined (TCGETA) */
3717 #endif /* ! defined (TIOCGLTC) && defined (TIOCGETC) */
3718 #endif /* ! defined HAVE_TERMIOS */
3719 #endif /* ! defined (SIGNALS_VIA_CHARACTERS) */
3722 /* Get the pgrp using the tty itself, if we have that.
3723 Otherwise, use the pty to get the pgrp.
3724 On pfa systems, saka@pfu.fujitsu.co.JP writes:
3725 "TIOCGPGRP symbol defined in sys/ioctl.h at E50.
3726 But, TIOCGPGRP does not work on E50 ;-P works fine on E60"
3727 His patch indicates that if TIOCGPGRP returns an error, then
3728 we should just assume that p->pid is also the process group id. */
3732 if (!NILP (p
->subtty
))
3733 err
= ioctl (XFASTINT (p
->subtty
), TIOCGPGRP
, &gid
);
3735 err
= ioctl (XINT (p
->infd
), TIOCGPGRP
, &gid
);
3739 gid
= - XFASTINT (p
->pid
);
3740 #endif /* ! defined (pfa) */
3746 #else /* ! defined (TIOCGPGRP ) */
3747 /* Can't select pgrps on this system, so we know that
3748 the child itself heads the pgrp. */
3749 gid
= - XFASTINT (p
->pid
);
3750 #endif /* ! defined (TIOCGPGRP ) */
3752 /* If current_group is lambda, and the shell owns the terminal,
3753 don't send any signal. */
3754 if (EQ (current_group
, Qlambda
) && gid
== - XFASTINT (p
->pid
))
3758 gid
= - XFASTINT (p
->pid
);
3764 p
->raw_status_low
= Qnil
;
3765 p
->raw_status_high
= Qnil
;
3767 XSETINT (p
->tick
, ++process_tick
);
3771 #endif /* ! defined (SIGCONT) */
3774 send_process (proc
, "\003", 1, Qnil
); /* ^C */
3779 send_process (proc
, "\031", 1, Qnil
); /* ^Y */
3784 sys$
forcex (&(XFASTINT (p
->pid
)), 0, 1);
3787 flush_pending_output (XINT (p
->infd
));
3791 /* If we don't have process groups, send the signal to the immediate
3792 subprocess. That isn't really right, but it's better than any
3793 obvious alternative. */
3796 kill (XFASTINT (p
->pid
), signo
);
3800 /* gid may be a pid, or minus a pgrp's number */
3802 if (!NILP (current_group
))
3803 ioctl (XINT (p
->infd
), TIOCSIGSEND
, signo
);
3806 gid
= - XFASTINT (p
->pid
);
3809 #else /* ! defined (TIOCSIGSEND) */
3810 EMACS_KILLPG (-gid
, signo
);
3811 #endif /* ! defined (TIOCSIGSEND) */
3814 DEFUN ("interrupt-process", Finterrupt_process
, Sinterrupt_process
, 0, 2, 0,
3815 "Interrupt process PROCESS.\n\
3816 PROCESS may be a process, a buffer, or the name of a process or buffer.\n\
3817 nil or no arg means current buffer's process.\n\
3818 Second arg CURRENT-GROUP non-nil means send signal to\n\
3819 the current process-group of the process's controlling terminal\n\
3820 rather than to the process's own process group.\n\
3821 If the process is a shell, this means interrupt current subjob\n\
3822 rather than the shell.\n\
3824 If CURRENT-GROUP is `lambda', and if the shell owns the terminal,\n\
3825 don't send the signal.")
3826 (process
, current_group
)
3827 Lisp_Object process
, current_group
;
3829 process_send_signal (process
, SIGINT
, current_group
, 0);
3833 DEFUN ("kill-process", Fkill_process
, Skill_process
, 0, 2, 0,
3834 "Kill process PROCESS. May be process or name of one.\n\
3835 See function `interrupt-process' for more details on usage.")
3836 (process
, current_group
)
3837 Lisp_Object process
, current_group
;
3839 process_send_signal (process
, SIGKILL
, current_group
, 0);
3843 DEFUN ("quit-process", Fquit_process
, Squit_process
, 0, 2, 0,
3844 "Send QUIT signal to process PROCESS. May be process or name of one.\n\
3845 See function `interrupt-process' for more details on usage.")
3846 (process
, current_group
)
3847 Lisp_Object process
, current_group
;
3849 process_send_signal (process
, SIGQUIT
, current_group
, 0);
3853 DEFUN ("stop-process", Fstop_process
, Sstop_process
, 0, 2, 0,
3854 "Stop process PROCESS. May be process or name of one.\n\
3855 See function `interrupt-process' for more details on usage.")
3856 (process
, current_group
)
3857 Lisp_Object process
, current_group
;
3860 error ("no SIGTSTP support");
3862 process_send_signal (process
, SIGTSTP
, current_group
, 0);
3867 DEFUN ("continue-process", Fcontinue_process
, Scontinue_process
, 0, 2, 0,
3868 "Continue process PROCESS. May be process or name of one.\n\
3869 See function `interrupt-process' for more details on usage.")
3870 (process
, current_group
)
3871 Lisp_Object process
, current_group
;
3874 process_send_signal (process
, SIGCONT
, current_group
, 0);
3876 error ("no SIGCONT support");
3881 DEFUN ("signal-process", Fsignal_process
, Ssignal_process
,
3882 2, 2, "nProcess number: \nnSignal code: ",
3883 "Send the process with process id PID the signal with code SIGCODE.\n\
3884 PID must be an integer. The process need not be a child of this Emacs.\n\
3885 SIGCODE may be an integer, or a symbol whose name is a signal name.")
3887 Lisp_Object pid
, sigcode
;
3889 CHECK_NUMBER (pid
, 0);
3891 #define handle_signal(NAME, VALUE) \
3892 else if (!strcmp (name, NAME)) \
3893 XSETINT (sigcode, VALUE)
3895 if (INTEGERP (sigcode
))
3899 unsigned char *name
;
3901 CHECK_SYMBOL (sigcode
, 1);
3902 name
= XSYMBOL (sigcode
)->name
->data
;
3907 handle_signal ("SIGHUP", SIGHUP
);
3910 handle_signal ("SIGINT", SIGINT
);
3913 handle_signal ("SIGQUIT", SIGQUIT
);
3916 handle_signal ("SIGILL", SIGILL
);
3919 handle_signal ("SIGABRT", SIGABRT
);
3922 handle_signal ("SIGEMT", SIGEMT
);
3925 handle_signal ("SIGKILL", SIGKILL
);
3928 handle_signal ("SIGFPE", SIGFPE
);
3931 handle_signal ("SIGBUS", SIGBUS
);
3934 handle_signal ("SIGSEGV", SIGSEGV
);
3937 handle_signal ("SIGSYS", SIGSYS
);
3940 handle_signal ("SIGPIPE", SIGPIPE
);
3943 handle_signal ("SIGALRM", SIGALRM
);
3946 handle_signal ("SIGTERM", SIGTERM
);
3949 handle_signal ("SIGURG", SIGURG
);
3952 handle_signal ("SIGSTOP", SIGSTOP
);
3955 handle_signal ("SIGTSTP", SIGTSTP
);
3958 handle_signal ("SIGCONT", SIGCONT
);
3961 handle_signal ("SIGCHLD", SIGCHLD
);
3964 handle_signal ("SIGTTIN", SIGTTIN
);
3967 handle_signal ("SIGTTOU", SIGTTOU
);
3970 handle_signal ("SIGIO", SIGIO
);
3973 handle_signal ("SIGXCPU", SIGXCPU
);
3976 handle_signal ("SIGXFSZ", SIGXFSZ
);
3979 handle_signal ("SIGVTALRM", SIGVTALRM
);
3982 handle_signal ("SIGPROF", SIGPROF
);
3985 handle_signal ("SIGWINCH", SIGWINCH
);
3988 handle_signal ("SIGINFO", SIGINFO
);
3991 handle_signal ("SIGUSR1", SIGUSR1
);
3994 handle_signal ("SIGUSR2", SIGUSR2
);
3997 error ("Undefined signal name %s", name
);
4000 #undef handle_signal
4002 return make_number (kill (XINT (pid
), XINT (sigcode
)));
4005 DEFUN ("process-send-eof", Fprocess_send_eof
, Sprocess_send_eof
, 0, 1, 0,
4006 "Make PROCESS see end-of-file in its input.\n\
4007 EOF comes after any text already sent to it.\n\
4008 PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
4009 nil, indicating the current buffer's process.\n\
4010 If PROCESS is a network connection, or is a process communicating\n\
4011 through a pipe (as opposed to a pty), then you cannot send any more\n\
4012 text to PROCESS after you call this function.")
4014 Lisp_Object process
;
4017 struct coding_system
*coding
;
4019 proc
= get_process (process
);
4020 coding
= proc_encode_coding_system
[XINT (XPROCESS (proc
)->outfd
)];
4022 /* Make sure the process is really alive. */
4023 if (! NILP (XPROCESS (proc
)->raw_status_low
))
4024 update_status (XPROCESS (proc
));
4025 if (! EQ (XPROCESS (proc
)->status
, Qrun
))
4026 error ("Process %s not running", XSTRING (XPROCESS (proc
)->name
)->data
);
4028 if (CODING_REQUIRE_FLUSHING (coding
))
4030 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
4031 send_process (proc
, "", 0, Qnil
);
4035 send_process (proc
, "\032", 1, Qnil
); /* ^z */
4037 if (!NILP (XPROCESS (proc
)->pty_flag
))
4038 send_process (proc
, "\004", 1, Qnil
);
4041 int old_outfd
, new_outfd
;
4043 #ifdef HAVE_SHUTDOWN
4044 /* If this is a network connection, or socketpair is used
4045 for communication with the subprocess, call shutdown to cause EOF.
4046 (In some old system, shutdown to socketpair doesn't work.
4047 Then we just can't win.) */
4048 if (NILP (XPROCESS (proc
)->pid
)
4049 || XINT (XPROCESS (proc
)->outfd
) == XINT (XPROCESS (proc
)->infd
))
4050 shutdown (XINT (XPROCESS (proc
)->outfd
), 1);
4051 /* In case of socketpair, outfd == infd, so don't close it. */
4052 if (XINT (XPROCESS (proc
)->outfd
) != XINT (XPROCESS (proc
)->infd
))
4053 emacs_close (XINT (XPROCESS (proc
)->outfd
));
4054 #else /* not HAVE_SHUTDOWN */
4055 emacs_close (XINT (XPROCESS (proc
)->outfd
));
4056 #endif /* not HAVE_SHUTDOWN */
4057 new_outfd
= emacs_open (NULL_DEVICE
, O_WRONLY
, 0);
4058 old_outfd
= XINT (XPROCESS (proc
)->outfd
);
4060 if (!proc_encode_coding_system
[new_outfd
])
4061 proc_encode_coding_system
[new_outfd
]
4062 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
4063 bcopy (proc_encode_coding_system
[old_outfd
],
4064 proc_encode_coding_system
[new_outfd
],
4065 sizeof (struct coding_system
));
4066 bzero (proc_encode_coding_system
[old_outfd
],
4067 sizeof (struct coding_system
));
4069 XSETINT (XPROCESS (proc
)->outfd
, new_outfd
);
4075 /* Kill all processes associated with `buffer'.
4076 If `buffer' is nil, kill all processes */
4079 kill_buffer_processes (buffer
)
4082 Lisp_Object tail
, proc
;
4084 for (tail
= Vprocess_alist
; GC_CONSP (tail
); tail
= XCDR (tail
))
4086 proc
= XCDR (XCAR (tail
));
4087 if (GC_PROCESSP (proc
)
4088 && (NILP (buffer
) || EQ (XPROCESS (proc
)->buffer
, buffer
)))
4090 if (NETCONN_P (proc
))
4091 Fdelete_process (proc
);
4092 else if (XINT (XPROCESS (proc
)->infd
) >= 0)
4093 process_send_signal (proc
, SIGHUP
, Qnil
, 1);
4098 /* On receipt of a signal that a child status has changed,
4099 loop asking about children with changed statuses until
4100 the system says there are no more.
4101 All we do is change the status;
4102 we do not run sentinels or print notifications.
4103 That is saved for the next time keyboard input is done,
4104 in order to avoid timing errors. */
4106 /** WARNING: this can be called during garbage collection.
4107 Therefore, it must not be fooled by the presence of mark bits in
4110 /** USG WARNING: Although it is not obvious from the documentation
4111 in signal(2), on a USG system the SIGCLD handler MUST NOT call
4112 signal() before executing at least one wait(), otherwise the handler
4113 will be called again, resulting in an infinite loop. The relevant
4114 portion of the documentation reads "SIGCLD signals will be queued
4115 and the signal-catching function will be continually reentered until
4116 the queue is empty". Invoking signal() causes the kernel to reexamine
4117 the SIGCLD queue. Fred Fish, UniSoft Systems Inc. */
4120 sigchld_handler (signo
)
4123 int old_errno
= errno
;
4125 register struct Lisp_Process
*p
;
4126 extern EMACS_TIME
*input_available_clear_time
;
4130 sigheld
|= sigbit (SIGCHLD
);
4142 #endif /* no WUNTRACED */
4143 /* Keep trying to get a status until we get a definitive result. */
4147 pid
= wait3 (&w
, WNOHANG
| WUNTRACED
, 0);
4149 while (pid
<= 0 && errno
== EINTR
);
4153 /* A real failure. We have done all our job, so return. */
4155 /* USG systems forget handlers when they are used;
4156 must reestablish each time */
4157 #if defined (USG) && !defined (POSIX_SIGNALS)
4158 signal (signo
, sigchld_handler
); /* WARNING - must come after wait3() */
4161 sigheld
&= ~sigbit (SIGCHLD
);
4169 #endif /* no WNOHANG */
4171 /* Find the process that signaled us, and record its status. */
4174 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
4176 proc
= XCDR (XCAR (tail
));
4177 p
= XPROCESS (proc
);
4178 if (EQ (p
->childp
, Qt
) && XFASTINT (p
->pid
) == pid
)
4183 /* Look for an asynchronous process whose pid hasn't been filled
4186 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
4188 proc
= XCDR (XCAR (tail
));
4189 p
= XPROCESS (proc
);
4190 if (INTEGERP (p
->pid
) && XINT (p
->pid
) == -1)
4195 /* Change the status of the process that was found. */
4198 union { int i
; WAITTYPE wt
; } u
;
4199 int clear_desc_flag
= 0;
4201 XSETINT (p
->tick
, ++process_tick
);
4203 XSETINT (p
->raw_status_low
, u
.i
& 0xffff);
4204 XSETINT (p
->raw_status_high
, u
.i
>> 16);
4206 /* If process has terminated, stop waiting for its output. */
4207 if ((WIFSIGNALED (w
) || WIFEXITED (w
))
4208 && XINT (p
->infd
) >= 0)
4209 clear_desc_flag
= 1;
4211 /* We use clear_desc_flag to avoid a compiler bug in Microsoft C. */
4212 if (clear_desc_flag
)
4214 FD_CLR (XINT (p
->infd
), &input_wait_mask
);
4215 FD_CLR (XINT (p
->infd
), &non_keyboard_wait_mask
);
4218 /* Tell wait_reading_process_input that it needs to wake up and
4220 if (input_available_clear_time
)
4221 EMACS_SET_SECS_USECS (*input_available_clear_time
, 0, 0);
4224 /* There was no asynchronous process found for that id. Check
4225 if we have a synchronous process. */
4228 synch_process_alive
= 0;
4230 /* Report the status of the synchronous process. */
4232 synch_process_retcode
= WRETCODE (w
);
4233 else if (WIFSIGNALED (w
))
4235 int code
= WTERMSIG (w
);
4238 synchronize_system_messages_locale ();
4239 signame
= strsignal (code
);
4242 signame
= "unknown";
4244 synch_process_death
= signame
;
4247 /* Tell wait_reading_process_input that it needs to wake up and
4249 if (input_available_clear_time
)
4250 EMACS_SET_SECS_USECS (*input_available_clear_time
, 0, 0);
4253 /* On some systems, we must return right away.
4254 If any more processes want to signal us, we will
4256 Otherwise (on systems that have WNOHANG), loop around
4257 to use up all the processes that have something to tell us. */
4258 #if defined (USG) && ! (defined (HPUX) && defined (WNOHANG)) || defined (WINDOWSNT)
4259 #if defined (USG) && ! defined (POSIX_SIGNALS)
4260 signal (signo
, sigchld_handler
);
4264 #endif /* USG, but not HPUX with WNOHANG */
4270 exec_sentinel_unwind (data
)
4273 XPROCESS (XCAR (data
))->sentinel
= XCDR (data
);
4278 exec_sentinel_error_handler (error
)
4281 cmd_error_internal (error
, "error in process sentinel: ");
4283 update_echo_area ();
4284 Fsleep_for (make_number (2), Qnil
);
4289 exec_sentinel (proc
, reason
)
4290 Lisp_Object proc
, reason
;
4292 Lisp_Object sentinel
, obuffer
, odeactivate
, okeymap
;
4293 register struct Lisp_Process
*p
= XPROCESS (proc
);
4294 int count
= specpdl_ptr
- specpdl
;
4295 int outer_running_asynch_code
= running_asynch_code
;
4296 int waiting
= waiting_for_user_input_p
;
4298 /* No need to gcpro these, because all we do with them later
4299 is test them for EQness, and none of them should be a string. */
4300 odeactivate
= Vdeactivate_mark
;
4301 XSETBUFFER (obuffer
, current_buffer
);
4302 okeymap
= current_buffer
->keymap
;
4304 sentinel
= p
->sentinel
;
4305 if (NILP (sentinel
))
4308 /* Zilch the sentinel while it's running, to avoid recursive invocations;
4309 assure that it gets restored no matter how the sentinel exits. */
4311 record_unwind_protect (exec_sentinel_unwind
, Fcons (proc
, sentinel
));
4312 /* Inhibit quit so that random quits don't screw up a running filter. */
4313 specbind (Qinhibit_quit
, Qt
);
4314 specbind (Qlast_nonmenu_event
, Qt
);
4316 /* In case we get recursively called,
4317 and we already saved the match data nonrecursively,
4318 save the same match data in safely recursive fashion. */
4319 if (outer_running_asynch_code
)
4322 tem
= Fmatch_data (Qnil
, Qnil
);
4323 restore_match_data ();
4324 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
4325 Fset_match_data (tem
);
4328 /* For speed, if a search happens within this code,
4329 save the match data in a special nonrecursive fashion. */
4330 running_asynch_code
= 1;
4332 internal_condition_case_1 (read_process_output_call
,
4334 Fcons (proc
, Fcons (reason
, Qnil
))),
4335 !NILP (Vdebug_on_error
) ? Qnil
: Qerror
,
4336 exec_sentinel_error_handler
);
4338 /* If we saved the match data nonrecursively, restore it now. */
4339 restore_match_data ();
4340 running_asynch_code
= outer_running_asynch_code
;
4342 Vdeactivate_mark
= odeactivate
;
4344 /* Restore waiting_for_user_input_p as it was
4345 when we were called, in case the filter clobbered it. */
4346 waiting_for_user_input_p
= waiting
;
4349 if (! EQ (Fcurrent_buffer (), obuffer
)
4350 || ! EQ (current_buffer
->keymap
, okeymap
))
4352 /* But do it only if the caller is actually going to read events.
4353 Otherwise there's no need to make him wake up, and it could
4354 cause trouble (for example it would make Fsit_for return). */
4355 if (waiting_for_user_input_p
== -1)
4356 record_asynch_buffer_change ();
4358 unbind_to (count
, Qnil
);
4361 /* Report all recent events of a change in process status
4362 (either run the sentinel or output a message).
4363 This is done while Emacs is waiting for keyboard input. */
4368 register Lisp_Object proc
, buffer
;
4369 Lisp_Object tail
, msg
;
4370 struct gcpro gcpro1
, gcpro2
;
4374 /* We need to gcpro tail; if read_process_output calls a filter
4375 which deletes a process and removes the cons to which tail points
4376 from Vprocess_alist, and then causes a GC, tail is an unprotected
4380 /* Set this now, so that if new processes are created by sentinels
4381 that we run, we get called again to handle their status changes. */
4382 update_tick
= process_tick
;
4384 for (tail
= Vprocess_alist
; !NILP (tail
); tail
= Fcdr (tail
))
4387 register struct Lisp_Process
*p
;
4389 proc
= Fcdr (Fcar (tail
));
4390 p
= XPROCESS (proc
);
4392 if (XINT (p
->tick
) != XINT (p
->update_tick
))
4394 XSETINT (p
->update_tick
, XINT (p
->tick
));
4396 /* If process is still active, read any output that remains. */
4397 while (! EQ (p
->filter
, Qt
)
4398 && XINT (p
->infd
) >= 0
4399 && read_process_output (proc
, XINT (p
->infd
)) > 0);
4403 /* Get the text to use for the message. */
4404 if (!NILP (p
->raw_status_low
))
4406 msg
= status_message (p
->status
);
4408 /* If process is terminated, deactivate it or delete it. */
4410 if (CONSP (p
->status
))
4411 symbol
= XCAR (p
->status
);
4413 if (EQ (symbol
, Qsignal
) || EQ (symbol
, Qexit
)
4414 || EQ (symbol
, Qclosed
))
4416 if (delete_exited_processes
)
4417 remove_process (proc
);
4419 deactivate_process (proc
);
4422 /* The actions above may have further incremented p->tick.
4423 So set p->update_tick again
4424 so that an error in the sentinel will not cause
4425 this code to be run again. */
4426 XSETINT (p
->update_tick
, XINT (p
->tick
));
4427 /* Now output the message suitably. */
4428 if (!NILP (p
->sentinel
))
4429 exec_sentinel (proc
, msg
);
4430 /* Don't bother with a message in the buffer
4431 when a process becomes runnable. */
4432 else if (!EQ (symbol
, Qrun
) && !NILP (buffer
))
4434 Lisp_Object ro
, tem
;
4435 struct buffer
*old
= current_buffer
;
4436 int opoint
, opoint_byte
;
4437 int before
, before_byte
;
4439 ro
= XBUFFER (buffer
)->read_only
;
4441 /* Avoid error if buffer is deleted
4442 (probably that's why the process is dead, too) */
4443 if (NILP (XBUFFER (buffer
)->name
))
4445 Fset_buffer (buffer
);
4448 opoint_byte
= PT_BYTE
;
4449 /* Insert new output into buffer
4450 at the current end-of-output marker,
4451 thus preserving logical ordering of input and output. */
4452 if (XMARKER (p
->mark
)->buffer
)
4453 Fgoto_char (p
->mark
);
4455 SET_PT_BOTH (ZV
, ZV_BYTE
);
4458 before_byte
= PT_BYTE
;
4460 tem
= current_buffer
->read_only
;
4461 current_buffer
->read_only
= Qnil
;
4462 insert_string ("\nProcess ");
4463 Finsert (1, &p
->name
);
4464 insert_string (" ");
4466 current_buffer
->read_only
= tem
;
4467 set_marker_both (p
->mark
, p
->buffer
, PT
, PT_BYTE
);
4469 if (opoint
>= before
)
4470 SET_PT_BOTH (opoint
+ (PT
- before
),
4471 opoint_byte
+ (PT_BYTE
- before_byte
));
4473 SET_PT_BOTH (opoint
, opoint_byte
);
4475 set_buffer_internal (old
);
4480 update_mode_lines
++; /* in case buffers use %s in mode-line-format */
4481 redisplay_preserve_echo_area ();
4487 DEFUN ("set-process-coding-system", Fset_process_coding_system
,
4488 Sset_process_coding_system
, 1, 3, 0,
4489 "Set coding systems of PROCESS to DECODING and ENCODING.\n\
4490 DECODING will be used to decode subprocess output and ENCODING to\n\
4491 encode subprocess input.")
4492 (proc
, decoding
, encoding
)
4493 register Lisp_Object proc
, decoding
, encoding
;
4495 register struct Lisp_Process
*p
;
4497 CHECK_PROCESS (proc
, 0);
4498 p
= XPROCESS (proc
);
4499 if (XINT (p
->infd
) < 0)
4500 error ("Input file descriptor of %s closed", XSTRING (p
->name
)->data
);
4501 if (XINT (p
->outfd
) < 0)
4502 error ("Output file descriptor of %s closed", XSTRING (p
->name
)->data
);
4504 p
->decode_coding_system
= Fcheck_coding_system (decoding
);
4505 p
->encode_coding_system
= Fcheck_coding_system (encoding
);
4506 setup_coding_system (decoding
,
4507 proc_decode_coding_system
[XINT (p
->infd
)]);
4508 setup_coding_system (encoding
,
4509 proc_encode_coding_system
[XINT (p
->outfd
)]);
4514 DEFUN ("process-coding-system",
4515 Fprocess_coding_system
, Sprocess_coding_system
, 1, 1, 0,
4516 "Return a cons of coding systems for decoding and encoding of PROCESS.")
4518 register Lisp_Object proc
;
4520 CHECK_PROCESS (proc
, 0);
4521 return Fcons (XPROCESS (proc
)->decode_coding_system
,
4522 XPROCESS (proc
)->encode_coding_system
);
4525 /* The first time this is called, assume keyboard input comes from DESC
4526 instead of from where we used to expect it.
4527 Subsequent calls mean assume input keyboard can come from DESC
4528 in addition to other places. */
4530 static int add_keyboard_wait_descriptor_called_flag
;
4533 add_keyboard_wait_descriptor (desc
)
4536 if (! add_keyboard_wait_descriptor_called_flag
)
4537 FD_CLR (0, &input_wait_mask
);
4538 add_keyboard_wait_descriptor_called_flag
= 1;
4539 FD_SET (desc
, &input_wait_mask
);
4540 FD_SET (desc
, &non_process_wait_mask
);
4541 if (desc
> max_keyboard_desc
)
4542 max_keyboard_desc
= desc
;
4545 /* From now on, do not expect DESC to give keyboard input. */
4548 delete_keyboard_wait_descriptor (desc
)
4552 int lim
= max_keyboard_desc
;
4554 FD_CLR (desc
, &input_wait_mask
);
4555 FD_CLR (desc
, &non_process_wait_mask
);
4557 if (desc
== max_keyboard_desc
)
4558 for (fd
= 0; fd
< lim
; fd
++)
4559 if (FD_ISSET (fd
, &input_wait_mask
)
4560 && !FD_ISSET (fd
, &non_keyboard_wait_mask
))
4561 max_keyboard_desc
= fd
;
4564 /* Return nonzero if *MASK has a bit set
4565 that corresponds to one of the keyboard input descriptors. */
4568 keyboard_bit_set (mask
)
4573 for (fd
= 0; fd
<= max_keyboard_desc
; fd
++)
4574 if (FD_ISSET (fd
, mask
) && FD_ISSET (fd
, &input_wait_mask
)
4575 && !FD_ISSET (fd
, &non_keyboard_wait_mask
))
4588 if (! noninteractive
|| initialized
)
4590 signal (SIGCHLD
, sigchld_handler
);
4593 FD_ZERO (&input_wait_mask
);
4594 FD_ZERO (&non_keyboard_wait_mask
);
4595 FD_ZERO (&non_process_wait_mask
);
4596 max_process_desc
= 0;
4598 FD_SET (0, &input_wait_mask
);
4600 Vprocess_alist
= Qnil
;
4601 for (i
= 0; i
< MAXDESC
; i
++)
4603 chan_process
[i
] = Qnil
;
4604 proc_buffered_char
[i
] = -1;
4606 bzero (proc_decode_coding_system
, sizeof proc_decode_coding_system
);
4607 bzero (proc_encode_coding_system
, sizeof proc_encode_coding_system
);
4609 Vdefault_process_coding_system
4610 = (NILP (buffer_defaults
.enable_multibyte_characters
)
4611 ? Fcons (Qraw_text
, Qnil
)
4612 : Fcons (Qemacs_mule
, Qnil
));
4618 Qprocessp
= intern ("processp");
4619 staticpro (&Qprocessp
);
4620 Qrun
= intern ("run");
4622 Qstop
= intern ("stop");
4624 Qsignal
= intern ("signal");
4625 staticpro (&Qsignal
);
4627 /* Qexit is already staticpro'd by syms_of_eval; don't staticpro it
4630 Qexit = intern ("exit");
4631 staticpro (&Qexit); */
4633 Qopen
= intern ("open");
4635 Qclosed
= intern ("closed");
4636 staticpro (&Qclosed
);
4638 Qlast_nonmenu_event
= intern ("last-nonmenu-event");
4639 staticpro (&Qlast_nonmenu_event
);
4641 staticpro (&Vprocess_alist
);
4643 DEFVAR_BOOL ("delete-exited-processes", &delete_exited_processes
,
4644 "*Non-nil means delete processes immediately when they exit.\n\
4645 nil means don't delete them until `list-processes' is run.");
4647 delete_exited_processes
= 1;
4649 DEFVAR_LISP ("process-connection-type", &Vprocess_connection_type
,
4650 "Control type of device used to communicate with subprocesses.\n\
4651 Values are nil to use a pipe, or t or `pty' to use a pty.\n\
4652 The value has no effect if the system has no ptys or if all ptys are busy:\n\
4653 then a pipe is used in any case.\n\
4654 The value takes effect when `start-process' is called.");
4655 Vprocess_connection_type
= Qt
;
4657 defsubr (&Sprocessp
);
4658 defsubr (&Sget_process
);
4659 defsubr (&Sget_buffer_process
);
4660 defsubr (&Sdelete_process
);
4661 defsubr (&Sprocess_status
);
4662 defsubr (&Sprocess_exit_status
);
4663 defsubr (&Sprocess_id
);
4664 defsubr (&Sprocess_name
);
4665 defsubr (&Sprocess_tty_name
);
4666 defsubr (&Sprocess_command
);
4667 defsubr (&Sset_process_buffer
);
4668 defsubr (&Sprocess_buffer
);
4669 defsubr (&Sprocess_mark
);
4670 defsubr (&Sset_process_filter
);
4671 defsubr (&Sprocess_filter
);
4672 defsubr (&Sset_process_sentinel
);
4673 defsubr (&Sprocess_sentinel
);
4674 defsubr (&Sset_process_window_size
);
4675 defsubr (&Sset_process_inherit_coding_system_flag
);
4676 defsubr (&Sprocess_inherit_coding_system_flag
);
4677 defsubr (&Sprocess_kill_without_query
);
4678 defsubr (&Sprocess_contact
);
4679 defsubr (&Slist_processes
);
4680 defsubr (&Sprocess_list
);
4681 defsubr (&Sstart_process
);
4683 defsubr (&Sopen_network_stream
);
4684 #endif /* HAVE_SOCKETS */
4685 defsubr (&Saccept_process_output
);
4686 defsubr (&Sprocess_send_region
);
4687 defsubr (&Sprocess_send_string
);
4688 defsubr (&Sinterrupt_process
);
4689 defsubr (&Skill_process
);
4690 defsubr (&Squit_process
);
4691 defsubr (&Sstop_process
);
4692 defsubr (&Scontinue_process
);
4693 defsubr (&Sprocess_running_child_p
);
4694 defsubr (&Sprocess_send_eof
);
4695 defsubr (&Ssignal_process
);
4696 defsubr (&Swaiting_for_user_input_p
);
4697 /* defsubr (&Sprocess_connection); */
4698 defsubr (&Sset_process_coding_system
);
4699 defsubr (&Sprocess_coding_system
);
4703 #else /* not subprocesses */
4705 #include <sys/types.h>
4709 #include "systime.h"
4710 #include "charset.h"
4712 #include "termopts.h"
4713 #include "sysselect.h"
4715 extern int frame_garbaged
;
4717 extern EMACS_TIME
timer_check ();
4718 extern int timers_run
;
4720 /* As described above, except assuming that there are no subprocesses:
4722 Wait for timeout to elapse and/or keyboard input to be available.
4725 timeout in seconds, or
4726 zero for no limit, or
4727 -1 means gobble data immediately available but don't wait for any.
4729 read_kbd is a Lisp_Object:
4730 0 to ignore keyboard input, or
4731 1 to return when input is available, or
4732 -1 means caller will actually read the input, so don't throw to
4734 a cons cell, meaning wait until its car is non-nil
4735 (and gobble terminal input into the buffer if any arrives), or
4736 We know that read_kbd will never be a Lisp_Process, since
4737 `subprocesses' isn't defined.
4739 do_display != 0 means redisplay should be done to show subprocess
4740 output that arrives.
4742 Return true iff we received input from any process. */
4745 wait_reading_process_input (time_limit
, microsecs
, read_kbd
, do_display
)
4746 int time_limit
, microsecs
;
4747 Lisp_Object read_kbd
;
4751 EMACS_TIME end_time
, timeout
;
4752 SELECT_TYPE waitchannels
;
4754 Lisp_Object
*wait_for_cell
= 0;
4756 /* If waiting for non-nil in a cell, record where. */
4757 if (CONSP (read_kbd
))
4759 wait_for_cell
= &XCAR (read_kbd
);
4760 XSETFASTINT (read_kbd
, 0);
4763 /* What does time_limit really mean? */
4764 if (time_limit
|| microsecs
)
4766 EMACS_GET_TIME (end_time
);
4767 EMACS_SET_SECS_USECS (timeout
, time_limit
, microsecs
);
4768 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
4771 /* Turn off periodic alarms (in case they are in use)
4772 because the select emulator uses alarms. */
4773 turn_on_atimers (0);
4777 int timeout_reduced_for_timers
= 0;
4779 /* If calling from keyboard input, do not quit
4780 since we want to return C-g as an input character.
4781 Otherwise, do pending quit if requested. */
4782 if (XINT (read_kbd
) >= 0)
4785 /* Exit now if the cell we're waiting for became non-nil. */
4786 if (wait_for_cell
&& ! NILP (*wait_for_cell
))
4789 /* Compute time from now till when time limit is up */
4790 /* Exit if already run out */
4791 if (time_limit
== -1)
4793 /* -1 specified for timeout means
4794 gobble output available now
4795 but don't wait at all. */
4797 EMACS_SET_SECS_USECS (timeout
, 0, 0);
4799 else if (time_limit
|| microsecs
)
4801 EMACS_GET_TIME (timeout
);
4802 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
4803 if (EMACS_TIME_NEG_P (timeout
))
4808 EMACS_SET_SECS_USECS (timeout
, 100000, 0);
4811 /* If our caller will not immediately handle keyboard events,
4812 run timer events directly.
4813 (Callers that will immediately read keyboard events
4814 call timer_delay on their own.) */
4815 if (! wait_for_cell
)
4817 EMACS_TIME timer_delay
;
4821 old_timers_run
= timers_run
;
4822 timer_delay
= timer_check (1);
4823 if (timers_run
!= old_timers_run
&& do_display
)
4825 redisplay_preserve_echo_area ();
4826 /* We must retry, since a timer may have requeued itself
4827 and that could alter the time delay. */
4831 /* If there is unread keyboard input, also return. */
4832 if (XINT (read_kbd
) != 0
4833 && requeued_events_pending_p ())
4836 if (! EMACS_TIME_NEG_P (timer_delay
) && time_limit
!= -1)
4838 EMACS_TIME difference
;
4839 EMACS_SUB_TIME (difference
, timer_delay
, timeout
);
4840 if (EMACS_TIME_NEG_P (difference
))
4842 timeout
= timer_delay
;
4843 timeout_reduced_for_timers
= 1;
4848 /* Cause C-g and alarm signals to take immediate action,
4849 and cause input available signals to zero out timeout. */
4850 if (XINT (read_kbd
) < 0)
4851 set_waiting_for_input (&timeout
);
4853 /* Wait till there is something to do. */
4855 if (! XINT (read_kbd
) && wait_for_cell
== 0)
4856 FD_ZERO (&waitchannels
);
4858 FD_SET (0, &waitchannels
);
4860 /* If a frame has been newly mapped and needs updating,
4861 reprocess its display stuff. */
4862 if (frame_garbaged
&& do_display
)
4864 clear_waiting_for_input ();
4865 redisplay_preserve_echo_area ();
4866 if (XINT (read_kbd
) < 0)
4867 set_waiting_for_input (&timeout
);
4870 if (XINT (read_kbd
) && detect_input_pending ())
4873 FD_ZERO (&waitchannels
);
4876 nfds
= select (1, &waitchannels
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0,
4881 /* Make C-g and alarm signals set flags again */
4882 clear_waiting_for_input ();
4884 /* If we woke up due to SIGWINCH, actually change size now. */
4885 do_pending_window_change (0);
4887 if (time_limit
&& nfds
== 0 && ! timeout_reduced_for_timers
)
4888 /* We waited the full specified time, so return now. */
4893 /* If the system call was interrupted, then go around the
4895 if (xerrno
== EINTR
)
4896 FD_ZERO (&waitchannels
);
4898 error ("select error: %s", emacs_strerror (xerrno
));
4901 else if (nfds
> 0 && (waitchannels
& 1) && interrupt_input
)
4902 /* System sometimes fails to deliver SIGIO. */
4903 kill (getpid (), SIGIO
);
4906 if (XINT (read_kbd
) && interrupt_input
&& (waitchannels
& 1))
4907 kill (getpid (), SIGIO
);
4910 /* Check for keyboard input */
4912 if ((XINT (read_kbd
) != 0)
4913 && detect_input_pending_run_timers (do_display
))
4915 swallow_events (do_display
);
4916 if (detect_input_pending_run_timers (do_display
))
4920 /* If there is unread keyboard input, also return. */
4921 if (XINT (read_kbd
) != 0
4922 && requeued_events_pending_p ())
4925 /* If wait_for_cell. check for keyboard input
4926 but don't run any timers.
4927 ??? (It seems wrong to me to check for keyboard
4928 input at all when wait_for_cell, but the code
4929 has been this way since July 1994.
4930 Try changing this after version 19.31.) */
4932 && detect_input_pending ())
4934 swallow_events (do_display
);
4935 if (detect_input_pending ())
4939 /* Exit now if the cell we're waiting for became non-nil. */
4940 if (wait_for_cell
&& ! NILP (*wait_for_cell
))
4950 DEFUN ("get-buffer-process", Fget_buffer_process
, Sget_buffer_process
, 1, 1, 0,
4951 /* Don't confuse make-docfile by having two doc strings for this function.
4952 make-docfile does not pay attention to #if, for good reason! */
4955 register Lisp_Object name
;
4960 DEFUN ("process-inherit-coding-system-flag",
4961 Fprocess_inherit_coding_system_flag
, Sprocess_inherit_coding_system_flag
,
4963 /* Don't confuse make-docfile by having two doc strings for this function.
4964 make-docfile does not pay attention to #if, for good reason! */
4967 register Lisp_Object process
;
4969 /* Ignore the argument and return the value of
4970 inherit-process-coding-system. */
4971 return inherit_process_coding_system
? Qt
: Qnil
;
4974 /* Kill all processes associated with `buffer'.
4975 If `buffer' is nil, kill all processes.
4976 Since we have no subprocesses, this does nothing. */
4979 kill_buffer_processes (buffer
)
4992 defsubr (&Sget_buffer_process
);
4993 defsubr (&Sprocess_inherit_coding_system_flag
);
4997 #endif /* not subprocesses */