Mercurial > emacs
annotate src/process.c @ 4413:5a00cec8e9b0
(fill-region-as-paragraph): When we take one word
after the fill column, don't stop at period with just one space.
When checking whether at beginning of line, if no fill prefix,
ignore intervening whitespace.
author | Richard M. Stallman <rms@gnu.org> |
---|---|
date | Mon, 02 Aug 1993 05:55:56 +0000 |
parents | 4055472194b5 |
children | 76f242eb1fa8 |
rev | line source |
---|---|
578 | 1 /* Asynchronous subprocess control for GNU Emacs. |
2961 | 2 Copyright (C) 1985, 1986, 1987, 1988, 1993 Free Software Foundation, Inc. |
578 | 3 |
4 This file is part of GNU Emacs. | |
5 | |
6 GNU Emacs is free software; you can redistribute it and/or modify | |
7 it under the terms of the GNU General Public License as published by | |
1780
d01c59bac5c1
* frame.h (FRAME_SAMPLE_VISIBILITY): Make sure frame is marked as
Jim Blandy <jimb@redhat.com>
parents:
1683
diff
changeset
|
8 the Free Software Foundation; either version 2, or (at your option) |
578 | 9 any later version. |
10 | |
11 GNU Emacs is distributed in the hope that it will be useful, | |
12 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 GNU General Public License for more details. | |
15 | |
16 You should have received a copy of the GNU General Public License | |
17 along with GNU Emacs; see the file COPYING. If not, write to | |
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ | |
19 | |
20 | |
21 #include <signal.h> | |
22 | |
23 #include "config.h" | |
24 | |
588 | 25 /* This file is split into two parts by the following preprocessor |
26 conditional. The 'then' clause contains all of the support for | |
27 asynchronous subprocesses. The 'else' clause contains stub | |
28 versions of some of the asynchronous subprocess routines that are | |
29 often called elsewhere in Emacs, so we don't have to #ifdef the | |
30 sections that call them. */ | |
31 | |
32 | |
578 | 33 #ifdef subprocesses |
34 | |
35 #include <stdio.h> | |
36 #include <errno.h> | |
37 #include <setjmp.h> | |
38 #include <sys/types.h> /* some typedefs are used in sys/file.h */ | |
39 #include <sys/file.h> | |
40 #include <sys/stat.h> | |
41 | |
42 #ifdef HAVE_SOCKETS /* TCP connection support, if kernel can do it */ | |
43 #include <sys/socket.h> | |
44 #include <netdb.h> | |
45 #include <netinet/in.h> | |
46 #include <arpa/inet.h> | |
47 #endif /* HAVE_SOCKETS */ | |
48 | |
49 #if defined(BSD) || defined(STRIDE) | |
50 #include <sys/ioctl.h> | |
1012
a48ed1d416dd
* process.c (process_send_signal): Don't send SIGTSTP if the
Jim Blandy <jimb@redhat.com>
parents:
849
diff
changeset
|
51 #if !defined (O_NDELAY) && defined (HAVE_PTYS) && !defined(USG5) |
578 | 52 #include <fcntl.h> |
53 #endif /* HAVE_PTYS and no O_NDELAY */ | |
54 #endif /* BSD or STRIDE */ | |
55 | |
56 #ifdef NEED_BSDTTY | |
57 #include <bsdtty.h> | |
58 #endif | |
59 | |
60 #ifdef IRIS | |
61 #include <sys/sysmacros.h> /* for "minor" */ | |
62 #endif /* not IRIS */ | |
63 | |
64 #include "systime.h" | |
1047
1ab1ed32e82a
* process.c: Include "systty.h", not "systerm.h".
Jim Blandy <jimb@redhat.com>
parents:
1030
diff
changeset
|
65 #include "systty.h" |
578 | 66 |
67 #include "lisp.h" | |
68 #include "window.h" | |
69 #include "buffer.h" | |
70 #include "process.h" | |
71 #include "termhooks.h" | |
72 #include "termopts.h" | |
73 #include "commands.h" | |
1780
d01c59bac5c1
* frame.h (FRAME_SAMPLE_VISIBILITY): Make sure frame is marked as
Jim Blandy <jimb@redhat.com>
parents:
1683
diff
changeset
|
74 #include "frame.h" |
578 | 75 |
76 Lisp_Object Qrun, Qstop, Qsignal, Qopen, Qclosed; | |
77 /* Qexit is declared and initialized in eval.c. */ | |
78 | |
79 /* a process object is a network connection when its childp field is neither | |
80 Qt nor Qnil but is instead a string (name of foreign host we | |
81 are connected to + name of port we are connected to) */ | |
82 | |
83 #ifdef HAVE_SOCKETS | |
84 static Lisp_Object stream_process; | |
85 | |
86 #define NETCONN_P(p) (XGCTYPE (XPROCESS (p)->childp) == Lisp_String) | |
87 #else | |
88 #define NETCONN_P(p) 0 | |
89 #endif /* HAVE_SOCKETS */ | |
90 | |
91 /* Define first descriptor number available for subprocesses. */ | |
92 #ifdef VMS | |
93 #define FIRST_PROC_DESC 1 | |
94 #else /* Not VMS */ | |
95 #define FIRST_PROC_DESC 3 | |
96 #endif | |
97 | |
98 /* Define SIGCHLD as an alias for SIGCLD. There are many conditionals | |
99 testing SIGCHLD. */ | |
100 | |
101 #if !defined (SIGCHLD) && defined (SIGCLD) | |
102 #define SIGCHLD SIGCLD | |
103 #endif /* SIGCLD */ | |
104 | |
105 #include "syssignal.h" | |
106 | |
107 /* Define the structure that the wait system call stores. | |
108 On many systems, there is a structure defined for this. | |
109 But on vanilla-ish USG systems there is not. */ | |
110 | |
111 #ifndef VMS | |
112 #ifndef WAITTYPE | |
2917
725698689fbd
Some more changes from Michael K. Johnson for Linux.
Jim Blandy <jimb@redhat.com>
parents:
2894
diff
changeset
|
113 #if (!defined (BSD) && !defined (UNIPLUS) && !defined (STRIDE) && !(defined (HPUX) && !defined (NOMULTIPLEJOBS)) && !defined (HAVE_WAIT_HEADER)) || defined (LINUX) |
578 | 114 #define WAITTYPE int |
115 #define WIFSTOPPED(w) ((w&0377) == 0177) | |
116 #define WIFSIGNALED(w) ((w&0377) != 0177 && (w&~0377) == 0) | |
117 #define WIFEXITED(w) ((w&0377) == 0) | |
118 #define WRETCODE(w) (w >> 8) | |
119 #define WSTOPSIG(w) (w >> 8) | |
1030
9934251d8219
(WCOREDUMP): Define only if not defined.
Richard M. Stallman <rms@gnu.org>
parents:
1012
diff
changeset
|
120 #define WTERMSIG(w) (w & 0377) |
9934251d8219
(WCOREDUMP): Define only if not defined.
Richard M. Stallman <rms@gnu.org>
parents:
1012
diff
changeset
|
121 #ifndef WCOREDUMP |
578 | 122 #define WCOREDUMP(w) ((w&0200) != 0) |
1030
9934251d8219
(WCOREDUMP): Define only if not defined.
Richard M. Stallman <rms@gnu.org>
parents:
1012
diff
changeset
|
123 #endif |
578 | 124 #else |
125 #ifdef BSD4_1 | |
126 #include <wait.h> | |
127 #else | |
128 #include <sys/wait.h> | |
129 #endif /* not BSD 4.1 */ | |
130 | |
131 #define WAITTYPE union wait | |
132 #define WRETCODE(w) w.w_retcode | |
133 #define WCOREDUMP(w) w.w_coredump | |
134 | |
135 #ifdef HPUX | |
136 /* HPUX version 7 has broken definitions of these. */ | |
137 #undef WTERMSIG | |
138 #undef WSTOPSIG | |
139 #undef WIFSTOPPED | |
140 #undef WIFSIGNALED | |
141 #undef WIFEXITED | |
142 #endif | |
143 | |
144 #ifndef WTERMSIG | |
145 #define WTERMSIG(w) w.w_termsig | |
146 #endif | |
147 #ifndef WSTOPSIG | |
148 #define WSTOPSIG(w) w.w_stopsig | |
149 #endif | |
150 #ifndef WIFSTOPPED | |
151 #define WIFSTOPPED(w) (WTERMSIG (w) == 0177) | |
152 #endif | |
153 #ifndef WIFSIGNALED | |
154 #define WIFSIGNALED(w) (WTERMSIG (w) != 0177 && (WSTOPSIG (w)) == 0) | |
155 #endif | |
156 #ifndef WIFEXITED | |
157 #define WIFEXITED(w) (WTERMSIG (w) == 0) | |
158 #endif | |
159 #endif /* BSD or UNIPLUS or STRIDE */ | |
160 #endif /* no WAITTYPE */ | |
161 #else /* VMS */ | |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
162 #define WAITTYPE int |
2357
9faa3a02ea97
* process.c [VMS] (DCL_PROMPT): Remove hack.
Jim Blandy <jimb@redhat.com>
parents:
2290
diff
changeset
|
163 #define WIFSTOPPED(w) 0 |
9faa3a02ea97
* process.c [VMS] (DCL_PROMPT): Remove hack.
Jim Blandy <jimb@redhat.com>
parents:
2290
diff
changeset
|
164 #define WIFSIGNALED(w) 0 |
9faa3a02ea97
* process.c [VMS] (DCL_PROMPT): Remove hack.
Jim Blandy <jimb@redhat.com>
parents:
2290
diff
changeset
|
165 #define WIFEXITED(w) ((w) != -1) |
9faa3a02ea97
* process.c [VMS] (DCL_PROMPT): Remove hack.
Jim Blandy <jimb@redhat.com>
parents:
2290
diff
changeset
|
166 #define WRETCODE(w) (w) |
9faa3a02ea97
* process.c [VMS] (DCL_PROMPT): Remove hack.
Jim Blandy <jimb@redhat.com>
parents:
2290
diff
changeset
|
167 #define WSTOPSIG(w) (w) |
9faa3a02ea97
* process.c [VMS] (DCL_PROMPT): Remove hack.
Jim Blandy <jimb@redhat.com>
parents:
2290
diff
changeset
|
168 #define WCOREDUMP(w) 0 |
9faa3a02ea97
* process.c [VMS] (DCL_PROMPT): Remove hack.
Jim Blandy <jimb@redhat.com>
parents:
2290
diff
changeset
|
169 #define WTERMSIG(w) (w) |
578 | 170 #include <ssdef.h> |
171 #include <iodef.h> | |
172 #include <clidef.h> | |
173 #include "vmsproc.h" | |
174 #endif /* VMS */ | |
175 | |
176 extern errno; | |
177 extern sys_nerr; | |
178 extern char *sys_errlist[]; | |
179 | |
180 #ifndef VMS | |
181 #ifndef BSD4_1 | |
3023
cfd999700613
(create_process): Ignore retval from TIOCSTTY.
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
182 #ifndef LINUX |
578 | 183 extern char *sys_siglist[]; |
3023
cfd999700613
(create_process): Ignore retval from TIOCSTTY.
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
184 #endif |
578 | 185 #else |
186 char *sys_siglist[] = | |
187 { | |
188 "bum signal!!", | |
189 "hangup", | |
190 "interrupt", | |
191 "quit", | |
192 "illegal instruction", | |
193 "trace trap", | |
194 "iot instruction", | |
195 "emt instruction", | |
196 "floating point exception", | |
197 "kill", | |
198 "bus error", | |
199 "segmentation violation", | |
200 "bad argument to system call", | |
201 "write on a pipe with no one to read it", | |
202 "alarm clock", | |
203 "software termination signal from kill", | |
204 "status signal", | |
205 "sendable stop signal not from tty", | |
206 "stop signal from tty", | |
207 "continue a stopped process", | |
208 "child status has changed", | |
209 "background read attempted from control tty", | |
210 "background write attempted from control tty", | |
211 "input record available at control tty", | |
212 "exceeded CPU time limit", | |
213 "exceeded file size limit" | |
214 }; | |
215 #endif | |
216 #endif /* VMS */ | |
217 | |
218 /* t means use pty, nil means use a pipe, | |
219 maybe other values to come. */ | |
220 Lisp_Object Vprocess_connection_type; | |
221 | |
222 #ifdef SKTPAIR | |
223 #ifndef HAVE_SOCKETS | |
224 #include <sys/socket.h> | |
225 #endif | |
226 #endif /* SKTPAIR */ | |
227 | |
228 /* Number of events of change of status of a process. */ | |
229 int process_tick; | |
230 | |
231 /* Number of events for which the user or sentinel has been notified. */ | |
232 int update_tick; | |
233 | |
234 #ifdef FD_SET | |
235 /* We could get this from param.h, but better not to depend on finding that. | |
236 And better not to risk that it might define other symbols used in this | |
237 file. */ | |
3238
0f0d9e9c33f2
(MAXDESC): Get it from FD_SETSIZE if that exists.
Richard M. Stallman <rms@gnu.org>
parents:
3103
diff
changeset
|
238 #ifdef FD_SETSIZE |
0f0d9e9c33f2
(MAXDESC): Get it from FD_SETSIZE if that exists.
Richard M. Stallman <rms@gnu.org>
parents:
3103
diff
changeset
|
239 #define MAXDESC FD_SETSIZE |
0f0d9e9c33f2
(MAXDESC): Get it from FD_SETSIZE if that exists.
Richard M. Stallman <rms@gnu.org>
parents:
3103
diff
changeset
|
240 #else |
578 | 241 #define MAXDESC 64 |
3238
0f0d9e9c33f2
(MAXDESC): Get it from FD_SETSIZE if that exists.
Richard M. Stallman <rms@gnu.org>
parents:
3103
diff
changeset
|
242 #endif |
578 | 243 #define SELECT_TYPE fd_set |
244 #else /* no FD_SET */ | |
245 #define MAXDESC 32 | |
246 #define SELECT_TYPE int | |
247 | |
248 /* Define the macros to access a single-int bitmap of descriptors. */ | |
249 #define FD_SET(n, p) (*(p) |= (1 << (n))) | |
250 #define FD_CLR(n, p) (*(p) &= ~(1 << (n))) | |
251 #define FD_ISSET(n, p) (*(p) & (1 << (n))) | |
252 #define FD_ZERO(p) (*(p) = 0) | |
253 #endif /* no FD_SET */ | |
254 | |
255 /* Mask of bits indicating the descriptors that we wait for input on */ | |
256 | |
257 SELECT_TYPE input_wait_mask; | |
258 | |
259 int delete_exited_processes; | |
260 | |
261 /* Indexed by descriptor, gives the process (if any) for that descriptor */ | |
262 Lisp_Object chan_process[MAXDESC]; | |
263 | |
264 /* Alist of elements (NAME . PROCESS) */ | |
265 Lisp_Object Vprocess_alist; | |
266 | |
267 Lisp_Object Qprocessp; | |
268 | |
269 Lisp_Object get_process (); | |
270 | |
271 /* Buffered-ahead input char from process, indexed by channel. | |
272 -1 means empty (no char is buffered). | |
273 Used on sys V where the only way to tell if there is any | |
274 output from the process is to read at least one char. | |
275 Always -1 on systems that support FIONREAD. */ | |
276 | |
277 int proc_buffered_char[MAXDESC]; | |
278 | |
279 /* Compute the Lisp form of the process status, p->status, from | |
280 the numeric status that was returned by `wait'. */ | |
281 | |
1522
19ccf004b172
* process.c: (status_convert): Declare this to return a
Jim Blandy <jimb@redhat.com>
parents:
1323
diff
changeset
|
282 Lisp_Object status_convert (); |
19ccf004b172
* process.c: (status_convert): Declare this to return a
Jim Blandy <jimb@redhat.com>
parents:
1323
diff
changeset
|
283 |
578 | 284 update_status (p) |
285 struct Lisp_Process *p; | |
286 { | |
287 union { int i; WAITTYPE wt; } u; | |
288 u.i = XFASTINT (p->raw_status_low) + (XFASTINT (p->raw_status_high) << 16); | |
289 p->status = status_convert (u.wt); | |
290 p->raw_status_low = Qnil; | |
291 p->raw_status_high = Qnil; | |
292 } | |
293 | |
3608 | 294 /* Convert a process status word in Unix format to |
578 | 295 the list that we use internally. */ |
296 | |
297 Lisp_Object | |
298 status_convert (w) | |
299 WAITTYPE w; | |
300 { | |
301 if (WIFSTOPPED (w)) | |
302 return Fcons (Qstop, Fcons (make_number (WSTOPSIG (w)), Qnil)); | |
303 else if (WIFEXITED (w)) | |
304 return Fcons (Qexit, Fcons (make_number (WRETCODE (w)), | |
305 WCOREDUMP (w) ? Qt : Qnil)); | |
306 else if (WIFSIGNALED (w)) | |
307 return Fcons (Qsignal, Fcons (make_number (WTERMSIG (w)), | |
308 WCOREDUMP (w) ? Qt : Qnil)); | |
309 else | |
310 return Qrun; | |
311 } | |
312 | |
313 /* Given a status-list, extract the three pieces of information | |
314 and store them individually through the three pointers. */ | |
315 | |
316 void | |
317 decode_status (l, symbol, code, coredump) | |
318 Lisp_Object l; | |
319 Lisp_Object *symbol; | |
320 int *code; | |
321 int *coredump; | |
322 { | |
323 Lisp_Object tem; | |
324 | |
325 if (XTYPE (l) == Lisp_Symbol) | |
326 { | |
327 *symbol = l; | |
328 *code = 0; | |
329 *coredump = 0; | |
330 } | |
331 else | |
332 { | |
333 *symbol = XCONS (l)->car; | |
334 tem = XCONS (l)->cdr; | |
335 *code = XFASTINT (XCONS (tem)->car); | |
1522
19ccf004b172
* process.c: (status_convert): Declare this to return a
Jim Blandy <jimb@redhat.com>
parents:
1323
diff
changeset
|
336 tem = XCONS (tem)->cdr; |
578 | 337 *coredump = !NILP (tem); |
338 } | |
339 } | |
340 | |
341 /* Return a string describing a process status list. */ | |
342 | |
343 Lisp_Object | |
344 status_message (status) | |
345 Lisp_Object status; | |
346 { | |
347 Lisp_Object symbol; | |
348 int code, coredump; | |
349 Lisp_Object string, string2; | |
350 | |
351 decode_status (status, &symbol, &code, &coredump); | |
352 | |
353 if (EQ (symbol, Qsignal) || EQ (symbol, Qstop)) | |
354 { | |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
355 #ifndef VMS |
578 | 356 string = build_string (code < NSIG ? sys_siglist[code] : "unknown"); |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
357 #else |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
358 string = build_string (code < NSIG ? sys_errlist[code] : "unknown"); |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
359 #endif |
578 | 360 string2 = build_string (coredump ? " (core dumped)\n" : "\n"); |
361 XSTRING (string)->data[0] = DOWNCASE (XSTRING (string)->data[0]); | |
362 return concat2 (string, string2); | |
363 } | |
364 else if (EQ (symbol, Qexit)) | |
365 { | |
366 if (code == 0) | |
367 return build_string ("finished\n"); | |
2429
96b55f2f19cd
Rename int-to-string to number-to-string, since it can handle
Jim Blandy <jimb@redhat.com>
parents:
2357
diff
changeset
|
368 string = Fnumber_to_string (make_number (code)); |
578 | 369 string2 = build_string (coredump ? " (core dumped)\n" : "\n"); |
370 return concat2 (build_string ("exited abnormally with code "), | |
371 concat2 (string, string2)); | |
372 } | |
373 else | |
374 return Fcopy_sequence (Fsymbol_name (symbol)); | |
375 } | |
376 | |
377 #ifdef HAVE_PTYS | |
378 | |
379 /* Open an available pty, returning a file descriptor. | |
380 Return -1 on failure. | |
381 The file name of the terminal corresponding to the pty | |
382 is left in the variable pty_name. */ | |
383 | |
384 char pty_name[24]; | |
385 | |
386 int | |
387 allocate_pty () | |
388 { | |
389 struct stat stb; | |
390 register c, i; | |
391 int fd; | |
392 | |
624 | 393 /* Some systems name their pseudoterminals so that there are gaps in |
394 the usual sequence - for example, on HP9000/S700 systems, there | |
395 are no pseudoterminals with names ending in 'f'. So we wait for | |
396 three failures in a row before deciding that we've reached the | |
397 end of the ptys. */ | |
398 int failed_count = 0; | |
399 | |
578 | 400 #ifdef PTY_ITERATION |
401 PTY_ITERATION | |
402 #else | |
403 for (c = FIRST_PTY_LETTER; c <= 'z'; c++) | |
404 for (i = 0; i < 16; i++) | |
405 #endif | |
406 { | |
407 #ifdef PTY_NAME_SPRINTF | |
408 PTY_NAME_SPRINTF | |
409 #else | |
410 sprintf (pty_name, "/dev/pty%c%x", c, i); | |
411 #endif /* no PTY_NAME_SPRINTF */ | |
412 | |
822
c6e94e13926c
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
808
diff
changeset
|
413 #ifdef PTY_OPEN |
c6e94e13926c
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
808
diff
changeset
|
414 PTY_OPEN; |
c6e94e13926c
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
808
diff
changeset
|
415 #else /* no PTY_OPEN */ |
624 | 416 #ifdef IRIS |
417 /* Unusual IRIS code */ | |
418 *ptyv = open ("/dev/ptc", O_RDWR | O_NDELAY, 0); | |
419 if (fd < 0) | |
420 return -1; | |
421 if (fstat (fd, &stb) < 0) | |
422 return -1; | |
822
c6e94e13926c
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
808
diff
changeset
|
423 #else /* not IRIS */ |
578 | 424 if (stat (pty_name, &stb) < 0) |
624 | 425 { |
426 failed_count++; | |
427 if (failed_count >= 3) | |
428 return -1; | |
429 } | |
430 else | |
431 failed_count = 0; | |
578 | 432 #ifdef O_NONBLOCK |
433 fd = open (pty_name, O_RDWR | O_NONBLOCK, 0); | |
434 #else | |
435 fd = open (pty_name, O_RDWR | O_NDELAY, 0); | |
436 #endif | |
822
c6e94e13926c
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
808
diff
changeset
|
437 #endif /* not IRIS */ |
c6e94e13926c
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
808
diff
changeset
|
438 #endif /* no PTY_OPEN */ |
578 | 439 |
440 if (fd >= 0) | |
441 { | |
442 /* check to make certain that both sides are available | |
443 this avoids a nasty yet stupid bug in rlogins */ | |
444 #ifdef PTY_TTY_NAME_SPRINTF | |
445 PTY_TTY_NAME_SPRINTF | |
446 #else | |
447 sprintf (pty_name, "/dev/tty%c%x", c, i); | |
448 #endif /* no PTY_TTY_NAME_SPRINTF */ | |
449 #ifndef UNIPLUS | |
450 if (access (pty_name, 6) != 0) | |
451 { | |
452 close (fd); | |
2887
0554478bfa71
* process.c [__sgi] (allocate_pty): Give up immediately if pty is
Jim Blandy <jimb@redhat.com>
parents:
2830
diff
changeset
|
453 #if !defined(IRIS) && !defined(__sgi) |
578 | 454 continue; |
455 #else | |
456 return -1; | |
457 #endif /* IRIS */ | |
458 } | |
459 #endif /* not UNIPLUS */ | |
460 setup_pty (fd); | |
461 return fd; | |
462 } | |
463 } | |
464 return -1; | |
465 } | |
466 #endif /* HAVE_PTYS */ | |
467 | |
468 Lisp_Object | |
469 make_process (name) | |
470 Lisp_Object name; | |
471 { | |
472 register Lisp_Object val, tem, name1; | |
473 register struct Lisp_Process *p; | |
474 char suffix[10]; | |
475 register int i; | |
476 | |
477 /* size of process structure includes the vector header, | |
478 so deduct for that. But struct Lisp_Vector includes the first | |
479 element, thus deducts too much, so add it back. */ | |
480 val = Fmake_vector (make_number ((sizeof (struct Lisp_Process) | |
481 - sizeof (struct Lisp_Vector) | |
482 + sizeof (Lisp_Object)) | |
483 / sizeof (Lisp_Object)), | |
484 Qnil); | |
485 XSETTYPE (val, Lisp_Process); | |
486 | |
487 p = XPROCESS (val); | |
488 XFASTINT (p->infd) = 0; | |
489 XFASTINT (p->outfd) = 0; | |
490 XFASTINT (p->pid) = 0; | |
491 XFASTINT (p->tick) = 0; | |
492 XFASTINT (p->update_tick) = 0; | |
493 p->raw_status_low = Qnil; | |
494 p->raw_status_high = Qnil; | |
495 p->status = Qrun; | |
496 p->mark = Fmake_marker (); | |
497 | |
498 /* If name is already in use, modify it until it is unused. */ | |
499 | |
500 name1 = name; | |
501 for (i = 1; ; i++) | |
502 { | |
503 tem = Fget_process (name1); | |
504 if (NILP (tem)) break; | |
505 sprintf (suffix, "<%d>", i); | |
506 name1 = concat2 (name, build_string (suffix)); | |
507 } | |
508 name = name1; | |
509 p->name = name; | |
510 Vprocess_alist = Fcons (Fcons (name, val), Vprocess_alist); | |
511 return val; | |
512 } | |
513 | |
514 remove_process (proc) | |
515 register Lisp_Object proc; | |
516 { | |
517 register Lisp_Object pair; | |
518 | |
519 pair = Frassq (proc, Vprocess_alist); | |
520 Vprocess_alist = Fdelq (pair, Vprocess_alist); | |
521 Fset_marker (XPROCESS (proc)->mark, Qnil, Qnil); | |
522 | |
523 deactivate_process (proc); | |
524 } | |
525 | |
526 DEFUN ("processp", Fprocessp, Sprocessp, 1, 1, 0, | |
527 "Return t if OBJECT is a process.") | |
528 (obj) | |
529 Lisp_Object obj; | |
530 { | |
531 return XTYPE (obj) == Lisp_Process ? Qt : Qnil; | |
532 } | |
533 | |
534 DEFUN ("get-process", Fget_process, Sget_process, 1, 1, 0, | |
535 "Return the process named NAME, or nil if there is none.") | |
536 (name) | |
537 register Lisp_Object name; | |
538 { | |
539 if (XTYPE (name) == Lisp_Process) | |
540 return name; | |
541 CHECK_STRING (name, 0); | |
542 return Fcdr (Fassoc (name, Vprocess_alist)); | |
543 } | |
544 | |
545 DEFUN ("get-buffer-process", Fget_buffer_process, Sget_buffer_process, 1, 1, 0, | |
546 "Return the (or, a) process associated with BUFFER.\n\ | |
547 BUFFER may be a buffer or the name of one.") | |
548 (name) | |
549 register Lisp_Object name; | |
550 { | |
551 register Lisp_Object buf, tail, proc; | |
552 | |
553 if (NILP (name)) return Qnil; | |
554 buf = Fget_buffer (name); | |
555 if (NILP (buf)) return Qnil; | |
556 | |
557 for (tail = Vprocess_alist; !NILP (tail); tail = Fcdr (tail)) | |
558 { | |
559 proc = Fcdr (Fcar (tail)); | |
560 if (XTYPE (proc) == Lisp_Process && EQ (XPROCESS (proc)->buffer, buf)) | |
561 return proc; | |
562 } | |
563 return Qnil; | |
564 } | |
565 | |
808 | 566 /* This is how commands for the user decode process arguments. It |
567 accepts a process, a process name, a buffer, a buffer name, or nil. | |
568 Buffers denote the first process in the buffer, and nil denotes the | |
569 current buffer. */ | |
578 | 570 |
571 Lisp_Object | |
572 get_process (name) | |
573 register Lisp_Object name; | |
574 { | |
575 register Lisp_Object proc; | |
576 if (NILP (name)) | |
577 proc = Fget_buffer_process (Fcurrent_buffer ()); | |
578 else | |
579 { | |
580 proc = Fget_process (name); | |
581 if (NILP (proc)) | |
582 proc = Fget_buffer_process (Fget_buffer (name)); | |
583 } | |
584 | |
585 if (!NILP (proc)) | |
586 return proc; | |
587 | |
588 if (NILP (name)) | |
589 error ("Current buffer has no process"); | |
590 else | |
591 error ("Process %s does not exist", XSTRING (name)->data); | |
592 /* NOTREACHED */ | |
593 } | |
594 | |
595 DEFUN ("delete-process", Fdelete_process, Sdelete_process, 1, 1, 0, | |
596 "Delete PROCESS: kill it and forget about it immediately.\n\ | |
808 | 597 PROCESS may be a process, a buffer, the name of a process or buffer, or\n\ |
598 nil, indicating the current buffer's process.") | |
578 | 599 (proc) |
600 register Lisp_Object proc; | |
601 { | |
602 proc = get_process (proc); | |
603 XPROCESS (proc)->raw_status_low = Qnil; | |
604 XPROCESS (proc)->raw_status_high = Qnil; | |
605 if (NETCONN_P (proc)) | |
606 { | |
607 XPROCESS (proc)->status = Fcons (Qexit, Fcons (make_number (0), Qnil)); | |
608 XSETINT (XPROCESS (proc)->tick, ++process_tick); | |
609 } | |
610 else if (XFASTINT (XPROCESS (proc)->infd)) | |
611 { | |
612 Fkill_process (proc, Qnil); | |
613 /* Do this now, since remove_process will make sigchld_handler do nothing. */ | |
614 XPROCESS (proc)->status | |
615 = Fcons (Qsignal, Fcons (make_number (SIGKILL), Qnil)); | |
616 XSETINT (XPROCESS (proc)->tick, ++process_tick); | |
617 status_notify (); | |
618 } | |
619 remove_process (proc); | |
620 return Qnil; | |
621 } | |
622 | |
623 DEFUN ("process-status", Fprocess_status, Sprocess_status, 1, 1, 0, | |
624 "Return the status of PROCESS: a symbol, one of these:\n\ | |
625 run -- for a process that is running.\n\ | |
626 stop -- for a process stopped but continuable.\n\ | |
627 exit -- for a process that has exited.\n\ | |
628 signal -- for a process that has got a fatal signal.\n\ | |
629 open -- for a network stream connection that is open.\n\ | |
630 closed -- for a network stream connection that is closed.\n\ | |
808 | 631 nil -- if arg is a process name and no such process exists.\n\ |
632 PROCESS may be a process, a buffer, the name of a process or buffer, or\n\ | |
633 nil, indicating the current buffer's process.") | |
578 | 634 (proc) |
635 register Lisp_Object proc; | |
636 { | |
637 register struct Lisp_Process *p; | |
638 register Lisp_Object status; | |
4257
f8b1ea675224
(Fprocess_status): Use Fget_process, to avoid error
Richard M. Stallman <rms@gnu.org>
parents:
4231
diff
changeset
|
639 proc = Fget_process (proc); |
578 | 640 if (NILP (proc)) |
641 return proc; | |
642 p = XPROCESS (proc); | |
643 if (!NILP (p->raw_status_low)) | |
644 update_status (p); | |
645 status = p->status; | |
646 if (XTYPE (status) == Lisp_Cons) | |
647 status = XCONS (status)->car; | |
648 if (NETCONN_P (proc)) | |
649 { | |
650 if (EQ (status, Qrun)) | |
651 status = Qopen; | |
652 else if (EQ (status, Qexit)) | |
653 status = Qclosed; | |
654 } | |
655 return status; | |
656 } | |
657 | |
658 DEFUN ("process-exit-status", Fprocess_exit_status, Sprocess_exit_status, | |
659 1, 1, 0, | |
660 "Return the exit status of PROCESS or the signal number that killed it.\n\ | |
661 If PROCESS has not yet exited or died, return 0.") | |
662 (proc) | |
663 register Lisp_Object proc; | |
664 { | |
665 CHECK_PROCESS (proc, 0); | |
666 if (!NILP (XPROCESS (proc)->raw_status_low)) | |
667 update_status (XPROCESS (proc)); | |
668 if (XTYPE (XPROCESS (proc)->status) == Lisp_Cons) | |
669 return XCONS (XCONS (XPROCESS (proc)->status)->cdr)->car; | |
670 return make_number (0); | |
671 } | |
672 | |
673 DEFUN ("process-id", Fprocess_id, Sprocess_id, 1, 1, 0, | |
674 "Return the process id of PROCESS.\n\ | |
675 This is the pid of the Unix process which PROCESS uses or talks to.\n\ | |
676 For a network connection, this value is nil.") | |
677 (proc) | |
678 register Lisp_Object proc; | |
679 { | |
680 CHECK_PROCESS (proc, 0); | |
681 return XPROCESS (proc)->pid; | |
682 } | |
683 | |
684 DEFUN ("process-name", Fprocess_name, Sprocess_name, 1, 1, 0, | |
685 "Return the name of PROCESS, as a string.\n\ | |
686 This is the name of the program invoked in PROCESS,\n\ | |
687 possibly modified to make it unique among process names.") | |
688 (proc) | |
689 register Lisp_Object proc; | |
690 { | |
691 CHECK_PROCESS (proc, 0); | |
692 return XPROCESS (proc)->name; | |
693 } | |
694 | |
695 DEFUN ("process-command", Fprocess_command, Sprocess_command, 1, 1, 0, | |
696 "Return the command that was executed to start PROCESS.\n\ | |
697 This is a list of strings, the first string being the program executed\n\ | |
698 and the rest of the strings being the arguments given to it.\n\ | |
699 For a non-child channel, this is nil.") | |
700 (proc) | |
701 register Lisp_Object proc; | |
702 { | |
703 CHECK_PROCESS (proc, 0); | |
704 return XPROCESS (proc)->command; | |
705 } | |
706 | |
707 DEFUN ("set-process-buffer", Fset_process_buffer, Sset_process_buffer, | |
708 2, 2, 0, | |
709 "Set buffer associated with PROCESS to BUFFER (a buffer, or nil).") | |
710 (proc, buffer) | |
711 register Lisp_Object proc, buffer; | |
712 { | |
713 CHECK_PROCESS (proc, 0); | |
714 if (!NILP (buffer)) | |
715 CHECK_BUFFER (buffer, 1); | |
716 XPROCESS (proc)->buffer = buffer; | |
717 return buffer; | |
718 } | |
719 | |
720 DEFUN ("process-buffer", Fprocess_buffer, Sprocess_buffer, | |
721 1, 1, 0, | |
722 "Return the buffer PROCESS is associated with.\n\ | |
723 Output from PROCESS is inserted in this buffer\n\ | |
724 unless PROCESS has a filter.") | |
725 (proc) | |
726 register Lisp_Object proc; | |
727 { | |
728 CHECK_PROCESS (proc, 0); | |
729 return XPROCESS (proc)->buffer; | |
730 } | |
731 | |
732 DEFUN ("process-mark", Fprocess_mark, Sprocess_mark, | |
733 1, 1, 0, | |
734 "Return the marker for the end of the last output from PROCESS.") | |
735 (proc) | |
736 register Lisp_Object proc; | |
737 { | |
738 CHECK_PROCESS (proc, 0); | |
739 return XPROCESS (proc)->mark; | |
740 } | |
741 | |
742 DEFUN ("set-process-filter", Fset_process_filter, Sset_process_filter, | |
743 2, 2, 0, | |
744 "Give PROCESS the filter function FILTER; nil means no filter.\n\ | |
745 When a process has a filter, each time it does output\n\ | |
746 the entire string of output is passed to the filter.\n\ | |
747 The filter gets two arguments: the process and the string of output.\n\ | |
748 If the process has a filter, its buffer is not used for output.") | |
749 (proc, filter) | |
750 register Lisp_Object proc, filter; | |
751 { | |
752 CHECK_PROCESS (proc, 0); | |
753 XPROCESS (proc)->filter = filter; | |
754 return filter; | |
755 } | |
756 | |
757 DEFUN ("process-filter", Fprocess_filter, Sprocess_filter, | |
758 1, 1, 0, | |
759 "Returns the filter function of PROCESS; nil if none.\n\ | |
760 See `set-process-filter' for more info on filter functions.") | |
761 (proc) | |
762 register Lisp_Object proc; | |
763 { | |
764 CHECK_PROCESS (proc, 0); | |
765 return XPROCESS (proc)->filter; | |
766 } | |
767 | |
768 DEFUN ("set-process-sentinel", Fset_process_sentinel, Sset_process_sentinel, | |
769 2, 2, 0, | |
770 "Give PROCESS the sentinel SENTINEL; nil for none.\n\ | |
771 The sentinel is called as a function when the process changes state.\n\ | |
772 It gets two arguments: the process, and a string describing the change.") | |
773 (proc, sentinel) | |
774 register Lisp_Object proc, sentinel; | |
775 { | |
776 CHECK_PROCESS (proc, 0); | |
777 XPROCESS (proc)->sentinel = sentinel; | |
778 return sentinel; | |
779 } | |
780 | |
781 DEFUN ("process-sentinel", Fprocess_sentinel, Sprocess_sentinel, | |
782 1, 1, 0, | |
783 "Return the sentinel of PROCESS; nil if none.\n\ | |
784 See `set-process-sentinel' for more info on sentinels.") | |
785 (proc) | |
786 register Lisp_Object proc; | |
787 { | |
788 CHECK_PROCESS (proc, 0); | |
789 return XPROCESS (proc)->sentinel; | |
790 } | |
791 | |
792 DEFUN ("process-kill-without-query", Fprocess_kill_without_query, | |
793 Sprocess_kill_without_query, 1, 2, 0, | |
794 "Say no query needed if PROCESS is running when Emacs is exited.\n\ | |
795 Optional second argument if non-nill says to require a query.\n\ | |
796 Value is t if a query was formerly required.") | |
797 (proc, value) | |
798 register Lisp_Object proc, value; | |
799 { | |
800 Lisp_Object tem; | |
801 | |
802 CHECK_PROCESS (proc, 0); | |
803 tem = XPROCESS (proc)->kill_without_query; | |
804 XPROCESS (proc)->kill_without_query = Fnull (value); | |
805 | |
806 return Fnull (tem); | |
807 } | |
4231
91a883c56382
(Fget_buffer_process): Delete doc string from
Richard M. Stallman <rms@gnu.org>
parents:
4057
diff
changeset
|
808 |
91a883c56382
(Fget_buffer_process): Delete doc string from
Richard M. Stallman <rms@gnu.org>
parents:
4057
diff
changeset
|
809 #if 0 /* Turned off because we don't currently record this info |
91a883c56382
(Fget_buffer_process): Delete doc string from
Richard M. Stallman <rms@gnu.org>
parents:
4057
diff
changeset
|
810 in the process. Perhaps add it. */ |
91a883c56382
(Fget_buffer_process): Delete doc string from
Richard M. Stallman <rms@gnu.org>
parents:
4057
diff
changeset
|
811 DEFUN ("process-connection", Fprocess_connection, Sprocess_connection, 1, 1, 0, |
91a883c56382
(Fget_buffer_process): Delete doc string from
Richard M. Stallman <rms@gnu.org>
parents:
4057
diff
changeset
|
812 "Return the connection type of `PROCESS'.\n\ |
91a883c56382
(Fget_buffer_process): Delete doc string from
Richard M. Stallman <rms@gnu.org>
parents:
4057
diff
changeset
|
813 The value is `nil' for a pipe,\n\ |
91a883c56382
(Fget_buffer_process): Delete doc string from
Richard M. Stallman <rms@gnu.org>
parents:
4057
diff
changeset
|
814 `t' or `pty' for a pty, or `stream' for a socket connection.") |
91a883c56382
(Fget_buffer_process): Delete doc string from
Richard M. Stallman <rms@gnu.org>
parents:
4057
diff
changeset
|
815 (process) |
91a883c56382
(Fget_buffer_process): Delete doc string from
Richard M. Stallman <rms@gnu.org>
parents:
4057
diff
changeset
|
816 Lisp_Object process; |
91a883c56382
(Fget_buffer_process): Delete doc string from
Richard M. Stallman <rms@gnu.org>
parents:
4057
diff
changeset
|
817 { |
91a883c56382
(Fget_buffer_process): Delete doc string from
Richard M. Stallman <rms@gnu.org>
parents:
4057
diff
changeset
|
818 return XPROCESS (process)->type; |
91a883c56382
(Fget_buffer_process): Delete doc string from
Richard M. Stallman <rms@gnu.org>
parents:
4057
diff
changeset
|
819 } |
91a883c56382
(Fget_buffer_process): Delete doc string from
Richard M. Stallman <rms@gnu.org>
parents:
4057
diff
changeset
|
820 #endif |
578 | 821 |
822 Lisp_Object | |
823 list_processes_1 () | |
824 { | |
825 register Lisp_Object tail, tem; | |
826 Lisp_Object proc, minspace, tem1; | |
827 register struct buffer *old = current_buffer; | |
828 register struct Lisp_Process *p; | |
829 register int state; | |
830 char tembuf[80]; | |
831 | |
832 XFASTINT (minspace) = 1; | |
833 | |
834 set_buffer_internal (XBUFFER (Vstandard_output)); | |
835 Fbuffer_disable_undo (Vstandard_output); | |
836 | |
837 current_buffer->truncate_lines = Qt; | |
838 | |
839 write_string ("\ | |
840 Proc Status Buffer Command\n\ | |
841 ---- ------ ------ -------\n", -1); | |
842 | |
843 for (tail = Vprocess_alist; !NILP (tail); tail = Fcdr (tail)) | |
844 { | |
845 Lisp_Object symbol; | |
846 | |
847 proc = Fcdr (Fcar (tail)); | |
848 p = XPROCESS (proc); | |
849 if (NILP (p->childp)) | |
850 continue; | |
851 | |
852 Finsert (1, &p->name); | |
853 Findent_to (make_number (13), minspace); | |
854 | |
855 if (!NILP (p->raw_status_low)) | |
856 update_status (p); | |
857 symbol = p->status; | |
858 if (XTYPE (p->status) == Lisp_Cons) | |
859 symbol = XCONS (p->status)->car; | |
860 | |
861 | |
862 if (EQ (symbol, Qsignal)) | |
863 { | |
864 Lisp_Object tem; | |
865 tem = Fcar (Fcdr (p->status)); | |
866 #ifdef VMS | |
867 if (XINT (tem) < NSIG) | |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
868 write_string (sys_errlist [XINT (tem)], -1); |
578 | 869 else |
870 #endif | |
871 Fprinc (symbol, Qnil); | |
872 } | |
873 else if (NETCONN_P (proc)) | |
874 { | |
875 if (EQ (symbol, Qrun)) | |
876 write_string ("open", -1); | |
877 else if (EQ (symbol, Qexit)) | |
878 write_string ("closed", -1); | |
879 else | |
880 Fprinc (symbol, Qnil); | |
881 } | |
882 else | |
883 Fprinc (symbol, Qnil); | |
884 | |
885 if (EQ (symbol, Qexit)) | |
886 { | |
887 Lisp_Object tem; | |
888 tem = Fcar (Fcdr (p->status)); | |
889 if (XFASTINT (tem)) | |
890 { | |
891 sprintf (tembuf, " %d", XFASTINT (tem)); | |
892 write_string (tembuf, -1); | |
893 } | |
894 } | |
895 | |
896 if (EQ (symbol, Qsignal) || EQ (symbol, Qexit)) | |
897 remove_process (proc); | |
898 | |
899 Findent_to (make_number (22), minspace); | |
900 if (NILP (p->buffer)) | |
901 insert_string ("(none)"); | |
902 else if (NILP (XBUFFER (p->buffer)->name)) | |
903 insert_string ("(Killed)"); | |
904 else | |
905 Finsert (1, &XBUFFER (p->buffer)->name); | |
906 | |
907 Findent_to (make_number (37), minspace); | |
908 | |
909 if (NETCONN_P (proc)) | |
910 { | |
911 sprintf (tembuf, "(network stream connection to %s)\n", | |
912 XSTRING (p->childp)->data); | |
913 insert_string (tembuf); | |
914 } | |
915 else | |
916 { | |
917 tem = p->command; | |
918 while (1) | |
919 { | |
920 tem1 = Fcar (tem); | |
921 Finsert (1, &tem1); | |
922 tem = Fcdr (tem); | |
923 if (NILP (tem)) | |
924 break; | |
925 insert_string (" "); | |
926 } | |
927 insert_string ("\n"); | |
928 } | |
929 } | |
930 return Qnil; | |
931 } | |
932 | |
933 DEFUN ("list-processes", Flist_processes, Slist_processes, 0, 0, "", | |
934 "Display a list of all processes.\n\ | |
935 \(Any processes listed as Exited or Signaled are actually eliminated\n\ | |
936 after the listing is made.)") | |
937 () | |
938 { | |
939 internal_with_output_to_temp_buffer ("*Process List*", | |
940 list_processes_1, Qnil); | |
941 return Qnil; | |
942 } | |
943 | |
944 DEFUN ("process-list", Fprocess_list, Sprocess_list, 0, 0, 0, | |
945 "Return a list of all processes.") | |
946 () | |
947 { | |
948 return Fmapcar (Qcdr, Vprocess_alist); | |
949 } | |
950 | |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
951 /* Starting asynchronous inferior processes. */ |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
952 |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
953 static Lisp_Object start_process_unwind (); |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
954 |
578 | 955 DEFUN ("start-process", Fstart_process, Sstart_process, 3, MANY, 0, |
956 "Start a program in a subprocess. Return the process object for it.\n\ | |
957 Args are NAME BUFFER PROGRAM &rest PROGRAM-ARGS\n\ | |
958 NAME is name for process. It is modified if necessary to make it unique.\n\ | |
959 BUFFER is the buffer or (buffer-name) to associate with the process.\n\ | |
960 Process output goes at end of that buffer, unless you specify\n\ | |
961 an output stream or filter function to handle the output.\n\ | |
962 BUFFER may be also nil, meaning that this process is not associated\n\ | |
963 with any buffer\n\ | |
964 Third arg is program file name. It is searched for as in the shell.\n\ | |
965 Remaining arguments are strings to give program as arguments.") | |
966 (nargs, args) | |
967 int nargs; | |
968 register Lisp_Object *args; | |
969 { | |
1683
a0a41de51400
Give subprocess creation a way to find a valid current directory
Jim Blandy <jimb@redhat.com>
parents:
1655
diff
changeset
|
970 Lisp_Object buffer, name, program, proc, current_dir, tem; |
578 | 971 #ifdef VMS |
972 register unsigned char *new_argv; | |
973 int len; | |
974 #else | |
975 register unsigned char **new_argv; | |
976 #endif | |
977 register int i; | |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
978 int count = specpdl_ptr - specpdl; |
578 | 979 |
980 buffer = args[1]; | |
981 if (!NILP (buffer)) | |
982 buffer = Fget_buffer_create (buffer); | |
983 | |
1683
a0a41de51400
Give subprocess creation a way to find a valid current directory
Jim Blandy <jimb@redhat.com>
parents:
1655
diff
changeset
|
984 /* Make sure that the child will be able to chdir to the current |
a0a41de51400
Give subprocess creation a way to find a valid current directory
Jim Blandy <jimb@redhat.com>
parents:
1655
diff
changeset
|
985 buffer's current directory, or its unhandled equivalent. We |
a0a41de51400
Give subprocess creation a way to find a valid current directory
Jim Blandy <jimb@redhat.com>
parents:
1655
diff
changeset
|
986 can't just have the child check for an error when it does the |
a0a41de51400
Give subprocess creation a way to find a valid current directory
Jim Blandy <jimb@redhat.com>
parents:
1655
diff
changeset
|
987 chdir, since it's in a vfork. |
a0a41de51400
Give subprocess creation a way to find a valid current directory
Jim Blandy <jimb@redhat.com>
parents:
1655
diff
changeset
|
988 |
a0a41de51400
Give subprocess creation a way to find a valid current directory
Jim Blandy <jimb@redhat.com>
parents:
1655
diff
changeset
|
989 We have to GCPRO around this because Fexpand_file_name and |
a0a41de51400
Give subprocess creation a way to find a valid current directory
Jim Blandy <jimb@redhat.com>
parents:
1655
diff
changeset
|
990 Funhandled_file_name_directory might call a file name handling |
a0a41de51400
Give subprocess creation a way to find a valid current directory
Jim Blandy <jimb@redhat.com>
parents:
1655
diff
changeset
|
991 function. The argument list is protected by the caller, so all |
a0a41de51400
Give subprocess creation a way to find a valid current directory
Jim Blandy <jimb@redhat.com>
parents:
1655
diff
changeset
|
992 we really have to worry about is buffer. */ |
a0a41de51400
Give subprocess creation a way to find a valid current directory
Jim Blandy <jimb@redhat.com>
parents:
1655
diff
changeset
|
993 { |
a0a41de51400
Give subprocess creation a way to find a valid current directory
Jim Blandy <jimb@redhat.com>
parents:
1655
diff
changeset
|
994 struct gcpro gcpro1, gcpro2; |
a0a41de51400
Give subprocess creation a way to find a valid current directory
Jim Blandy <jimb@redhat.com>
parents:
1655
diff
changeset
|
995 |
a0a41de51400
Give subprocess creation a way to find a valid current directory
Jim Blandy <jimb@redhat.com>
parents:
1655
diff
changeset
|
996 current_dir = current_buffer->directory; |
a0a41de51400
Give subprocess creation a way to find a valid current directory
Jim Blandy <jimb@redhat.com>
parents:
1655
diff
changeset
|
997 |
a0a41de51400
Give subprocess creation a way to find a valid current directory
Jim Blandy <jimb@redhat.com>
parents:
1655
diff
changeset
|
998 GCPRO2 (buffer, current_dir); |
a0a41de51400
Give subprocess creation a way to find a valid current directory
Jim Blandy <jimb@redhat.com>
parents:
1655
diff
changeset
|
999 |
a0a41de51400
Give subprocess creation a way to find a valid current directory
Jim Blandy <jimb@redhat.com>
parents:
1655
diff
changeset
|
1000 current_dir = |
a0a41de51400
Give subprocess creation a way to find a valid current directory
Jim Blandy <jimb@redhat.com>
parents:
1655
diff
changeset
|
1001 expand_and_dir_to_file |
1886
dd2e31cbf205
* process.c (Fstart_process): Jimb's change of December 11
Michael I. Bushnell <mib@gnu.org>
parents:
1780
diff
changeset
|
1002 (Funhandled_file_name_directory (current_dir), Qnil); |
1683
a0a41de51400
Give subprocess creation a way to find a valid current directory
Jim Blandy <jimb@redhat.com>
parents:
1655
diff
changeset
|
1003 if (NILP (Ffile_accessible_directory_p (current_dir))) |
a0a41de51400
Give subprocess creation a way to find a valid current directory
Jim Blandy <jimb@redhat.com>
parents:
1655
diff
changeset
|
1004 report_file_error ("Setting current directory", |
a0a41de51400
Give subprocess creation a way to find a valid current directory
Jim Blandy <jimb@redhat.com>
parents:
1655
diff
changeset
|
1005 Fcons (current_buffer->directory, Qnil)); |
a0a41de51400
Give subprocess creation a way to find a valid current directory
Jim Blandy <jimb@redhat.com>
parents:
1655
diff
changeset
|
1006 |
a0a41de51400
Give subprocess creation a way to find a valid current directory
Jim Blandy <jimb@redhat.com>
parents:
1655
diff
changeset
|
1007 UNGCPRO; |
a0a41de51400
Give subprocess creation a way to find a valid current directory
Jim Blandy <jimb@redhat.com>
parents:
1655
diff
changeset
|
1008 } |
a0a41de51400
Give subprocess creation a way to find a valid current directory
Jim Blandy <jimb@redhat.com>
parents:
1655
diff
changeset
|
1009 |
578 | 1010 name = args[0]; |
1011 CHECK_STRING (name, 0); | |
1012 | |
1013 program = args[2]; | |
1014 | |
1015 CHECK_STRING (program, 2); | |
1016 | |
1017 #ifdef VMS | |
1018 /* Make a one member argv with all args concatenated | |
1019 together separated by a blank. */ | |
1020 len = XSTRING (program)->size + 2; | |
1021 for (i = 3; i < nargs; i++) | |
1022 { | |
1023 tem = args[i]; | |
1024 CHECK_STRING (tem, i); | |
1025 len += XSTRING (tem)->size + 1; /* count the blank */ | |
1026 } | |
1027 new_argv = (unsigned char *) alloca (len); | |
1028 strcpy (new_argv, XSTRING (program)->data); | |
1029 for (i = 3; i < nargs; i++) | |
1030 { | |
1031 tem = args[i]; | |
1032 CHECK_STRING (tem, i); | |
1033 strcat (new_argv, " "); | |
1034 strcat (new_argv, XSTRING (tem)->data); | |
1035 } | |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1036 /* Need to add code here to check for program existence on VMS */ |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1037 |
578 | 1038 #else /* not VMS */ |
1039 new_argv = (unsigned char **) alloca ((nargs - 1) * sizeof (char *)); | |
1040 | |
1041 for (i = 3; i < nargs; i++) | |
1042 { | |
1043 tem = args[i]; | |
1044 CHECK_STRING (tem, i); | |
1045 new_argv[i - 2] = XSTRING (tem)->data; | |
1046 } | |
1047 new_argv[i - 2] = 0; | |
1048 new_argv[0] = XSTRING (program)->data; | |
1049 | |
1050 /* If program file name is not absolute, search our path for it */ | |
1051 if (new_argv[0][0] != '/') | |
1052 { | |
1053 tem = Qnil; | |
2432
17a84e60603b
New macros NULL_DEVICE and EXEC_SUFFIXES, to give the name of the
Jim Blandy <jimb@redhat.com>
parents:
2429
diff
changeset
|
1054 openp (Vexec_path, program, EXEC_SUFFIXES, &tem, 1); |
578 | 1055 if (NILP (tem)) |
1056 report_file_error ("Searching for program", Fcons (program, Qnil)); | |
1057 new_argv[0] = XSTRING (tem)->data; | |
1058 } | |
1059 #endif /* not VMS */ | |
1060 | |
1061 proc = make_process (name); | |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1062 /* If an error occurs and we can't start the process, we want to |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1063 remove it from the process list. This means that each error |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1064 check in create_process doesn't need to call remove_process |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1065 itself; it's all taken care of here. */ |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1066 record_unwind_protect (start_process_unwind, proc); |
578 | 1067 |
1068 XPROCESS (proc)->childp = Qt; | |
1069 XPROCESS (proc)->command_channel_p = Qnil; | |
1070 XPROCESS (proc)->buffer = buffer; | |
1071 XPROCESS (proc)->sentinel = Qnil; | |
1072 XPROCESS (proc)->filter = Qnil; | |
1073 XPROCESS (proc)->command = Flist (nargs - 2, args + 2); | |
1074 | |
1683
a0a41de51400
Give subprocess creation a way to find a valid current directory
Jim Blandy <jimb@redhat.com>
parents:
1655
diff
changeset
|
1075 create_process (proc, new_argv, current_dir); |
578 | 1076 |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1077 return unbind_to (count, proc); |
578 | 1078 } |
1079 | |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1080 /* This function is the unwind_protect form for Fstart_process. If |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1081 PROC doesn't have its pid set, then we know someone has signalled |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1082 an error and the process wasn't started successfully, so we should |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1083 remove it from the process list. */ |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1084 static Lisp_Object |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1085 start_process_unwind (proc) |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1086 Lisp_Object proc; |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1087 { |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1088 if (XTYPE (proc) != Lisp_Process) |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1089 abort (); |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1090 |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1091 /* Was PROC started successfully? */ |
3685
47d7fda8a609
(start_process_unwind): Use XINT.
Richard M. Stallman <rms@gnu.org>
parents:
3666
diff
changeset
|
1092 if (XINT (XPROCESS (proc)->pid) <= 0) |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1093 remove_process (proc); |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1094 |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1095 return Qnil; |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1096 } |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1097 |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1098 |
578 | 1099 SIGTYPE |
1100 create_process_1 (signo) | |
1101 int signo; | |
1102 { | |
1103 #ifdef USG | |
1104 /* USG systems forget handlers when they are used; | |
1105 must reestablish each time */ | |
1106 signal (signo, create_process_1); | |
1107 #endif /* USG */ | |
1108 } | |
1109 | |
1110 #if 0 /* This doesn't work; see the note before sigchld_handler. */ | |
1111 #ifdef USG | |
1112 #ifdef SIGCHLD | |
1113 /* Mimic blocking of signals on system V, which doesn't really have it. */ | |
1114 | |
1115 /* Nonzero means we got a SIGCHLD when it was supposed to be blocked. */ | |
1116 int sigchld_deferred; | |
1117 | |
1118 SIGTYPE | |
1119 create_process_sigchld () | |
1120 { | |
1121 signal (SIGCHLD, create_process_sigchld); | |
1122 | |
1123 sigchld_deferred = 1; | |
1124 } | |
1125 #endif | |
1126 #endif | |
1127 #endif | |
1128 | |
1129 #ifndef VMS /* VMS version of this function is in vmsproc.c. */ | |
1683
a0a41de51400
Give subprocess creation a way to find a valid current directory
Jim Blandy <jimb@redhat.com>
parents:
1655
diff
changeset
|
1130 create_process (process, new_argv, current_dir) |
578 | 1131 Lisp_Object process; |
1132 char **new_argv; | |
1683
a0a41de51400
Give subprocess creation a way to find a valid current directory
Jim Blandy <jimb@redhat.com>
parents:
1655
diff
changeset
|
1133 Lisp_Object current_dir; |
578 | 1134 { |
1135 int pid, inchannel, outchannel, forkin, forkout; | |
1136 int sv[2]; | |
1137 #ifdef SIGCHLD | |
1138 SIGTYPE (*sigchld)(); | |
1139 #endif | |
1140 int pty_flag = 0; | |
1141 extern char **environ; | |
1142 | |
1143 inchannel = outchannel = -1; | |
1144 | |
1145 #ifdef HAVE_PTYS | |
1146 if (EQ (Vprocess_connection_type, Qt)) | |
1147 outchannel = inchannel = allocate_pty (); | |
1148 | |
1149 if (inchannel >= 0) | |
1150 { | |
1151 #ifndef USG | |
1152 /* On USG systems it does not work to open the pty's tty here | |
1153 and then close and reopen it in the child. */ | |
1154 #ifdef O_NOCTTY | |
1155 /* Don't let this terminal become our controlling terminal | |
1156 (in case we don't have one). */ | |
1157 forkout = forkin = open (pty_name, O_RDWR | O_NOCTTY, 0); | |
1158 #else | |
1159 forkout = forkin = open (pty_name, O_RDWR, 0); | |
1160 #endif | |
1161 if (forkin < 0) | |
1162 report_file_error ("Opening pty", Qnil); | |
1163 #else | |
1164 forkin = forkout = -1; | |
1165 #endif /* not USG */ | |
1166 pty_flag = 1; | |
1167 } | |
1168 else | |
1169 #endif /* HAVE_PTYS */ | |
1170 #ifdef SKTPAIR | |
1171 { | |
1172 if (socketpair (AF_UNIX, SOCK_STREAM, 0, sv) < 0) | |
1173 report_file_error ("Opening socketpair", Qnil); | |
1174 outchannel = inchannel = sv[0]; | |
1175 forkout = forkin = sv[1]; | |
1176 } | |
1177 #else /* not SKTPAIR */ | |
1178 { | |
1179 pipe (sv); | |
1180 inchannel = sv[0]; | |
1181 forkout = sv[1]; | |
1182 pipe (sv); | |
1183 outchannel = sv[1]; | |
1184 forkin = sv[0]; | |
1185 } | |
1186 #endif /* not SKTPAIR */ | |
1187 | |
1188 #if 0 | |
1189 /* Replaced by close_process_descs */ | |
1190 set_exclusive_use (inchannel); | |
1191 set_exclusive_use (outchannel); | |
1192 #endif | |
1193 | |
1194 /* Stride people say it's a mystery why this is needed | |
1195 as well as the O_NDELAY, but that it fails without this. */ | |
1196 #if defined (STRIDE) || (defined (pfa) && defined (HAVE_PTYS)) | |
1197 { | |
1198 int one = 1; | |
1199 ioctl (inchannel, FIONBIO, &one); | |
1200 } | |
1201 #endif | |
1202 | |
1203 #ifdef O_NONBLOCK | |
1204 fcntl (inchannel, F_SETFL, O_NONBLOCK); | |
1205 #else | |
1206 #ifdef O_NDELAY | |
1207 fcntl (inchannel, F_SETFL, O_NDELAY); | |
1208 #endif | |
1209 #endif | |
1210 | |
1211 /* Record this as an active process, with its channels. | |
1212 As a result, child_setup will close Emacs's side of the pipes. */ | |
1213 chan_process[inchannel] = process; | |
1214 XFASTINT (XPROCESS (process)->infd) = inchannel; | |
1215 XFASTINT (XPROCESS (process)->outfd) = outchannel; | |
1216 /* Record the tty descriptor used in the subprocess. */ | |
1217 if (forkin < 0) | |
1218 XPROCESS (process)->subtty = Qnil; | |
1219 else | |
1220 XFASTINT (XPROCESS (process)->subtty) = forkin; | |
1221 XPROCESS (process)->pty_flag = (pty_flag ? Qt : Qnil); | |
1222 XPROCESS (process)->status = Qrun; | |
1223 | |
1224 /* Delay interrupts until we have a chance to store | |
1225 the new fork's pid in its process structure */ | |
1226 #ifdef SIGCHLD | |
1227 #ifdef BSD4_1 | |
1228 sighold (SIGCHLD); | |
1229 #else /* not BSD4_1 */ | |
1230 #if defined (BSD) || defined (UNIPLUS) || defined (HPUX) | |
1231 sigsetmask (sigmask (SIGCHLD)); | |
1232 #else /* ordinary USG */ | |
1233 #if 0 | |
1234 sigchld_deferred = 0; | |
1235 sigchld = signal (SIGCHLD, create_process_sigchld); | |
1236 #endif | |
1237 #endif /* ordinary USG */ | |
1238 #endif /* not BSD4_1 */ | |
1239 #endif /* SIGCHLD */ | |
1240 | |
1241 /* Until we store the proper pid, enable sigchld_handler | |
1242 to recognize an unknown pid as standing for this process. | |
1243 It is very important not to let this `marker' value stay | |
1244 in the table after this function has returned; if it does | |
1245 it might cause call-process to hang and subsequent asynchronous | |
1246 processes to get their return values scrambled. */ | |
1247 XSETINT (XPROCESS (process)->pid, -1); | |
1248 | |
1249 { | |
1250 /* child_setup must clobber environ on systems with true vfork. | |
1251 Protect it from permanent change. */ | |
1252 char **save_environ = environ; | |
1253 | |
1254 pid = vfork (); | |
1255 if (pid == 0) | |
1256 { | |
1257 int xforkin = forkin; | |
1258 int xforkout = forkout; | |
1259 | |
1260 #if 0 /* This was probably a mistake--it duplicates code later on, | |
1261 but fails to handle all the cases. */ | |
1262 /* Make sure SIGCHLD is not blocked in the child. */ | |
1263 sigsetmask (SIGEMPTYMASK); | |
1264 #endif | |
1265 | |
1266 /* Make the pty be the controlling terminal of the process. */ | |
1267 #ifdef HAVE_PTYS | |
1268 /* First, disconnect its current controlling terminal. */ | |
1269 #ifdef HAVE_SETSID | |
1270 setsid (); | |
1030
9934251d8219
(WCOREDUMP): Define only if not defined.
Richard M. Stallman <rms@gnu.org>
parents:
1012
diff
changeset
|
1271 #ifdef TIOCSCTTY |
9934251d8219
(WCOREDUMP): Define only if not defined.
Richard M. Stallman <rms@gnu.org>
parents:
1012
diff
changeset
|
1272 /* Make the pty's terminal the controlling terminal. */ |
3023
cfd999700613
(create_process): Ignore retval from TIOCSTTY.
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
1273 if (pty_flag) |
cfd999700613
(create_process): Ignore retval from TIOCSTTY.
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
1274 /* We ignore the return value |
cfd999700613
(create_process): Ignore retval from TIOCSTTY.
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
1275 because faith@cs.unc.edu says that is necessary on Linux. */ |
cfd999700613
(create_process): Ignore retval from TIOCSTTY.
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
1276 ioctl (xforkin, TIOCSCTTY, 0); |
1030
9934251d8219
(WCOREDUMP): Define only if not defined.
Richard M. Stallman <rms@gnu.org>
parents:
1012
diff
changeset
|
1277 #endif |
578 | 1278 #else /* not HAVE_SETSID */ |
3810
87d9ef5f831b
* callproc.c (Fcall_process, child_setup): If IRIX is #defined,
Jim Blandy <jimb@redhat.com>
parents:
3685
diff
changeset
|
1279 #if defined (USG) && !defined (IRIX) |
578 | 1280 /* It's very important to call setpgrp() here and no time |
1281 afterwards. Otherwise, we lose our controlling tty which | |
1282 is set when we open the pty. */ | |
1283 setpgrp (); | |
1284 #endif /* USG */ | |
1285 #endif /* not HAVE_SETSID */ | |
1286 #ifdef TIOCNOTTY | |
1287 /* In 4.3BSD, the TIOCSPGRP bug has been fixed, and now you | |
1288 can do TIOCSPGRP only to the process's controlling tty. */ | |
1289 if (pty_flag) | |
1290 { | |
1291 /* I wonder: would just ioctl (0, TIOCNOTTY, 0) work here? | |
1292 I can't test it since I don't have 4.3. */ | |
1293 int j = open ("/dev/tty", O_RDWR, 0); | |
1294 ioctl (j, TIOCNOTTY, 0); | |
1295 close (j); | |
3826
647bef18618f
Changes for Irix 4.0, tested this time:
Jim Blandy <jimb@redhat.com>
parents:
3810
diff
changeset
|
1296 #ifndef USG |
578 | 1297 /* In order to get a controlling terminal on some versions |
1298 of BSD, it is necessary to put the process in pgrp 0 | |
1299 before it opens the terminal. */ | |
1300 setpgrp (0, 0); | |
1301 #endif | |
1302 } | |
1303 #endif /* TIOCNOTTY */ | |
1304 | |
1305 #if !defined (RTU) && !defined (UNIPLUS) | |
1306 /*** There is a suggestion that this ought to be a | |
1307 conditional on TIOCSPGRP. */ | |
1308 /* Now close the pty (if we had it open) and reopen it. | |
1309 This makes the pty the controlling terminal of the subprocess. */ | |
1310 if (pty_flag) | |
1311 { | |
1312 /* I wonder if close (open (pty_name, ...)) would work? */ | |
1313 if (xforkin >= 0) | |
1314 close (xforkin); | |
1315 xforkout = xforkin = open (pty_name, O_RDWR, 0); | |
1316 | |
1317 if (xforkin < 0) | |
1318 abort (); | |
1319 } | |
1320 #endif /* not UNIPLUS and not RTU */ | |
1321 #ifdef SETUP_SLAVE_PTY | |
1322 SETUP_SLAVE_PTY; | |
1323 #endif /* SETUP_SLAVE_PTY */ | |
1324 #ifdef AIX | |
1325 /* On AIX, we've disabled SIGHUP above once we start a child on a pty. | |
1326 Now reenable it in the child, so it will die when we want it to. */ | |
1327 if (pty_flag) | |
1328 signal (SIGHUP, SIG_DFL); | |
1329 #endif | |
1330 #endif /* HAVE_PTYS */ | |
1331 | |
1332 #ifdef SIGCHLD | |
1333 #ifdef BSD4_1 | |
1334 sigrelse (SIGCHLD); | |
1335 #else /* not BSD4_1 */ | |
1336 #if defined (BSD) || defined (UNIPLUS) || defined (HPUX) | |
1337 sigsetmask (SIGEMPTYMASK); | |
1338 #else /* ordinary USG */ | |
1207
af619d68a576
* process.c [SIGCHLD && !BSD && !UNIPLUS && !HPUX]
Jim Blandy <jimb@redhat.com>
parents:
1180
diff
changeset
|
1339 #if 0 |
578 | 1340 signal (SIGCHLD, sigchld); |
1207
af619d68a576
* process.c [SIGCHLD && !BSD && !UNIPLUS && !HPUX]
Jim Blandy <jimb@redhat.com>
parents:
1180
diff
changeset
|
1341 #endif |
578 | 1342 #endif /* ordinary USG */ |
1343 #endif /* not BSD4_1 */ | |
1344 #endif /* SIGCHLD */ | |
1345 | |
1346 child_setup_tty (xforkout); | |
1347 child_setup (xforkin, xforkout, xforkout, | |
638 | 1348 new_argv, 1, current_dir); |
578 | 1349 } |
1350 environ = save_environ; | |
1351 } | |
1352 | |
1353 if (pid < 0) | |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1354 report_file_error ("Doing vfork", Qnil); |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1355 |
578 | 1356 XFASTINT (XPROCESS (process)->pid) = pid; |
1357 | |
1358 FD_SET (inchannel, &input_wait_mask); | |
1359 | |
1360 /* If the subfork execv fails, and it exits, | |
1361 this close hangs. I don't know why. | |
1362 So have an interrupt jar it loose. */ | |
1363 stop_polling (); | |
1364 signal (SIGALRM, create_process_1); | |
1365 alarm (1); | |
1366 #ifdef SYSV4_PTYS | |
1367 /* OK to close only if it's not a pty. Otherwise we need to leave | |
1368 it open for ioctl to get pgrp when signals are sent, or to send | |
1369 the interrupt characters through if that's how we're signalling | |
1370 subprocesses. Alternately if you are concerned about running out | |
1371 of file descriptors, you could just save the tty name and open | |
1372 just to do the ioctl. */ | |
1373 if (NILP (XFASTINT (XPROCESS (process)->pty_flag))) | |
1374 #endif | |
1375 { | |
1376 XPROCESS (process)->subtty = Qnil; | |
1377 if (forkin >= 0) | |
1378 close (forkin); | |
1379 } | |
1380 alarm (0); | |
1381 start_polling (); | |
1382 if (forkin != forkout && forkout >= 0) | |
1383 close (forkout); | |
1384 | |
1385 #ifdef SIGCHLD | |
1386 #ifdef BSD4_1 | |
1387 sigrelse (SIGCHLD); | |
1388 #else /* not BSD4_1 */ | |
1389 #if defined (BSD) || defined (UNIPLUS) || defined (HPUX) | |
1390 sigsetmask (SIGEMPTYMASK); | |
1391 #else /* ordinary USG */ | |
1392 #if 0 | |
1393 signal (SIGCHLD, sigchld); | |
1394 /* Now really handle any of these signals | |
1395 that came in during this function. */ | |
1396 if (sigchld_deferred) | |
1397 kill (getpid (), SIGCHLD); | |
1398 #endif | |
1399 #endif /* ordinary USG */ | |
1400 #endif /* not BSD4_1 */ | |
1401 #endif /* SIGCHLD */ | |
1402 } | |
1403 #endif /* not VMS */ | |
1404 | |
1405 #ifdef HAVE_SOCKETS | |
1406 | |
1407 /* open a TCP network connection to a given HOST/SERVICE. Treated | |
1408 exactly like a normal process when reading and writing. Only | |
1409 differences are in status display and process deletion. A network | |
1410 connection has no PID; you cannot signal it. All you can do is | |
1411 deactivate and close it via delete-process */ | |
1412 | |
1413 DEFUN ("open-network-stream", Fopen_network_stream, Sopen_network_stream, | |
1414 4, 4, 0, | |
1415 "Open a TCP connection for a service to a host.\n\ | |
1416 Returns a subprocess-object to represent the connection.\n\ | |
1417 Input and output work as for subprocesses; `delete-process' closes it.\n\ | |
1418 Args are NAME BUFFER HOST SERVICE.\n\ | |
1419 NAME is name for process. It is modified if necessary to make it unique.\n\ | |
1420 BUFFER is the buffer (or buffer-name) to associate with the process.\n\ | |
1421 Process output goes at end of that buffer, unless you specify\n\ | |
1422 an output stream or filter function to handle the output.\n\ | |
1423 BUFFER may be also nil, meaning that this process is not associated\n\ | |
1424 with any buffer\n\ | |
1425 Third arg is name of the host to connect to, or its IP address.\n\ | |
1426 Fourth arg SERVICE is name of the service desired, or an integer\n\ | |
1427 specifying a port number to connect to.") | |
1428 (name, buffer, host, service) | |
1429 Lisp_Object name, buffer, host, service; | |
1430 { | |
1431 Lisp_Object proc; | |
1432 register int i; | |
1433 struct sockaddr_in address; | |
1434 struct servent *svc_info; | |
1435 struct hostent *host_info_ptr, host_info; | |
1436 char *(addr_list[2]); | |
1437 unsigned long numeric_addr; | |
1438 int s, outch, inch; | |
1439 char errstring[80]; | |
1440 int port; | |
1441 struct hostent host_info_fixed; | |
1442 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4; | |
1443 | |
1444 GCPRO4 (name, buffer, host, service); | |
1445 CHECK_STRING (name, 0); | |
1446 CHECK_STRING (host, 0); | |
1447 if (XTYPE(service) == Lisp_Int) | |
1448 port = htons ((unsigned short) XINT (service)); | |
1449 else | |
1450 { | |
1451 CHECK_STRING (service, 0); | |
1452 svc_info = getservbyname (XSTRING (service)->data, "tcp"); | |
1453 if (svc_info == 0) | |
1454 error ("Unknown service \"%s\"", XSTRING (service)->data); | |
1455 port = svc_info->s_port; | |
1456 } | |
1457 | |
1458 host_info_ptr = gethostbyname (XSTRING (host)->data); | |
1459 if (host_info_ptr == 0) | |
1460 /* Attempt to interpret host as numeric inet address */ | |
1461 { | |
1462 numeric_addr = inet_addr (XSTRING (host)->data); | |
1463 if (numeric_addr == -1) | |
1464 error ("Unknown host \"%s\"", XSTRING (host)->data); | |
1465 | |
1466 host_info_ptr = &host_info; | |
1467 host_info.h_name = 0; | |
1468 host_info.h_aliases = 0; | |
1469 host_info.h_addrtype = AF_INET; | |
2944
f66a150d3fb9
* process.c (Fopen_network_stream): Deal with older systems, which
Jim Blandy <jimb@redhat.com>
parents:
2917
diff
changeset
|
1470 #ifdef h_addr |
f66a150d3fb9
* process.c (Fopen_network_stream): Deal with older systems, which
Jim Blandy <jimb@redhat.com>
parents:
2917
diff
changeset
|
1471 /* Older machines have only one address slot called h_addr. |
f66a150d3fb9
* process.c (Fopen_network_stream): Deal with older systems, which
Jim Blandy <jimb@redhat.com>
parents:
2917
diff
changeset
|
1472 Newer machines have h_addr_list, but #define h_addr to |
f66a150d3fb9
* process.c (Fopen_network_stream): Deal with older systems, which
Jim Blandy <jimb@redhat.com>
parents:
2917
diff
changeset
|
1473 be its first element. */ |
f66a150d3fb9
* process.c (Fopen_network_stream): Deal with older systems, which
Jim Blandy <jimb@redhat.com>
parents:
2917
diff
changeset
|
1474 host_info.h_addr_list = &(addr_list[0]); |
f66a150d3fb9
* process.c (Fopen_network_stream): Deal with older systems, which
Jim Blandy <jimb@redhat.com>
parents:
2917
diff
changeset
|
1475 #endif |
f66a150d3fb9
* process.c (Fopen_network_stream): Deal with older systems, which
Jim Blandy <jimb@redhat.com>
parents:
2917
diff
changeset
|
1476 host_info.h_addr = (char*)(&numeric_addr); |
578 | 1477 addr_list[1] = 0; |
1478 host_info.h_length = strlen (addr_list[0]); | |
1479 } | |
1480 | |
1481 bzero (&address, sizeof address); | |
1482 bcopy (host_info_ptr->h_addr, (char *) &address.sin_addr, | |
1483 host_info_ptr->h_length); | |
1484 address.sin_family = host_info_ptr->h_addrtype; | |
1485 address.sin_port = port; | |
1486 | |
1487 s = socket (host_info_ptr->h_addrtype, SOCK_STREAM, 0); | |
1488 if (s < 0) | |
1489 report_file_error ("error creating socket", Fcons (name, Qnil)); | |
1490 | |
1491 loop: | |
3593
e425c3048283
* process.c (sigchld_handler): Add cast, to avoid warnings on Linux.
Jim Blandy <jimb@redhat.com>
parents:
3592
diff
changeset
|
1492 if (connect (s, (struct sockaddr *) &address, sizeof address) == -1) |
578 | 1493 { |
1494 int xerrno = errno; | |
1495 if (errno == EINTR) | |
1496 goto loop; | |
1497 close (s); | |
1498 errno = xerrno; | |
1499 report_file_error ("connection failed", | |
1500 Fcons (host, Fcons (name, Qnil))); | |
1501 } | |
1502 | |
1503 inch = s; | |
1504 outch = dup (s); | |
1505 if (outch < 0) | |
1506 report_file_error ("error duplicating socket", Fcons (name, Qnil)); | |
1507 | |
1508 if (!NILP (buffer)) | |
1509 buffer = Fget_buffer_create (buffer); | |
1510 proc = make_process (name); | |
1511 | |
1512 chan_process[inch] = proc; | |
1513 | |
1514 #ifdef O_NONBLOCK | |
1515 fcntl (inch, F_SETFL, O_NONBLOCK); | |
1516 #else | |
1517 #ifdef O_NDELAY | |
1518 fcntl (inch, F_SETFL, O_NDELAY); | |
1519 #endif | |
1520 #endif | |
1521 | |
1522 XPROCESS (proc)->childp = host; | |
1523 XPROCESS (proc)->command_channel_p = Qnil; | |
1524 XPROCESS (proc)->buffer = buffer; | |
1525 XPROCESS (proc)->sentinel = Qnil; | |
1526 XPROCESS (proc)->filter = Qnil; | |
1527 XPROCESS (proc)->command = Qnil; | |
1528 XPROCESS (proc)->pid = Qnil; | |
1529 XFASTINT (XPROCESS (proc)->infd) = s; | |
1530 XFASTINT (XPROCESS (proc)->outfd) = outch; | |
1531 XPROCESS (proc)->status = Qrun; | |
1532 FD_SET (inch, &input_wait_mask); | |
1533 | |
1534 UNGCPRO; | |
1535 return proc; | |
1536 } | |
1537 #endif /* HAVE_SOCKETS */ | |
1538 | |
1539 deactivate_process (proc) | |
1540 Lisp_Object proc; | |
1541 { | |
1542 register int inchannel, outchannel; | |
1543 register struct Lisp_Process *p = XPROCESS (proc); | |
1544 | |
1545 inchannel = XFASTINT (p->infd); | |
1546 outchannel = XFASTINT (p->outfd); | |
1547 | |
1548 if (inchannel) | |
1549 { | |
1550 /* Beware SIGCHLD hereabouts. */ | |
1551 flush_pending_output (inchannel); | |
1552 #ifdef VMS | |
1553 { | |
1554 VMS_PROC_STUFF *get_vms_process_pointer (), *vs; | |
1555 sys$dassgn (outchannel); | |
2357
9faa3a02ea97
* process.c [VMS] (DCL_PROMPT): Remove hack.
Jim Blandy <jimb@redhat.com>
parents:
2290
diff
changeset
|
1556 vs = get_vms_process_pointer (p->pid); |
578 | 1557 if (vs) |
1558 give_back_vms_process_stuff (vs); | |
1559 } | |
1560 #else | |
1561 close (inchannel); | |
1562 if (outchannel && outchannel != inchannel) | |
1563 close (outchannel); | |
1564 #endif | |
1565 | |
1566 XFASTINT (p->infd) = 0; | |
1567 XFASTINT (p->outfd) = 0; | |
1568 chan_process[inchannel] = Qnil; | |
1569 FD_CLR (inchannel, &input_wait_mask); | |
1570 } | |
1571 } | |
1572 | |
1573 /* Close all descriptors currently in use for communication | |
1574 with subprocess. This is used in a newly-forked subprocess | |
1575 to get rid of irrelevant descriptors. */ | |
1576 | |
1577 close_process_descs () | |
1578 { | |
1579 int i; | |
1580 for (i = 0; i < MAXDESC; i++) | |
1581 { | |
1582 Lisp_Object process; | |
1583 process = chan_process[i]; | |
1584 if (!NILP (process)) | |
1585 { | |
1586 int in = XFASTINT (XPROCESS (process)->infd); | |
1587 int out = XFASTINT (XPROCESS (process)->outfd); | |
1588 if (in) | |
1589 close (in); | |
1590 if (out && in != out) | |
1591 close (out); | |
1592 } | |
1593 } | |
1594 } | |
1595 | |
1596 DEFUN ("accept-process-output", Faccept_process_output, Saccept_process_output, | |
1597 0, 3, 0, | |
1598 "Allow any pending output from subprocesses to be read by Emacs.\n\ | |
1599 It is read into the process' buffers or given to their filter functions.\n\ | |
1600 Non-nil arg PROCESS means do not return until some output has been received\n\ | |
1601 from PROCESS.\n\ | |
1602 Non-nil second arg TIMEOUT and third arg TIMEOUT-MSECS are number of\n\ | |
1603 seconds and microseconds to wait; return after that much time whether\n\ | |
1604 or not there is input.\n\ | |
1605 Return non-nil iff we received any output before the timeout expired.") | |
1606 (proc, timeout, timeout_msecs) | |
1607 register Lisp_Object proc, timeout, timeout_msecs; | |
1608 { | |
1609 int seconds; | |
1610 int useconds; | |
1611 | |
1612 if (! NILP (timeout_msecs)) | |
1613 { | |
1614 CHECK_NUMBER (timeout_msecs, 2); | |
1615 useconds = XINT (timeout_msecs); | |
1616 if (XTYPE (timeout) != Lisp_Int) | |
1617 XSET (timeout, Lisp_Int, 0); | |
1618 | |
1619 { | |
1620 int carry = useconds / 1000000; | |
1621 | |
1622 XSETINT (timeout, XINT (timeout) + carry); | |
1623 useconds -= carry * 1000000; | |
1624 | |
1625 /* I think this clause is necessary because C doesn't | |
1626 guarantee a particular rounding direction for negative | |
1627 integers. */ | |
1628 if (useconds < 0) | |
1629 { | |
1630 XSETINT (timeout, XINT (timeout) - 1); | |
1631 useconds += 1000000; | |
1632 } | |
1633 } | |
1634 } | |
1180
9bf82484415d
(Faccept_process_output): Initialize useconds.
Richard M. Stallman <rms@gnu.org>
parents:
1047
diff
changeset
|
1635 else |
9bf82484415d
(Faccept_process_output): Initialize useconds.
Richard M. Stallman <rms@gnu.org>
parents:
1047
diff
changeset
|
1636 useconds = 0; |
578 | 1637 |
1638 if (! NILP (timeout)) | |
1639 { | |
1640 CHECK_NUMBER (timeout, 1); | |
1641 seconds = XINT (timeout); | |
1642 if (seconds <= 0) | |
1643 seconds = -1; | |
1644 } | |
1645 else | |
1646 { | |
1647 if (NILP (proc)) | |
1648 seconds = -1; | |
1649 else | |
1650 seconds = 0; | |
1651 } | |
1652 | |
650 | 1653 if (NILP (proc)) |
1654 XFASTINT (proc) = 0; | |
1655 | |
578 | 1656 return |
650 | 1657 (wait_reading_process_input (seconds, useconds, proc, 0) |
578 | 1658 ? Qt : Qnil); |
1659 } | |
1660 | |
1661 /* This variable is different from waiting_for_input in keyboard.c. | |
1662 It is used to communicate to a lisp process-filter/sentinel (via the | |
1663 function Fwaiting_for_user_input_p below) whether emacs was waiting | |
1664 for user-input when that process-filter was called. | |
1665 waiting_for_input cannot be used as that is by definition 0 when | |
1666 lisp code is being evalled */ | |
1667 static int waiting_for_user_input_p; | |
1668 | |
1669 /* Read and dispose of subprocess output while waiting for timeout to | |
1670 elapse and/or keyboard input to be available. | |
1671 | |
3953
d0c23febc08c
(wait_reading_process_input): Do include the keyboard
Richard M. Stallman <rms@gnu.org>
parents:
3915
diff
changeset
|
1672 TIME_LIMIT is: |
578 | 1673 timeout in seconds, or |
1674 zero for no limit, or | |
1675 -1 means gobble data immediately available but don't wait for any. | |
1676 | |
3953
d0c23febc08c
(wait_reading_process_input): Do include the keyboard
Richard M. Stallman <rms@gnu.org>
parents:
3915
diff
changeset
|
1677 MICROSECS is: |
d0c23febc08c
(wait_reading_process_input): Do include the keyboard
Richard M. Stallman <rms@gnu.org>
parents:
3915
diff
changeset
|
1678 an additional duration to wait, measured in microseconds. |
d0c23febc08c
(wait_reading_process_input): Do include the keyboard
Richard M. Stallman <rms@gnu.org>
parents:
3915
diff
changeset
|
1679 If this is nonzero and time_limit is 0, then the timeout |
d0c23febc08c
(wait_reading_process_input): Do include the keyboard
Richard M. Stallman <rms@gnu.org>
parents:
3915
diff
changeset
|
1680 consists of MICROSECS only. |
d0c23febc08c
(wait_reading_process_input): Do include the keyboard
Richard M. Stallman <rms@gnu.org>
parents:
3915
diff
changeset
|
1681 |
d0c23febc08c
(wait_reading_process_input): Do include the keyboard
Richard M. Stallman <rms@gnu.org>
parents:
3915
diff
changeset
|
1682 READ_KBD is a lisp value: |
578 | 1683 0 to ignore keyboard input, or |
1684 1 to return when input is available, or | |
2200
5e58643bb169
(wait_reading_process_input): New option to wait
Richard M. Stallman <rms@gnu.org>
parents:
2120
diff
changeset
|
1685 -1 meaning caller will actually read the input, so don't throw to |
578 | 1686 the quit handler, or |
3953
d0c23febc08c
(wait_reading_process_input): Do include the keyboard
Richard M. Stallman <rms@gnu.org>
parents:
3915
diff
changeset
|
1687 a cons cell, meaning wait wait until its car is non-nil |
d0c23febc08c
(wait_reading_process_input): Do include the keyboard
Richard M. Stallman <rms@gnu.org>
parents:
3915
diff
changeset
|
1688 (and gobble terminal input into the buffer if any arrives), or |
650 | 1689 a process object, meaning wait until something arrives from that |
1690 process. The return value is true iff we read some input from | |
1691 that process. | |
578 | 1692 |
3953
d0c23febc08c
(wait_reading_process_input): Do include the keyboard
Richard M. Stallman <rms@gnu.org>
parents:
3915
diff
changeset
|
1693 DO_DISPLAY != 0 means redisplay should be done to show subprocess |
578 | 1694 output that arrives. |
1695 | |
3953
d0c23febc08c
(wait_reading_process_input): Do include the keyboard
Richard M. Stallman <rms@gnu.org>
parents:
3915
diff
changeset
|
1696 If READ_KBD is a pointer to a struct Lisp_Process, then the |
578 | 1697 function returns true iff we received input from that process |
1698 before the timeout elapsed. | |
3591
507f64624555
Apply typo patches from Paul Eggert.
Jim Blandy <jimb@redhat.com>
parents:
3510
diff
changeset
|
1699 Otherwise, return true iff we received input from any process. */ |
578 | 1700 |
1701 wait_reading_process_input (time_limit, microsecs, read_kbd, do_display) | |
650 | 1702 int time_limit, microsecs; |
1703 Lisp_Object read_kbd; | |
1704 int do_display; | |
578 | 1705 { |
1706 register int channel, nfds, m; | |
1707 static SELECT_TYPE Available; | |
1708 int xerrno; | |
1709 Lisp_Object proc; | |
1710 EMACS_TIME timeout, end_time, garbage; | |
1711 SELECT_TYPE Atemp; | |
1712 int wait_channel = 0; | |
1713 struct Lisp_Process *wait_proc = 0; | |
1714 int got_some_input = 0; | |
2200
5e58643bb169
(wait_reading_process_input): New option to wait
Richard M. Stallman <rms@gnu.org>
parents:
2120
diff
changeset
|
1715 Lisp_Object *wait_for_cell = 0; |
578 | 1716 |
1717 FD_ZERO (&Available); | |
1718 | |
650 | 1719 /* If read_kbd is a process to watch, set wait_proc and wait_channel |
1720 accordingly. */ | |
1721 if (XTYPE (read_kbd) == Lisp_Process) | |
578 | 1722 { |
650 | 1723 wait_proc = XPROCESS (read_kbd); |
578 | 1724 wait_channel = XFASTINT (wait_proc->infd); |
650 | 1725 XFASTINT (read_kbd) = 0; |
578 | 1726 } |
1727 | |
2200
5e58643bb169
(wait_reading_process_input): New option to wait
Richard M. Stallman <rms@gnu.org>
parents:
2120
diff
changeset
|
1728 /* If waiting for non-nil in a cell, record where. */ |
5e58643bb169
(wait_reading_process_input): New option to wait
Richard M. Stallman <rms@gnu.org>
parents:
2120
diff
changeset
|
1729 if (XTYPE (read_kbd) == Lisp_Cons) |
5e58643bb169
(wait_reading_process_input): New option to wait
Richard M. Stallman <rms@gnu.org>
parents:
2120
diff
changeset
|
1730 { |
5e58643bb169
(wait_reading_process_input): New option to wait
Richard M. Stallman <rms@gnu.org>
parents:
2120
diff
changeset
|
1731 wait_for_cell = &XCONS (read_kbd)->car; |
5e58643bb169
(wait_reading_process_input): New option to wait
Richard M. Stallman <rms@gnu.org>
parents:
2120
diff
changeset
|
1732 XFASTINT (read_kbd) = 0; |
5e58643bb169
(wait_reading_process_input): New option to wait
Richard M. Stallman <rms@gnu.org>
parents:
2120
diff
changeset
|
1733 } |
5e58643bb169
(wait_reading_process_input): New option to wait
Richard M. Stallman <rms@gnu.org>
parents:
2120
diff
changeset
|
1734 |
650 | 1735 waiting_for_user_input_p = XINT (read_kbd); |
578 | 1736 |
1737 /* Since we may need to wait several times, | |
1738 compute the absolute time to return at. */ | |
1739 if (time_limit || microsecs) | |
1740 { | |
1741 EMACS_GET_TIME (end_time); | |
1742 EMACS_SET_SECS_USECS (timeout, time_limit, microsecs); | |
1743 EMACS_ADD_TIME (end_time, end_time, timeout); | |
1744 } | |
1745 | |
1746 while (1) | |
1747 { | |
1748 /* If calling from keyboard input, do not quit | |
1749 since we want to return C-g as an input character. | |
1750 Otherwise, do pending quit if requested. */ | |
650 | 1751 if (XINT (read_kbd) >= 0) |
578 | 1752 QUIT; |
1753 | |
1754 /* Compute time from now till when time limit is up */ | |
1755 /* Exit if already run out */ | |
1756 if (time_limit == -1) | |
1757 { | |
1758 /* -1 specified for timeout means | |
1759 gobble output available now | |
1760 but don't wait at all. */ | |
1761 | |
1762 EMACS_SET_SECS_USECS (timeout, 0, 0); | |
1763 } | |
1764 else if (time_limit || microsecs) | |
1765 { | |
1766 EMACS_GET_TIME (timeout); | |
1767 EMACS_SUB_TIME (timeout, end_time, timeout); | |
1768 if (EMACS_TIME_NEG_P (timeout)) | |
1769 break; | |
1770 } | |
1771 else | |
1772 { | |
1773 EMACS_SET_SECS_USECS (timeout, 100000, 0); | |
1774 } | |
1775 | |
2894
646c5beae647
* process.c (wait_reading_process_input): Undo change of April
Jim Blandy <jimb@redhat.com>
parents:
2893
diff
changeset
|
1776 /* Cause C-g and alarm signals to take immediate action, |
646c5beae647
* process.c (wait_reading_process_input): Undo change of April
Jim Blandy <jimb@redhat.com>
parents:
2893
diff
changeset
|
1777 and cause input available signals to zero out timeout. |
646c5beae647
* process.c (wait_reading_process_input): Undo change of April
Jim Blandy <jimb@redhat.com>
parents:
2893
diff
changeset
|
1778 |
646c5beae647
* process.c (wait_reading_process_input): Undo change of April
Jim Blandy <jimb@redhat.com>
parents:
2893
diff
changeset
|
1779 It is important that we do this before checking for process |
646c5beae647
* process.c (wait_reading_process_input): Undo change of April
Jim Blandy <jimb@redhat.com>
parents:
2893
diff
changeset
|
1780 activity. If we get a SIGCHLD after the explicit checks for |
646c5beae647
* process.c (wait_reading_process_input): Undo change of April
Jim Blandy <jimb@redhat.com>
parents:
2893
diff
changeset
|
1781 process activity, timeout is the only way we will know. */ |
646c5beae647
* process.c (wait_reading_process_input): Undo change of April
Jim Blandy <jimb@redhat.com>
parents:
2893
diff
changeset
|
1782 if (XINT (read_kbd) < 0) |
646c5beae647
* process.c (wait_reading_process_input): Undo change of April
Jim Blandy <jimb@redhat.com>
parents:
2893
diff
changeset
|
1783 set_waiting_for_input (&timeout); |
646c5beae647
* process.c (wait_reading_process_input): Undo change of April
Jim Blandy <jimb@redhat.com>
parents:
2893
diff
changeset
|
1784 |
1925
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
1785 /* If status of something has changed, and no input is |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
1786 available, notify the user of the change right away. After |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
1787 this explicit check, we'll let the SIGCHLD handler zap |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
1788 timeout to get our attention. */ |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
1789 if (update_tick != process_tick && do_display) |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
1790 { |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
1791 Atemp = input_wait_mask; |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
1792 EMACS_SET_SECS_USECS (timeout, 0, 0); |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
1793 if (select (MAXDESC, &Atemp, 0, 0, &timeout) <= 0) |
2894
646c5beae647
* process.c (wait_reading_process_input): Undo change of April
Jim Blandy <jimb@redhat.com>
parents:
2893
diff
changeset
|
1794 { |
646c5beae647
* process.c (wait_reading_process_input): Undo change of April
Jim Blandy <jimb@redhat.com>
parents:
2893
diff
changeset
|
1795 /* It's okay for us to do this and then continue with |
646c5beae647
* process.c (wait_reading_process_input): Undo change of April
Jim Blandy <jimb@redhat.com>
parents:
2893
diff
changeset
|
1796 the loop, since timeout has already been zeroed out. */ |
646c5beae647
* process.c (wait_reading_process_input): Undo change of April
Jim Blandy <jimb@redhat.com>
parents:
2893
diff
changeset
|
1797 clear_waiting_for_input (); |
646c5beae647
* process.c (wait_reading_process_input): Undo change of April
Jim Blandy <jimb@redhat.com>
parents:
2893
diff
changeset
|
1798 status_notify (); |
646c5beae647
* process.c (wait_reading_process_input): Undo change of April
Jim Blandy <jimb@redhat.com>
parents:
2893
diff
changeset
|
1799 } |
1925
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
1800 } |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
1801 |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
1802 /* Don't wait for output from a non-running process. */ |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
1803 if (wait_proc != 0 && !NILP (wait_proc->raw_status_low)) |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
1804 update_status (wait_proc); |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
1805 if (wait_proc != 0 |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
1806 && ! EQ (wait_proc->status, Qrun)) |
2893
4df57953d5d0
* process.c (wait_reading_process_input): Don't forget to call
Jim Blandy <jimb@redhat.com>
parents:
2887
diff
changeset
|
1807 { |
4df57953d5d0
* process.c (wait_reading_process_input): Don't forget to call
Jim Blandy <jimb@redhat.com>
parents:
2887
diff
changeset
|
1808 clear_waiting_for_input (); |
4df57953d5d0
* process.c (wait_reading_process_input): Don't forget to call
Jim Blandy <jimb@redhat.com>
parents:
2887
diff
changeset
|
1809 break; |
4df57953d5d0
* process.c (wait_reading_process_input): Don't forget to call
Jim Blandy <jimb@redhat.com>
parents:
2887
diff
changeset
|
1810 } |
1925
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
1811 |
578 | 1812 /* Wait till there is something to do */ |
1813 | |
1814 Available = input_wait_mask; | |
4320
4055472194b5
(wait_reading_process_input): Undo last two changes:
Richard M. Stallman <rms@gnu.org>
parents:
4257
diff
changeset
|
1815 /* We used to have && wait_for_cell == 0 |
4055472194b5
(wait_reading_process_input): Undo last two changes:
Richard M. Stallman <rms@gnu.org>
parents:
4257
diff
changeset
|
1816 but that led to lossage handling selection_request events: |
4055472194b5
(wait_reading_process_input): Undo last two changes:
Richard M. Stallman <rms@gnu.org>
parents:
4257
diff
changeset
|
1817 within one, we would start to handle another. */ |
4055472194b5
(wait_reading_process_input): Undo last two changes:
Richard M. Stallman <rms@gnu.org>
parents:
4257
diff
changeset
|
1818 if (! XINT (read_kbd)) |
578 | 1819 FD_CLR (0, &Available); |
1820 | |
765 | 1821 /* If frame size has changed or the window is newly mapped, |
648 | 1822 redisplay now, before we start to wait. There is a race |
1823 condition here; if a SIGIO arrives between now and the select | |
1655
05e84e6c7d04
Tue Dec 1 23:42:25 1992 Jim Blandy (jimb@totoro.cs.oberlin.edu)
Jim Blandy <jimb@redhat.com>
parents:
1594
diff
changeset
|
1824 and indicates that a frame is trashed, the select may block |
05e84e6c7d04
Tue Dec 1 23:42:25 1992 Jim Blandy (jimb@totoro.cs.oberlin.edu)
Jim Blandy <jimb@redhat.com>
parents:
1594
diff
changeset
|
1825 displaying a trashed screen. */ |
765 | 1826 if (frame_garbaged) |
648 | 1827 redisplay_preserve_echo_area (); |
1828 | |
650 | 1829 if (XINT (read_kbd) && detect_input_pending ()) |
578 | 1830 nfds = 0; |
1831 else | |
1832 nfds = select (MAXDESC, &Available, 0, 0, &timeout); | |
588 | 1833 |
578 | 1834 xerrno = errno; |
1835 | |
1836 /* Make C-g and alarm signals set flags again */ | |
1837 clear_waiting_for_input (); | |
1838 | |
1839 /* If we woke up due to SIGWINCH, actually change size now. */ | |
1840 do_pending_window_change (); | |
1841 | |
648 | 1842 if (time_limit && nfds == 0) /* timeout elapsed */ |
578 | 1843 break; |
1844 if (nfds < 0) | |
1845 { | |
1846 if (xerrno == EINTR) | |
1847 FD_ZERO (&Available); | |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1848 #ifdef ultrix |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1849 /* Ultrix select seems to return ENOMEM when it is |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1850 interrupted. Treat it just like EINTR. Bleah. Note |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1851 that we want to test for the "ultrix" CPP symbol, not |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1852 "__ultrix__"; the latter is only defined under GCC, but |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
1853 not by DEC's bundled CC. -JimB */ |
1323
25b5b55a3916
* process.c (wait_reading_process_input): If the select returns
Jim Blandy <jimb@redhat.com>
parents:
1207
diff
changeset
|
1854 else if (xerrno == ENOMEM) |
25b5b55a3916
* process.c (wait_reading_process_input): If the select returns
Jim Blandy <jimb@redhat.com>
parents:
1207
diff
changeset
|
1855 FD_ZERO (&Available); |
25b5b55a3916
* process.c (wait_reading_process_input): If the select returns
Jim Blandy <jimb@redhat.com>
parents:
1207
diff
changeset
|
1856 #endif |
578 | 1857 #ifdef ALLIANT |
1858 /* This happens for no known reason on ALLIANT. | |
1859 I am guessing that this is the right response. -- RMS. */ | |
1860 else if (xerrno == EFAULT) | |
1861 FD_ZERO (&Available); | |
1862 #endif | |
1863 else if (xerrno == EBADF) | |
1864 { | |
1865 #ifdef AIX | |
1866 /* AIX doesn't handle PTY closure the same way BSD does. On AIX, | |
1867 the child's closure of the pts gives the parent a SIGHUP, and | |
1868 the ptc file descriptor is automatically closed, | |
1869 yielding EBADF here or at select() call above. | |
1870 So, SIGHUP is ignored (see def of PTY_TTY_NAME_SPRINTF | |
1871 in m-ibmrt-aix.h), and here we just ignore the select error. | |
1872 Cleanup occurs c/o status_notify after SIGCLD. */ | |
648 | 1873 FD_ZERO (&Available); /* Cannot depend on values returned */ |
578 | 1874 #else |
1875 abort (); | |
1876 #endif | |
1877 } | |
1878 else | |
1879 error("select error: %s", sys_errlist[xerrno]); | |
1880 } | |
2815
60f122cfe785
* process.c (wait_reading_process_input): If we're running
Jim Blandy <jimb@redhat.com>
parents:
2610
diff
changeset
|
1881 #if defined(sun) && !defined(USG5_4) |
578 | 1882 else if (nfds > 0 && FD_ISSET (0, &Available) && interrupt_input) |
2830 | 1883 /* System sometimes fails to deliver SIGIO. |
1884 | |
1885 David J. Mackenzie says that Emacs doesn't compile under | |
1886 Solaris if this code is enabled, thus the USG5_4 in the CPP | |
1887 conditional. "I haven't noticed any ill effects so far. | |
1888 If you find a Solaris expert somewhere, they might know | |
1889 better." */ | |
578 | 1890 kill (getpid (), SIGIO); |
1891 #endif | |
1892 | |
1893 /* Check for keyboard input */ | |
1894 /* If there is any, return immediately | |
1895 to give it higher priority than subprocesses */ | |
1896 | |
4320
4055472194b5
(wait_reading_process_input): Undo last two changes:
Richard M. Stallman <rms@gnu.org>
parents:
4257
diff
changeset
|
1897 /* We used to do his if wait_for_cell, |
4055472194b5
(wait_reading_process_input): Undo last two changes:
Richard M. Stallman <rms@gnu.org>
parents:
4257
diff
changeset
|
1898 but that caused infinite recursion in selection request events. */ |
4055472194b5
(wait_reading_process_input): Undo last two changes:
Richard M. Stallman <rms@gnu.org>
parents:
4257
diff
changeset
|
1899 if ((XINT (read_kbd)) |
4057
2fe1488b503c
(wait_reading_process_input): If wait_for_cell, do call
Richard M. Stallman <rms@gnu.org>
parents:
3953
diff
changeset
|
1900 && detect_input_pending ()) |
3103
98505a819898
(wait_reading_process_input): Call swallow_events.
Richard M. Stallman <rms@gnu.org>
parents:
3023
diff
changeset
|
1901 { |
98505a819898
(wait_reading_process_input): Call swallow_events.
Richard M. Stallman <rms@gnu.org>
parents:
3023
diff
changeset
|
1902 swallow_events (); |
98505a819898
(wait_reading_process_input): Call swallow_events.
Richard M. Stallman <rms@gnu.org>
parents:
3023
diff
changeset
|
1903 if (detect_input_pending ()) |
98505a819898
(wait_reading_process_input): Call swallow_events.
Richard M. Stallman <rms@gnu.org>
parents:
3023
diff
changeset
|
1904 break; |
98505a819898
(wait_reading_process_input): Call swallow_events.
Richard M. Stallman <rms@gnu.org>
parents:
3023
diff
changeset
|
1905 } |
578 | 1906 |
2200
5e58643bb169
(wait_reading_process_input): New option to wait
Richard M. Stallman <rms@gnu.org>
parents:
2120
diff
changeset
|
1907 /* Exit now if the cell we're waiting for became non-nil. */ |
5e58643bb169
(wait_reading_process_input): New option to wait
Richard M. Stallman <rms@gnu.org>
parents:
2120
diff
changeset
|
1908 if (wait_for_cell && ! NILP (*wait_for_cell)) |
5e58643bb169
(wait_reading_process_input): New option to wait
Richard M. Stallman <rms@gnu.org>
parents:
2120
diff
changeset
|
1909 break; |
5e58643bb169
(wait_reading_process_input): New option to wait
Richard M. Stallman <rms@gnu.org>
parents:
2120
diff
changeset
|
1910 |
621 | 1911 #ifdef SIGIO |
578 | 1912 /* If we think we have keyboard input waiting, but didn't get SIGIO |
1913 go read it. This can happen with X on BSD after logging out. | |
1914 In that case, there really is no input and no SIGIO, | |
1915 but select says there is input. */ | |
1916 | |
650 | 1917 if (XINT (read_kbd) && interrupt_input && (FD_ISSET (fileno (stdin), &Available))) |
578 | 1918 kill (0, SIGIO); |
621 | 1919 #endif |
578 | 1920 |
1921 if (! wait_proc) | |
1922 got_some_input |= nfds > 0; | |
1923 | |
624 | 1924 /* If checking input just got us a size-change event from X, |
1925 obey it now if we should. */ | |
4057
2fe1488b503c
(wait_reading_process_input): If wait_for_cell, do call
Richard M. Stallman <rms@gnu.org>
parents:
3953
diff
changeset
|
1926 if (XINT (read_kbd) || wait_for_cell) |
624 | 1927 do_pending_window_change (); |
1928 | |
578 | 1929 /* Check for data from a process or a command channel */ |
1930 for (channel = FIRST_PROC_DESC; channel < MAXDESC; channel++) | |
1931 { | |
1932 if (FD_ISSET (channel, &Available)) | |
1933 { | |
1934 int nread; | |
1935 | |
1936 /* If waiting for this channel, arrange to return as | |
1937 soon as no more input to be processed. No more | |
1938 waiting. */ | |
1939 if (wait_channel == channel) | |
1940 { | |
1941 wait_channel = 0; | |
1942 time_limit = -1; | |
1943 got_some_input = 1; | |
1944 } | |
1945 proc = chan_process[channel]; | |
1946 if (NILP (proc)) | |
1947 continue; | |
1948 | |
1949 /* Read data from the process, starting with our | |
1950 buffered-ahead character if we have one. */ | |
1951 | |
1952 nread = read_process_output (proc, channel); | |
1953 if (nread > 0) | |
1954 { | |
1955 /* Since read_process_output can run a filter, | |
1956 which can call accept-process-output, | |
1957 don't try to read from any other processes | |
1958 before doing the select again. */ | |
1959 FD_ZERO (&Available); | |
1960 | |
1961 if (do_display) | |
1962 redisplay_preserve_echo_area (); | |
1963 } | |
1964 #ifdef EWOULDBLOCK | |
1965 else if (nread == -1 && errno == EWOULDBLOCK) | |
1966 ; | |
1967 #else | |
1968 #ifdef O_NONBLOCK | |
1969 else if (nread == -1 && errno == EAGAIN) | |
1970 ; | |
1971 #else | |
1972 #ifdef O_NDELAY | |
1973 else if (nread == -1 && errno == EAGAIN) | |
1974 ; | |
1975 /* Note that we cannot distinguish between no input | |
1976 available now and a closed pipe. | |
1977 With luck, a closed pipe will be accompanied by | |
1978 subprocess termination and SIGCHLD. */ | |
1979 else if (nread == 0 && !NETCONN_P (proc)) | |
1980 ; | |
648 | 1981 #endif /* O_NDELAY */ |
1982 #endif /* O_NONBLOCK */ | |
1983 #endif /* EWOULDBLOCK */ | |
578 | 1984 #ifdef HAVE_PTYS |
1985 /* On some OSs with ptys, when the process on one end of | |
1986 a pty exits, the other end gets an error reading with | |
1987 errno = EIO instead of getting an EOF (0 bytes read). | |
1988 Therefore, if we get an error reading and errno = | |
1989 EIO, just continue, because the child process has | |
1990 exited and should clean itself up soon (e.g. when we | |
1991 get a SIGCHLD). */ | |
1992 else if (nread == -1 && errno == EIO) | |
1993 ; | |
648 | 1994 #endif /* HAVE_PTYS */ |
1995 /* If we can detect process termination, don't consider the process | |
1996 gone just because its pipe is closed. */ | |
578 | 1997 #ifdef SIGCHLD |
1998 else if (nread == 0 && !NETCONN_P (proc)) | |
1999 ; | |
2000 #endif | |
2001 else | |
2002 { | |
2003 /* Preserve status of processes already terminated. */ | |
2004 XSETINT (XPROCESS (proc)->tick, ++process_tick); | |
2005 deactivate_process (proc); | |
2006 if (!NILP (XPROCESS (proc)->raw_status_low)) | |
2007 update_status (XPROCESS (proc)); | |
2008 if (EQ (XPROCESS (proc)->status, Qrun)) | |
2009 XPROCESS (proc)->status | |
2010 = Fcons (Qexit, Fcons (make_number (256), Qnil)); | |
2011 } | |
2012 } | |
648 | 2013 } /* end for each file descriptor */ |
2014 } /* end while exit conditions not met */ | |
2015 | |
2016 /* If calling from keyboard input, do not quit | |
2017 since we want to return C-g as an input character. | |
2018 Otherwise, do pending quit if requested. */ | |
650 | 2019 if (XINT (read_kbd) >= 0) |
648 | 2020 { |
2021 /* Prevent input_pending from remaining set if we quit. */ | |
2022 clear_input_pending (); | |
2023 QUIT; | |
2024 } | |
578 | 2025 |
2026 return got_some_input; | |
2027 } | |
2028 | |
2029 /* Read pending output from the process channel, | |
2030 starting with our buffered-ahead character if we have one. | |
2031 Yield number of characters read. | |
2032 | |
2033 This function reads at most 1024 characters. | |
2034 If you want to read all available subprocess output, | |
2035 you must call it repeatedly until it returns zero. */ | |
2036 | |
2037 read_process_output (proc, channel) | |
2038 Lisp_Object proc; | |
2039 register int channel; | |
2040 { | |
2041 register int nchars; | |
2042 #ifdef VMS | |
2043 char *chars; | |
2044 #else | |
2045 char chars[1024]; | |
2046 #endif | |
2047 register Lisp_Object outstream; | |
2048 register struct buffer *old = current_buffer; | |
2049 register struct Lisp_Process *p = XPROCESS (proc); | |
2050 register int opoint; | |
2051 | |
2052 #ifdef VMS | |
2053 VMS_PROC_STUFF *vs, *get_vms_process_pointer(); | |
2054 | |
2055 vs = get_vms_process_pointer (p->pid); | |
2056 if (vs) | |
2057 { | |
2058 if (!vs->iosb[0]) | |
2059 return(0); /* Really weird if it does this */ | |
2060 if (!(vs->iosb[0] & 1)) | |
2061 return -1; /* I/O error */ | |
2062 } | |
2063 else | |
2064 error ("Could not get VMS process pointer"); | |
2065 chars = vs->inputBuffer; | |
2066 nchars = clean_vms_buffer (chars, vs->iosb[1]); | |
2067 if (nchars <= 0) | |
2068 { | |
2069 start_vms_process_read (vs); /* Crank up the next read on the process */ | |
2070 return 1; /* Nothing worth printing, say we got 1 */ | |
2071 } | |
2072 #else /* not VMS */ | |
2073 | |
2074 if (proc_buffered_char[channel] < 0) | |
2075 nchars = read (channel, chars, sizeof chars); | |
2076 else | |
2077 { | |
2078 chars[0] = proc_buffered_char[channel]; | |
2079 proc_buffered_char[channel] = -1; | |
2080 nchars = read (channel, chars + 1, sizeof chars - 1); | |
2081 if (nchars < 0) | |
2082 nchars = 1; | |
2083 else | |
2084 nchars = nchars + 1; | |
2085 } | |
2086 #endif /* not VMS */ | |
2087 | |
2088 if (nchars <= 0) return nchars; | |
2089 | |
2090 outstream = p->filter; | |
2091 if (!NILP (outstream)) | |
2092 { | |
2093 /* We inhibit quit here instead of just catching it so that | |
2094 hitting ^G when a filter happens to be running won't screw | |
2095 it up. */ | |
2096 int count = specpdl_ptr - specpdl; | |
3510
b4a552ca4e99
(read_process_output): Deactivate the mark.
Richard M. Stallman <rms@gnu.org>
parents:
3238
diff
changeset
|
2097 Lisp_Object odeactivate; |
b4a552ca4e99
(read_process_output): Deactivate the mark.
Richard M. Stallman <rms@gnu.org>
parents:
3238
diff
changeset
|
2098 |
b4a552ca4e99
(read_process_output): Deactivate the mark.
Richard M. Stallman <rms@gnu.org>
parents:
3238
diff
changeset
|
2099 odeactivate = Vdeactivate_mark; |
b4a552ca4e99
(read_process_output): Deactivate the mark.
Richard M. Stallman <rms@gnu.org>
parents:
3238
diff
changeset
|
2100 |
578 | 2101 specbind (Qinhibit_quit, Qt); |
2102 call2 (outstream, proc, make_string (chars, nchars)); | |
2103 | |
3666
c7ff787b096f
(read_process_output): Don't deactivate the mark.
Richard M. Stallman <rms@gnu.org>
parents:
3608
diff
changeset
|
2104 /* Handling the process output should not deactivate the mark. */ |
3510
b4a552ca4e99
(read_process_output): Deactivate the mark.
Richard M. Stallman <rms@gnu.org>
parents:
3238
diff
changeset
|
2105 Vdeactivate_mark = odeactivate; |
b4a552ca4e99
(read_process_output): Deactivate the mark.
Richard M. Stallman <rms@gnu.org>
parents:
3238
diff
changeset
|
2106 |
578 | 2107 #ifdef VMS |
2108 start_vms_process_read (vs); | |
2109 #endif | |
2110 unbind_to (count); | |
2111 return nchars; | |
2112 } | |
2113 | |
2114 /* If no filter, write into buffer if it isn't dead. */ | |
2115 if (!NILP (p->buffer) && !NILP (XBUFFER (p->buffer)->name)) | |
2116 { | |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2117 Lisp_Object old_read_only; |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2118 Lisp_Object old_begv, old_zv; |
3510
b4a552ca4e99
(read_process_output): Deactivate the mark.
Richard M. Stallman <rms@gnu.org>
parents:
3238
diff
changeset
|
2119 Lisp_Object odeactivate; |
b4a552ca4e99
(read_process_output): Deactivate the mark.
Richard M. Stallman <rms@gnu.org>
parents:
3238
diff
changeset
|
2120 |
b4a552ca4e99
(read_process_output): Deactivate the mark.
Richard M. Stallman <rms@gnu.org>
parents:
3238
diff
changeset
|
2121 odeactivate = Vdeactivate_mark; |
578 | 2122 |
2123 Fset_buffer (p->buffer); | |
2124 opoint = point; | |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2125 old_read_only = current_buffer->read_only; |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2126 XFASTINT (old_begv) = BEGV; |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2127 XFASTINT (old_zv) = ZV; |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2128 |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2129 current_buffer->read_only = Qnil; |
578 | 2130 |
2131 /* Insert new output into buffer | |
2132 at the current end-of-output marker, | |
2133 thus preserving logical ordering of input and output. */ | |
2134 if (XMARKER (p->mark)->buffer) | |
2135 SET_PT (marker_position (p->mark)); | |
2136 else | |
2137 SET_PT (ZV); | |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2138 |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2139 /* If the output marker is outside of the visible region, save |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2140 the restriction and widen. */ |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2141 if (! (BEGV <= point && point <= ZV)) |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2142 Fwiden (); |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2143 |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2144 /* Make sure opoint floats ahead of any new text, just as point |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2145 would. */ |
578 | 2146 if (point <= opoint) |
2147 opoint += nchars; | |
2148 | |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2149 /* Insert after old_begv, but before old_zv. */ |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2150 if (point < XFASTINT (old_begv)) |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2151 XFASTINT (old_begv) += nchars; |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2152 if (point <= XFASTINT (old_zv)) |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2153 XFASTINT (old_zv) += nchars; |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2154 |
578 | 2155 /* Insert before markers in case we are inserting where |
2156 the buffer's mark is, and the user's next command is Meta-y. */ | |
2157 insert_before_markers (chars, nchars); | |
2158 Fset_marker (p->mark, make_number (point), p->buffer); | |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2159 |
578 | 2160 update_mode_lines++; |
2161 | |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2162 /* If the restriction isn't what it should be, set it. */ |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2163 if (XFASTINT (old_begv) != BEGV || XFASTINT (old_zv) != ZV) |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2164 Fnarrow_to_region (old_begv, old_zv); |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2165 |
3666
c7ff787b096f
(read_process_output): Don't deactivate the mark.
Richard M. Stallman <rms@gnu.org>
parents:
3608
diff
changeset
|
2166 /* Handling the process output should not deactivate the mark. */ |
3510
b4a552ca4e99
(read_process_output): Deactivate the mark.
Richard M. Stallman <rms@gnu.org>
parents:
3238
diff
changeset
|
2167 Vdeactivate_mark = odeactivate; |
b4a552ca4e99
(read_process_output): Deactivate the mark.
Richard M. Stallman <rms@gnu.org>
parents:
3238
diff
changeset
|
2168 |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2169 current_buffer->read_only = old_read_only; |
578 | 2170 SET_PT (opoint); |
2171 set_buffer_internal (old); | |
2172 } | |
2173 #ifdef VMS | |
2174 start_vms_process_read (vs); | |
2175 #endif | |
2176 return nchars; | |
2177 } | |
2178 | |
2179 DEFUN ("waiting-for-user-input-p", Fwaiting_for_user_input_p, Swaiting_for_user_input_p, | |
2180 0, 0, 0, | |
2181 "Returns non-NIL if emacs is waiting for input from the user.\n\ | |
2182 This is intended for use by asynchronous process output filters and sentinels.") | |
2183 () | |
2184 { | |
2185 return ((waiting_for_user_input_p) ? Qt : Qnil); | |
2186 } | |
2187 | |
2188 /* Sending data to subprocess */ | |
2189 | |
2190 jmp_buf send_process_frame; | |
2191 | |
2192 SIGTYPE | |
2193 send_process_trap () | |
2194 { | |
2195 #ifdef BSD4_1 | |
2196 sigrelse (SIGPIPE); | |
2197 sigrelse (SIGALRM); | |
2198 #endif /* BSD4_1 */ | |
2199 longjmp (send_process_frame, 1); | |
2200 } | |
2201 | |
2202 send_process (proc, buf, len) | |
2203 Lisp_Object proc; | |
2204 char *buf; | |
2205 int len; | |
2206 { | |
2207 /* Don't use register vars; longjmp can lose them. */ | |
2208 int rv; | |
2209 unsigned char *procname = XSTRING (XPROCESS (proc)->name)->data; | |
2210 | |
2211 | |
2212 #ifdef VMS | |
2213 struct Lisp_Process *p = XPROCESS (proc); | |
2214 VMS_PROC_STUFF *vs, *get_vms_process_pointer(); | |
2215 #endif /* VMS */ | |
2216 | |
2217 if (! NILP (XPROCESS (proc)->raw_status_low)) | |
2218 update_status (XPROCESS (proc)); | |
2219 if (! EQ (XPROCESS (proc)->status, Qrun)) | |
2220 error ("Process %s not running", procname); | |
2221 | |
2222 #ifdef VMS | |
2223 vs = get_vms_process_pointer (p->pid); | |
2224 if (vs == 0) | |
2225 error ("Could not find this process: %x", p->pid); | |
2226 else if (write_to_vms_process (vs, buf, len)) | |
2227 ; | |
2228 #else | |
2229 if (!setjmp (send_process_frame)) | |
2230 while (len > 0) | |
2231 { | |
2232 int this = len; | |
621 | 2233 SIGTYPE (*old_sigpipe)(); |
2234 | |
578 | 2235 /* Don't send more than 500 bytes at a time. */ |
2236 if (this > 500) | |
2237 this = 500; | |
692 | 2238 old_sigpipe = (SIGTYPE (*) ()) signal (SIGPIPE, send_process_trap); |
578 | 2239 rv = write (XFASTINT (XPROCESS (proc)->outfd), buf, this); |
621 | 2240 signal (SIGPIPE, old_sigpipe); |
578 | 2241 if (rv < 0) |
2242 { | |
2243 if (0 | |
2244 #ifdef EWOULDBLOCK | |
2245 || errno == EWOULDBLOCK | |
2246 #endif | |
2247 #ifdef EAGAIN | |
2248 || errno == EAGAIN | |
2249 #endif | |
2250 ) | |
2251 { | |
2252 /* It would be nice to accept process output here, | |
2253 but that is difficult. For example, it could | |
2254 garbage what we are sending if that is from a buffer. */ | |
2255 immediate_quit = 1; | |
2256 QUIT; | |
2257 sleep (1); | |
2258 immediate_quit = 0; | |
2259 continue; | |
2260 } | |
2261 report_file_error ("writing to process", Fcons (proc, Qnil)); | |
2262 } | |
2263 buf += rv; | |
2264 len -= rv; | |
2265 /* Allow input from processes between bursts of sending. | |
2266 Otherwise things may get stopped up. */ | |
2267 if (len > 0) | |
650 | 2268 { |
2269 Lisp_Object zero; | |
2270 | |
2271 XFASTINT (zero) = 0; | |
2272 wait_reading_process_input (-1, 0, zero, 0); | |
2273 } | |
578 | 2274 } |
2275 #endif | |
2276 else | |
2277 { | |
2278 XPROCESS (proc)->raw_status_low = Qnil; | |
2279 XPROCESS (proc)->raw_status_high = Qnil; | |
2280 XPROCESS (proc)->status = Fcons (Qexit, Fcons (make_number (256), Qnil)); | |
2281 XSETINT (XPROCESS (proc)->tick, ++process_tick); | |
2282 deactivate_process (proc); | |
2283 #ifdef VMS | |
2284 error ("Error writing to process %s; closed it", procname); | |
2285 #else | |
2286 error ("SIGPIPE raised on process %s; closed it", procname); | |
2287 #endif | |
2288 } | |
2289 } | |
2290 | |
2291 DEFUN ("process-send-region", Fprocess_send_region, Sprocess_send_region, | |
2292 3, 3, 0, | |
2293 "Send current contents of region as input to PROCESS.\n\ | |
808 | 2294 PROCESS may be a process, a buffer, the name of a process or buffer, or\n\ |
2295 nil, indicating the current buffer's process.\n\ | |
578 | 2296 Called from program, takes three arguments, PROCESS, START and END.\n\ |
2297 If the region is more than 500 characters long,\n\ | |
2298 it is sent in several bunches. This may happen even for shorter regions.\n\ | |
2299 Output from processes can arrive in between bunches.") | |
2300 (process, start, end) | |
2301 Lisp_Object process, start, end; | |
2302 { | |
2303 Lisp_Object proc; | |
2304 int start1; | |
2305 | |
2306 proc = get_process (process); | |
2307 validate_region (&start, &end); | |
2308 | |
2309 if (XINT (start) < GPT && XINT (end) > GPT) | |
2310 move_gap (start); | |
2311 | |
2312 start1 = XINT (start); | |
2313 send_process (proc, &FETCH_CHAR (start1), XINT (end) - XINT (start)); | |
2314 | |
2315 return Qnil; | |
2316 } | |
2317 | |
2318 DEFUN ("process-send-string", Fprocess_send_string, Sprocess_send_string, | |
2319 2, 2, 0, | |
2320 "Send PROCESS the contents of STRING as input.\n\ | |
808 | 2321 PROCESS may be a process, a buffer, the name of a process or buffer, or\n\ |
2322 nil, indicating the current buffer's process.\n\ | |
578 | 2323 If STRING is more than 500 characters long,\n\ |
2324 it is sent in several bunches. This may happen even for shorter strings.\n\ | |
2325 Output from processes can arrive in between bunches.") | |
2326 (process, string) | |
2327 Lisp_Object process, string; | |
2328 { | |
2329 Lisp_Object proc; | |
2330 CHECK_STRING (string, 1); | |
2331 proc = get_process (process); | |
2332 send_process (proc, XSTRING (string)->data, XSTRING (string)->size); | |
2333 return Qnil; | |
2334 } | |
2335 | |
2336 /* send a signal number SIGNO to PROCESS. | |
2337 CURRENT_GROUP means send to the process group that currently owns | |
2338 the terminal being used to communicate with PROCESS. | |
2339 This is used for various commands in shell mode. | |
2340 If NOMSG is zero, insert signal-announcements into process's buffers | |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2341 right away. |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2342 |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2343 If we can, we try to signal PROCESS by sending control characters |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2344 down the pipe. This allows us to signal inferiors who have changed |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2345 their uid, for which killpg would return an EPERM error. */ |
578 | 2346 |
1522
19ccf004b172
* process.c: (status_convert): Declare this to return a
Jim Blandy <jimb@redhat.com>
parents:
1323
diff
changeset
|
2347 static void |
578 | 2348 process_send_signal (process, signo, current_group, nomsg) |
2349 Lisp_Object process; | |
2350 int signo; | |
2351 Lisp_Object current_group; | |
2352 int nomsg; | |
2353 { | |
2354 Lisp_Object proc; | |
2355 register struct Lisp_Process *p; | |
2356 int gid; | |
2357 int no_pgrp = 0; | |
2358 | |
2359 proc = get_process (process); | |
2360 p = XPROCESS (proc); | |
2361 | |
2362 if (!EQ (p->childp, Qt)) | |
2363 error ("Process %s is not a subprocess", | |
2364 XSTRING (p->name)->data); | |
2365 if (!XFASTINT (p->infd)) | |
2366 error ("Process %s is not active", | |
2367 XSTRING (p->name)->data); | |
2368 | |
2369 if (NILP (p->pty_flag)) | |
2370 current_group = Qnil; | |
2371 | |
2372 /* If we are using pgrps, get a pgrp number and make it negative. */ | |
2373 if (!NILP (current_group)) | |
2374 { | |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2375 #ifdef SIGNALS_VIA_CHARACTERS |
578 | 2376 /* If possible, send signals to the entire pgrp |
2377 by sending an input character to it. */ | |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2378 |
1925
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2379 /* TERMIOS is the latest and bestest, and seems most likely to |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2380 work. If the system has it, use it. */ |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2381 #ifdef HAVE_TERMIOS |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2382 struct termios t; |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2383 |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2384 switch (signo) |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2385 { |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2386 case SIGINT: |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2387 tcgetattr (XFASTINT (p->infd), &t); |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2388 send_process (proc, &t.c_cc[VINTR], 1); |
2120
fc3cdca22f8d
* process.c (process_send_signal): In the TERMIOS code for sending
Jim Blandy <jimb@redhat.com>
parents:
1925
diff
changeset
|
2389 return; |
1925
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2390 |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2391 case SIGQUIT: |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2392 tcgetattr (XFASTINT (p->infd), &t); |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2393 send_process (proc, &t.c_cc[VQUIT], 1); |
2120
fc3cdca22f8d
* process.c (process_send_signal): In the TERMIOS code for sending
Jim Blandy <jimb@redhat.com>
parents:
1925
diff
changeset
|
2394 return; |
1925
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2395 |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2396 case SIGTSTP: |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2397 tcgetattr (XFASTINT (p->infd), &t); |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2398 #ifdef VSWTCH |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2399 send_process (proc, &t.c_cc[VSWTCH], 1); |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2400 #else |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2401 send_process (proc, &t.c_cc[VSUSP], 1); |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2402 #endif |
2120
fc3cdca22f8d
* process.c (process_send_signal): In the TERMIOS code for sending
Jim Blandy <jimb@redhat.com>
parents:
1925
diff
changeset
|
2403 return; |
1925
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2404 } |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2405 |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2406 #else /* ! HAVE_TERMIOS */ |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2407 |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2408 /* On Berkeley descendants, the following IOCTL's retrieve the |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2409 current control characters. */ |
578 | 2410 #if defined (TIOCGLTC) && defined (TIOCGETC) |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2411 |
578 | 2412 struct tchars c; |
2413 struct ltchars lc; | |
2414 | |
2415 switch (signo) | |
2416 { | |
2417 case SIGINT: | |
2418 ioctl (XFASTINT (p->infd), TIOCGETC, &c); | |
2419 send_process (proc, &c.t_intrc, 1); | |
1522
19ccf004b172
* process.c: (status_convert): Declare this to return a
Jim Blandy <jimb@redhat.com>
parents:
1323
diff
changeset
|
2420 return; |
578 | 2421 case SIGQUIT: |
2422 ioctl (XFASTINT (p->infd), TIOCGETC, &c); | |
2423 send_process (proc, &c.t_quitc, 1); | |
1522
19ccf004b172
* process.c: (status_convert): Declare this to return a
Jim Blandy <jimb@redhat.com>
parents:
1323
diff
changeset
|
2424 return; |
1012
a48ed1d416dd
* process.c (process_send_signal): Don't send SIGTSTP if the
Jim Blandy <jimb@redhat.com>
parents:
849
diff
changeset
|
2425 #ifdef SIGTSTP |
578 | 2426 case SIGTSTP: |
2427 ioctl (XFASTINT (p->infd), TIOCGLTC, &lc); | |
2428 send_process (proc, &lc.t_suspc, 1); | |
1522
19ccf004b172
* process.c: (status_convert): Declare this to return a
Jim Blandy <jimb@redhat.com>
parents:
1323
diff
changeset
|
2429 return; |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2430 #endif /* ! defined (SIGTSTP) */ |
578 | 2431 } |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2432 |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2433 #else /* ! defined (TIOCGLTC) && defined (TIOCGETC) */ |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2434 |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2435 /* On SYSV descendants, the TCGETA ioctl retrieves the current control |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2436 characters. */ |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2437 #ifdef TCGETA |
578 | 2438 struct termio t; |
2439 switch (signo) | |
2440 { | |
2441 case SIGINT: | |
2442 ioctl (XFASTINT (p->infd), TCGETA, &t); | |
2443 send_process (proc, &t.c_cc[VINTR], 1); | |
1522
19ccf004b172
* process.c: (status_convert): Declare this to return a
Jim Blandy <jimb@redhat.com>
parents:
1323
diff
changeset
|
2444 return; |
578 | 2445 case SIGQUIT: |
2446 ioctl (XFASTINT (p->infd), TCGETA, &t); | |
2447 send_process (proc, &t.c_cc[VQUIT], 1); | |
1522
19ccf004b172
* process.c: (status_convert): Declare this to return a
Jim Blandy <jimb@redhat.com>
parents:
1323
diff
changeset
|
2448 return; |
1569
52a69b6a8f96
* process.c [SYSV]: Don't include <termios.h>, <termio.h>, or
Jim Blandy <jimb@redhat.com>
parents:
1522
diff
changeset
|
2449 #ifdef SIGTSTP |
578 | 2450 case SIGTSTP: |
2451 ioctl (XFASTINT (p->infd), TCGETA, &t); | |
2452 send_process (proc, &t.c_cc[VSWTCH], 1); | |
1522
19ccf004b172
* process.c: (status_convert): Declare this to return a
Jim Blandy <jimb@redhat.com>
parents:
1323
diff
changeset
|
2453 return; |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2454 #endif /* ! defined (SIGTSTP) */ |
578 | 2455 } |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2456 #else /* ! defined (TCGETA) */ |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2457 Your configuration files are messed up. |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2458 /* If your system configuration files define SIGNALS_VIA_CHARACTERS, |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2459 you'd better be using one of the alternatives above! */ |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2460 #endif /* ! defined (TCGETA) */ |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2461 #endif /* ! defined (TIOCGLTC) && defined (TIOCGETC) */ |
1925
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2462 #endif /* ! defined HAVE_TERMIOS */ |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2463 #endif /* ! defined (SIGNALS_VIA_CHARACTERS) */ |
849 | 2464 |
2465 #ifdef TIOCGPGRP | |
578 | 2466 /* Get the pgrp using the tty itself, if we have that. |
2467 Otherwise, use the pty to get the pgrp. | |
2468 On pfa systems, saka@pfu.fujitsu.co.JP writes: | |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2469 "TIOCGPGRP symbol defined in sys/ioctl.h at E50. |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2470 But, TIOCGPGRP does not work on E50 ;-P works fine on E60" |
578 | 2471 His patch indicates that if TIOCGPGRP returns an error, then |
2472 we should just assume that p->pid is also the process group id. */ | |
2473 { | |
2474 int err; | |
2475 | |
2476 if (!NILP (p->subtty)) | |
2477 err = ioctl (XFASTINT (p->subtty), TIOCGPGRP, &gid); | |
2478 else | |
2479 err = ioctl (XFASTINT (p->infd), TIOCGPGRP, &gid); | |
2480 | |
2481 #ifdef pfa | |
2482 if (err == -1) | |
2483 gid = - XFASTINT (p->pid); | |
849 | 2484 #endif /* ! defined (pfa) */ |
578 | 2485 } |
2486 if (gid == -1) | |
2487 no_pgrp = 1; | |
2488 else | |
2489 gid = - gid; | |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2490 #else /* ! defined (TIOCGPGRP ) */ |
849 | 2491 /* Can't select pgrps on this system, so we know that |
2492 the child itself heads the pgrp. */ | |
2493 gid = - XFASTINT (p->pid); | |
2494 #endif /* ! defined (TIOCGPGRP ) */ | |
578 | 2495 } |
2496 else | |
2497 gid = - XFASTINT (p->pid); | |
2498 | |
2499 switch (signo) | |
2500 { | |
2501 #ifdef SIGCONT | |
2502 case SIGCONT: | |
2503 p->raw_status_low = Qnil; | |
2504 p->raw_status_high = Qnil; | |
2505 p->status = Qrun; | |
2506 XSETINT (p->tick, ++process_tick); | |
2507 if (!nomsg) | |
2508 status_notify (); | |
2509 break; | |
849 | 2510 #endif /* ! defined (SIGCONT) */ |
578 | 2511 case SIGINT: |
2512 #ifdef VMS | |
2513 send_process (proc, "\003", 1); /* ^C */ | |
2514 goto whoosh; | |
2515 #endif | |
2516 case SIGQUIT: | |
2517 #ifdef VMS | |
2518 send_process (proc, "\031", 1); /* ^Y */ | |
2519 goto whoosh; | |
2520 #endif | |
2521 case SIGKILL: | |
2522 #ifdef VMS | |
2523 sys$forcex (&(XFASTINT (p->pid)), 0, 1); | |
2524 whoosh: | |
2525 #endif | |
2526 flush_pending_output (XFASTINT (p->infd)); | |
2527 break; | |
2528 } | |
2529 | |
2530 /* If we don't have process groups, send the signal to the immediate | |
2531 subprocess. That isn't really right, but it's better than any | |
2532 obvious alternative. */ | |
2533 if (no_pgrp) | |
2534 { | |
2535 kill (XFASTINT (p->pid), signo); | |
2536 return; | |
2537 } | |
2538 | |
2539 /* gid may be a pid, or minus a pgrp's number */ | |
2540 #ifdef TIOCSIGSEND | |
2541 if (!NILP (current_group)) | |
2542 ioctl (XFASTINT (p->infd), TIOCSIGSEND, signo); | |
2543 else | |
2544 { | |
2545 gid = - XFASTINT (p->pid); | |
2546 kill (gid, signo); | |
2547 } | |
849 | 2548 #else /* ! defined (TIOCSIGSEND) */ |
578 | 2549 EMACS_KILLPG (-gid, signo); |
849 | 2550 #endif /* ! defined (TIOCSIGSEND) */ |
578 | 2551 } |
2552 | |
2553 DEFUN ("interrupt-process", Finterrupt_process, Sinterrupt_process, 0, 2, 0, | |
2554 "Interrupt process PROCESS. May be process or name of one.\n\ | |
808 | 2555 PROCESS may be a process, a buffer, or the name of a process or buffer.\n\ |
578 | 2556 Nil or no arg means current buffer's process.\n\ |
2557 Second arg CURRENT-GROUP non-nil means send signal to\n\ | |
2558 the current process-group of the process's controlling terminal\n\ | |
2559 rather than to the process's own process group.\n\ | |
2560 If the process is a shell, this means interrupt current subjob\n\ | |
2561 rather than the shell.") | |
2562 (process, current_group) | |
2563 Lisp_Object process, current_group; | |
2564 { | |
2565 process_send_signal (process, SIGINT, current_group, 0); | |
2566 return process; | |
2567 } | |
2568 | |
2569 DEFUN ("kill-process", Fkill_process, Skill_process, 0, 2, 0, | |
2570 "Kill process PROCESS. May be process or name of one.\n\ | |
2571 See function `interrupt-process' for more details on usage.") | |
2572 (process, current_group) | |
2573 Lisp_Object process, current_group; | |
2574 { | |
2575 process_send_signal (process, SIGKILL, current_group, 0); | |
2576 return process; | |
2577 } | |
2578 | |
2579 DEFUN ("quit-process", Fquit_process, Squit_process, 0, 2, 0, | |
2580 "Send QUIT signal to process PROCESS. May be process or name of one.\n\ | |
2581 See function `interrupt-process' for more details on usage.") | |
2582 (process, current_group) | |
2583 Lisp_Object process, current_group; | |
2584 { | |
2585 process_send_signal (process, SIGQUIT, current_group, 0); | |
2586 return process; | |
2587 } | |
2588 | |
2589 DEFUN ("stop-process", Fstop_process, Sstop_process, 0, 2, 0, | |
2590 "Stop process PROCESS. May be process or name of one.\n\ | |
2591 See function `interrupt-process' for more details on usage.") | |
2592 (process, current_group) | |
2593 Lisp_Object process, current_group; | |
2594 { | |
2595 #ifndef SIGTSTP | |
2596 error ("no SIGTSTP support"); | |
2597 #else | |
2598 process_send_signal (process, SIGTSTP, current_group, 0); | |
2599 #endif | |
2600 return process; | |
2601 } | |
2602 | |
2603 DEFUN ("continue-process", Fcontinue_process, Scontinue_process, 0, 2, 0, | |
2604 "Continue process PROCESS. May be process or name of one.\n\ | |
2605 See function `interrupt-process' for more details on usage.") | |
2606 (process, current_group) | |
2607 Lisp_Object process, current_group; | |
2608 { | |
2609 #ifdef SIGCONT | |
2610 process_send_signal (process, SIGCONT, current_group, 0); | |
2611 #else | |
2612 error ("no SIGCONT support"); | |
2613 #endif | |
2614 return process; | |
2615 } | |
2616 | |
2617 DEFUN ("signal-process", Fsignal_process, Ssignal_process, | |
2618 2, 2, "nProcess number: \nnSignal code: ", | |
2619 "Send the process with number PID the signal with code CODE.\n\ | |
2620 Both PID and CODE are integers.") | |
2621 (pid, sig) | |
2622 Lisp_Object pid, sig; | |
2623 { | |
2624 CHECK_NUMBER (pid, 0); | |
2625 CHECK_NUMBER (sig, 1); | |
2626 return make_number (kill (XINT (pid), XINT (sig))); | |
2627 } | |
2628 | |
2629 DEFUN ("process-send-eof", Fprocess_send_eof, Sprocess_send_eof, 0, 1, 0, | |
2630 "Make PROCESS see end-of-file in its input.\n\ | |
2631 Eof comes after any text already sent to it.\n\ | |
808 | 2632 PROCESS may be a process, a buffer, the name of a process or buffer, or\n\ |
2633 nil, indicating the current buffer's process.") | |
578 | 2634 (process) |
2635 Lisp_Object process; | |
2636 { | |
2637 Lisp_Object proc; | |
2638 | |
2639 proc = get_process (process); | |
2221
7edc78402205
(Fprocess_send_eof): Make sure proc is running.
Richard M. Stallman <rms@gnu.org>
parents:
2200
diff
changeset
|
2640 |
7edc78402205
(Fprocess_send_eof): Make sure proc is running.
Richard M. Stallman <rms@gnu.org>
parents:
2200
diff
changeset
|
2641 /* Make sure the process is really alive. */ |
7edc78402205
(Fprocess_send_eof): Make sure proc is running.
Richard M. Stallman <rms@gnu.org>
parents:
2200
diff
changeset
|
2642 if (! NILP (XPROCESS (proc)->raw_status_low)) |
7edc78402205
(Fprocess_send_eof): Make sure proc is running.
Richard M. Stallman <rms@gnu.org>
parents:
2200
diff
changeset
|
2643 update_status (XPROCESS (proc)); |
7edc78402205
(Fprocess_send_eof): Make sure proc is running.
Richard M. Stallman <rms@gnu.org>
parents:
2200
diff
changeset
|
2644 if (! EQ (XPROCESS (proc)->status, Qrun)) |
2222
d81c60c5f9ce
Fix typo in previous change.
Richard M. Stallman <rms@gnu.org>
parents:
2221
diff
changeset
|
2645 error ("Process %s not running", XSTRING (XPROCESS (proc)->name)->data); |
2221
7edc78402205
(Fprocess_send_eof): Make sure proc is running.
Richard M. Stallman <rms@gnu.org>
parents:
2200
diff
changeset
|
2646 |
578 | 2647 /* Sending a zero-length record is supposed to mean eof |
2648 when TIOCREMOTE is turned on. */ | |
2649 #ifdef DID_REMOTE | |
2650 { | |
2651 char buf[1]; | |
2652 write (XFASTINT (XPROCESS (proc)->outfd), buf, 0); | |
2653 } | |
2654 #else /* did not do TOICREMOTE */ | |
2655 #ifdef VMS | |
2656 send_process (proc, "\032", 1); /* ^z */ | |
2657 #else | |
2658 if (!NILP (XPROCESS (proc)->pty_flag)) | |
2659 send_process (proc, "\004", 1); | |
2660 else | |
2661 { | |
2662 close (XPROCESS (proc)->outfd); | |
2432
17a84e60603b
New macros NULL_DEVICE and EXEC_SUFFIXES, to give the name of the
Jim Blandy <jimb@redhat.com>
parents:
2429
diff
changeset
|
2663 XFASTINT (XPROCESS (proc)->outfd) = open (NULL_DEVICE, O_WRONLY); |
578 | 2664 } |
2665 #endif /* VMS */ | |
2666 #endif /* did not do TOICREMOTE */ | |
2667 return process; | |
2668 } | |
2669 | |
2670 /* Kill all processes associated with `buffer'. | |
2671 If `buffer' is nil, kill all processes */ | |
2672 | |
2673 kill_buffer_processes (buffer) | |
2674 Lisp_Object buffer; | |
2675 { | |
2676 Lisp_Object tail, proc; | |
2677 | |
2678 for (tail = Vprocess_alist; XGCTYPE (tail) == Lisp_Cons; | |
2679 tail = XCONS (tail)->cdr) | |
2680 { | |
2681 proc = XCONS (XCONS (tail)->car)->cdr; | |
2682 if (XGCTYPE (proc) == Lisp_Process | |
2683 && (NILP (buffer) || EQ (XPROCESS (proc)->buffer, buffer))) | |
2684 { | |
2685 if (NETCONN_P (proc)) | |
2686 deactivate_process (proc); | |
2687 else if (XFASTINT (XPROCESS (proc)->infd)) | |
2688 process_send_signal (proc, SIGHUP, Qnil, 1); | |
2689 } | |
2690 } | |
2691 } | |
2692 | |
2693 /* On receipt of a signal that a child status has changed, | |
2694 loop asking about children with changed statuses until | |
2695 the system says there are no more. | |
2696 All we do is change the status; | |
2697 we do not run sentinels or print notifications. | |
2698 That is saved for the next time keyboard input is done, | |
2699 in order to avoid timing errors. */ | |
2700 | |
2701 /** WARNING: this can be called during garbage collection. | |
2702 Therefore, it must not be fooled by the presence of mark bits in | |
2703 Lisp objects. */ | |
2704 | |
2705 /** USG WARNING: Although it is not obvious from the documentation | |
2706 in signal(2), on a USG system the SIGCLD handler MUST NOT call | |
2707 signal() before executing at least one wait(), otherwise the handler | |
2708 will be called again, resulting in an infinite loop. The relevant | |
2709 portion of the documentation reads "SIGCLD signals will be queued | |
2710 and the signal-catching function will be continually reentered until | |
2711 the queue is empty". Invoking signal() causes the kernel to reexamine | |
2712 the SIGCLD queue. Fred Fish, UniSoft Systems Inc. */ | |
2713 | |
2714 SIGTYPE | |
2715 sigchld_handler (signo) | |
2716 int signo; | |
2717 { | |
2718 int old_errno = errno; | |
2719 Lisp_Object proc; | |
2720 register struct Lisp_Process *p; | |
1925
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2721 extern EMACS_TIME *input_available_clear_time; |
578 | 2722 |
2723 #ifdef BSD4_1 | |
2724 extern int sigheld; | |
2725 sigheld |= sigbit (SIGCHLD); | |
2726 #endif | |
2727 | |
2728 while (1) | |
2729 { | |
2730 register int pid; | |
2731 WAITTYPE w; | |
2732 Lisp_Object tail; | |
2733 | |
2734 #ifdef WNOHANG | |
2735 #ifndef WUNTRACED | |
2736 #define WUNTRACED 0 | |
2737 #endif /* no WUNTRACED */ | |
2738 /* Keep trying to get a status until we get a definitive result. */ | |
2739 do | |
2740 { | |
2741 errno = 0; | |
2742 pid = wait3 (&w, WNOHANG | WUNTRACED, 0); | |
2743 } | |
2744 while (pid <= 0 && errno == EINTR); | |
2745 | |
2746 if (pid <= 0) | |
2747 { | |
2748 /* A real failure. We have done all our job, so return. */ | |
2749 | |
2750 /* USG systems forget handlers when they are used; | |
2751 must reestablish each time */ | |
2752 #ifdef USG | |
2753 signal (signo, sigchld_handler); /* WARNING - must come after wait3() */ | |
2754 #endif | |
2755 #ifdef BSD4_1 | |
2756 sigheld &= ~sigbit (SIGCHLD); | |
2757 sigrelse (SIGCHLD); | |
2758 #endif | |
2759 errno = old_errno; | |
2760 return; | |
2761 } | |
2762 #else | |
2763 pid = wait (&w); | |
2764 #endif /* no WNOHANG */ | |
2765 | |
2766 /* Find the process that signaled us, and record its status. */ | |
2767 | |
2768 p = 0; | |
2769 for (tail = Vprocess_alist; XSYMBOL (tail) != XSYMBOL (Qnil); tail = XCONS (tail)->cdr) | |
2770 { | |
2771 proc = XCONS (XCONS (tail)->car)->cdr; | |
2772 p = XPROCESS (proc); | |
2773 if (EQ (p->childp, Qt) && XFASTINT (p->pid) == pid) | |
2774 break; | |
2775 p = 0; | |
2776 } | |
2777 | |
2778 /* Look for an asynchronous process whose pid hasn't been filled | |
2779 in yet. */ | |
2780 if (p == 0) | |
2781 for (tail = Vprocess_alist; XSYMBOL (tail) != XSYMBOL (Qnil); tail = XCONS (tail)->cdr) | |
2782 { | |
2783 proc = XCONS (XCONS (tail)->car)->cdr; | |
2784 p = XPROCESS (proc); | |
2785 if (XTYPE (p->pid) == Lisp_Int && XINT (p->pid) == -1) | |
2786 break; | |
2787 p = 0; | |
2788 } | |
2789 | |
2790 /* Change the status of the process that was found. */ | |
2791 if (p != 0) | |
2792 { | |
2793 union { int i; WAITTYPE wt; } u; | |
2794 | |
2795 XSETINT (p->tick, ++process_tick); | |
2796 u.wt = w; | |
2797 XFASTINT (p->raw_status_low) = u.i & 0xffff; | |
2798 XFASTINT (p->raw_status_high) = u.i >> 16; | |
2799 | |
2800 /* If process has terminated, stop waiting for its output. */ | |
2801 if (WIFSIGNALED (w) || WIFEXITED (w)) | |
1522
19ccf004b172
* process.c: (status_convert): Declare this to return a
Jim Blandy <jimb@redhat.com>
parents:
1323
diff
changeset
|
2802 if (XFASTINT (p->infd)) |
19ccf004b172
* process.c: (status_convert): Declare this to return a
Jim Blandy <jimb@redhat.com>
parents:
1323
diff
changeset
|
2803 FD_CLR (XFASTINT (p->infd), &input_wait_mask); |
1925
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2804 |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2805 /* Tell wait_reading_process_input that it needs to wake up and |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2806 look around. */ |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2807 if (input_available_clear_time) |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2808 EMACS_SET_SECS_USECS (*input_available_clear_time, 0, 0); |
578 | 2809 } |
2810 | |
2811 /* There was no asynchronous process found for that id. Check | |
2812 if we have a synchronous process. */ | |
2813 else | |
2814 { | |
2815 synch_process_alive = 0; | |
2816 | |
2817 /* Report the status of the synchronous process. */ | |
2818 if (WIFEXITED (w)) | |
2819 synch_process_retcode = WRETCODE (w); | |
2820 else if (WIFSIGNALED (w)) | |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2821 #ifndef VMS |
3592
7ce5a10ed6d9
* process.c (sigchld_handler): Add cast, to avoid warnings on Linux.
Jim Blandy <jimb@redhat.com>
parents:
3591
diff
changeset
|
2822 synch_process_death = (char *) sys_siglist[WTERMSIG (w)]; |
1594
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2823 #else |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2824 synch_process_death = sys_errlist[WTERMSIG (w)]; |
b476a97ad17e
* systty.h, process.c, buffer.h, callproc.c, sysdep.c, dired.c:
Jim Blandy <jimb@redhat.com>
parents:
1569
diff
changeset
|
2825 #endif |
1925
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2826 |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2827 /* Tell wait_reading_process_input that it needs to wake up and |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2828 look around. */ |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2829 if (input_available_clear_time) |
3ddb163a9201
* process.c: Make sure we don't miss processes exiting, by having
Jim Blandy <jimb@redhat.com>
parents:
1886
diff
changeset
|
2830 EMACS_SET_SECS_USECS (*input_available_clear_time, 0, 0); |
578 | 2831 } |
2832 | |
2833 /* On some systems, we must return right away. | |
2834 If any more processes want to signal us, we will | |
2835 get another signal. | |
2836 Otherwise (on systems that have WNOHANG), loop around | |
2837 to use up all the processes that have something to tell us. */ | |
2838 #if defined (USG) && ! (defined (HPUX) && defined (WNOHANG)) | |
2839 #ifdef USG | |
2840 signal (signo, sigchld_handler); | |
2841 #endif | |
2842 errno = old_errno; | |
2843 return; | |
2844 #endif /* USG, but not HPUX with WNOHANG */ | |
2845 } | |
2846 } | |
2847 | |
2848 | |
2849 static Lisp_Object | |
2850 exec_sentinel_unwind (data) | |
2851 Lisp_Object data; | |
2852 { | |
2853 XPROCESS (XCONS (data)->car)->sentinel = XCONS (data)->cdr; | |
2854 return Qnil; | |
2855 } | |
2856 | |
2857 static void | |
2858 exec_sentinel (proc, reason) | |
2859 Lisp_Object proc, reason; | |
2860 { | |
2861 Lisp_Object sentinel; | |
2862 register struct Lisp_Process *p = XPROCESS (proc); | |
2863 int count = specpdl_ptr - specpdl; | |
2864 | |
2865 sentinel = p->sentinel; | |
2866 if (NILP (sentinel)) | |
2867 return; | |
2868 | |
2869 /* Zilch the sentinel while it's running, to avoid recursive invocations; | |
2870 assure that it gets restored no matter how the sentinel exits. */ | |
2871 p->sentinel = Qnil; | |
2872 record_unwind_protect (exec_sentinel_unwind, Fcons (proc, sentinel)); | |
2873 /* Inhibit quit so that random quits don't screw up a running filter. */ | |
2874 specbind (Qinhibit_quit, Qt); | |
2875 call2 (sentinel, proc, reason); | |
2876 unbind_to (count); | |
2877 } | |
2878 | |
2879 /* Report all recent events of a change in process status | |
2880 (either run the sentinel or output a message). | |
2881 This is done while Emacs is waiting for keyboard input. */ | |
2882 | |
2883 status_notify () | |
2884 { | |
2885 register Lisp_Object proc, buffer; | |
2886 Lisp_Object tail = Qnil; | |
2887 Lisp_Object msg = Qnil; | |
2888 struct gcpro gcpro1, gcpro2; | |
2889 | |
2890 /* We need to gcpro tail; if read_process_output calls a filter | |
2891 which deletes a process and removes the cons to which tail points | |
2892 from Vprocess_alist, and then causes a GC, tail is an unprotected | |
2893 reference. */ | |
2894 GCPRO2 (tail, msg); | |
2895 | |
2896 for (tail = Vprocess_alist; !NILP (tail); tail = Fcdr (tail)) | |
2897 { | |
2898 Lisp_Object symbol; | |
2899 register struct Lisp_Process *p; | |
2900 | |
2901 proc = Fcdr (Fcar (tail)); | |
2902 p = XPROCESS (proc); | |
2903 | |
2904 if (XINT (p->tick) != XINT (p->update_tick)) | |
2905 { | |
2906 XSETINT (p->update_tick, XINT (p->tick)); | |
2907 | |
2908 /* If process is still active, read any output that remains. */ | |
2909 if (XFASTINT (p->infd)) | |
2910 while (read_process_output (proc, XFASTINT (p->infd)) > 0); | |
2911 | |
2912 buffer = p->buffer; | |
2913 | |
2914 /* Get the text to use for the message. */ | |
2915 if (!NILP (p->raw_status_low)) | |
2916 update_status (p); | |
2917 msg = status_message (p->status); | |
2918 | |
2919 /* If process is terminated, deactivate it or delete it. */ | |
2920 symbol = p->status; | |
2921 if (XTYPE (p->status) == Lisp_Cons) | |
2922 symbol = XCONS (p->status)->car; | |
2923 | |
2924 if (EQ (symbol, Qsignal) || EQ (symbol, Qexit) | |
2925 || EQ (symbol, Qclosed)) | |
2926 { | |
2927 if (delete_exited_processes) | |
2928 remove_process (proc); | |
2929 else | |
2930 deactivate_process (proc); | |
2931 } | |
2932 | |
2933 /* Now output the message suitably. */ | |
2934 if (!NILP (p->sentinel)) | |
2935 exec_sentinel (proc, msg); | |
2936 /* Don't bother with a message in the buffer | |
2937 when a process becomes runnable. */ | |
2938 else if (!EQ (symbol, Qrun) && !NILP (buffer)) | |
2939 { | |
2940 Lisp_Object ro = XBUFFER (buffer)->read_only; | |
2941 Lisp_Object tem; | |
2942 struct buffer *old = current_buffer; | |
2943 int opoint; | |
2944 | |
2945 /* Avoid error if buffer is deleted | |
2946 (probably that's why the process is dead, too) */ | |
2947 if (NILP (XBUFFER (buffer)->name)) | |
2948 continue; | |
2949 Fset_buffer (buffer); | |
2950 opoint = point; | |
2951 /* Insert new output into buffer | |
2952 at the current end-of-output marker, | |
2953 thus preserving logical ordering of input and output. */ | |
2954 if (XMARKER (p->mark)->buffer) | |
2955 SET_PT (marker_position (p->mark)); | |
2956 else | |
2957 SET_PT (ZV); | |
2958 if (point <= opoint) | |
2959 opoint += XSTRING (msg)->size + XSTRING (p->name)->size + 10; | |
2960 | |
2961 tem = current_buffer->read_only; | |
2962 current_buffer->read_only = Qnil; | |
2963 insert_string ("\nProcess "); | |
2964 Finsert (1, &p->name); | |
2965 insert_string (" "); | |
2966 Finsert (1, &msg); | |
2967 current_buffer->read_only = tem; | |
2968 Fset_marker (p->mark, make_number (point), p->buffer); | |
2969 | |
2970 SET_PT (opoint); | |
2971 set_buffer_internal (old); | |
2972 } | |
2973 } | |
2974 } /* end for */ | |
2975 | |
2976 update_mode_lines++; /* in case buffers use %s in mode-line-format */ | |
2977 redisplay_preserve_echo_area (); | |
2978 | |
2979 update_tick = process_tick; | |
2980 | |
2981 UNGCPRO; | |
2982 } | |
2983 | |
2984 init_process () | |
2985 { | |
2986 register int i; | |
2987 | |
2988 #ifdef SIGCHLD | |
2989 #ifndef CANNOT_DUMP | |
2990 if (! noninteractive || initialized) | |
2991 #endif | |
2992 signal (SIGCHLD, sigchld_handler); | |
2993 #endif | |
2994 | |
2995 FD_ZERO (&input_wait_mask); | |
2996 FD_SET (0, &input_wait_mask); | |
2997 Vprocess_alist = Qnil; | |
2998 for (i = 0; i < MAXDESC; i++) | |
2999 { | |
3000 chan_process[i] = Qnil; | |
3001 proc_buffered_char[i] = -1; | |
3002 } | |
3003 } | |
4231
91a883c56382
(Fget_buffer_process): Delete doc string from
Richard M. Stallman <rms@gnu.org>
parents:
4057
diff
changeset
|
3004 |
578 | 3005 syms_of_process () |
3006 { | |
3007 #ifdef HAVE_SOCKETS | |
3008 stream_process = intern ("stream"); | |
3009 #endif | |
3010 Qprocessp = intern ("processp"); | |
3011 staticpro (&Qprocessp); | |
3012 Qrun = intern ("run"); | |
3013 staticpro (&Qrun); | |
3014 Qstop = intern ("stop"); | |
3015 staticpro (&Qstop); | |
3016 Qsignal = intern ("signal"); | |
3017 staticpro (&Qsignal); | |
3018 | |
3019 /* Qexit is already staticpro'd by syms_of_eval; don't staticpro it | |
3020 here again. | |
3021 | |
3022 Qexit = intern ("exit"); | |
3023 staticpro (&Qexit); */ | |
3024 | |
3025 Qopen = intern ("open"); | |
3026 staticpro (&Qopen); | |
3027 Qclosed = intern ("closed"); | |
3028 staticpro (&Qclosed); | |
3029 | |
3030 staticpro (&Vprocess_alist); | |
3031 | |
3032 DEFVAR_BOOL ("delete-exited-processes", &delete_exited_processes, | |
3033 "*Non-nil means delete processes immediately when they exit.\n\ | |
3034 nil means don't delete them until `list-processes' is run."); | |
3035 | |
3036 delete_exited_processes = 1; | |
3037 | |
3038 DEFVAR_LISP ("process-connection-type", &Vprocess_connection_type, | |
3039 "Control type of device used to communicate with subprocesses.\n\ | |
3040 Values are nil to use a pipe, and t or 'pty for a pty. Note that if\n\ | |
3041 pty's are not available, this variable will be ignored. The value takes\n\ | |
3042 effect when `start-process' is called."); | |
3043 Vprocess_connection_type = Qt; | |
3044 | |
3045 defsubr (&Sprocessp); | |
3046 defsubr (&Sget_process); | |
3047 defsubr (&Sget_buffer_process); | |
3048 defsubr (&Sdelete_process); | |
3049 defsubr (&Sprocess_status); | |
3050 defsubr (&Sprocess_exit_status); | |
3051 defsubr (&Sprocess_id); | |
3052 defsubr (&Sprocess_name); | |
3053 defsubr (&Sprocess_command); | |
3054 defsubr (&Sset_process_buffer); | |
3055 defsubr (&Sprocess_buffer); | |
3056 defsubr (&Sprocess_mark); | |
3057 defsubr (&Sset_process_filter); | |
3058 defsubr (&Sprocess_filter); | |
3059 defsubr (&Sset_process_sentinel); | |
3060 defsubr (&Sprocess_sentinel); | |
3061 defsubr (&Sprocess_kill_without_query); | |
3062 defsubr (&Slist_processes); | |
3063 defsubr (&Sprocess_list); | |
3064 defsubr (&Sstart_process); | |
3065 #ifdef HAVE_SOCKETS | |
3066 defsubr (&Sopen_network_stream); | |
3067 #endif /* HAVE_SOCKETS */ | |
3068 defsubr (&Saccept_process_output); | |
3069 defsubr (&Sprocess_send_region); | |
3070 defsubr (&Sprocess_send_string); | |
3071 defsubr (&Sinterrupt_process); | |
3072 defsubr (&Skill_process); | |
3073 defsubr (&Squit_process); | |
3074 defsubr (&Sstop_process); | |
3075 defsubr (&Scontinue_process); | |
3076 defsubr (&Sprocess_send_eof); | |
3077 defsubr (&Ssignal_process); | |
3078 defsubr (&Swaiting_for_user_input_p); | |
3079 /* defsubr (&Sprocess_connection); */ | |
3080 } | |
3081 | |
588 | 3082 |
3083 #else /* not subprocesses */ | |
3084 | |
3085 #include <sys/types.h> | |
3086 #include <errno.h> | |
3087 | |
3088 #include "lisp.h" | |
3089 #include "systime.h" | |
3090 #include "termopts.h" | |
3091 | |
765 | 3092 extern int frame_garbaged; |
588 | 3093 |
3094 | |
3095 /* As described above, except assuming that there are no subprocesses: | |
3096 | |
3097 Wait for timeout to elapse and/or keyboard input to be available. | |
3098 | |
3099 time_limit is: | |
3100 timeout in seconds, or | |
3101 zero for no limit, or | |
3102 -1 means gobble data immediately available but don't wait for any. | |
3103 | |
650 | 3104 read_kbd is a Lisp_Object: |
588 | 3105 0 to ignore keyboard input, or |
3106 1 to return when input is available, or | |
3107 -1 means caller will actually read the input, so don't throw to | |
3108 the quit handler. | |
3109 We know that read_kbd will never be a Lisp_Process, since | |
3110 `subprocesses' isn't defined. | |
3111 | |
3112 do_display != 0 means redisplay should be done to show subprocess | |
3113 output that arrives. This version of the function ignores it. | |
3114 | |
3591
507f64624555
Apply typo patches from Paul Eggert.
Jim Blandy <jimb@redhat.com>
parents:
3510
diff
changeset
|
3115 Return true iff we received input from any process. */ |
588 | 3116 |
3117 int | |
3118 wait_reading_process_input (time_limit, microsecs, read_kbd, do_display) | |
650 | 3119 int time_limit, microsecs; |
3120 Lisp_Object read_kbd; | |
3121 int do_display; | |
588 | 3122 { |
3123 EMACS_TIME end_time, timeout, *timeout_p; | |
3124 int waitchannels; | |
3125 | |
3126 /* What does time_limit really mean? */ | |
3127 if (time_limit || microsecs) | |
3128 { | |
3129 /* It's not infinite. */ | |
3130 timeout_p = &timeout; | |
3131 | |
3132 if (time_limit == -1) | |
3133 /* In fact, it's zero. */ | |
3134 EMACS_SET_SECS_USECS (timeout, 0, 0); | |
3135 else | |
3136 EMACS_SET_SECS_USECS (timeout, time_limit, microsecs); | |
3137 | |
3138 /* How far in the future is that? */ | |
3139 EMACS_GET_TIME (end_time); | |
3140 EMACS_ADD_TIME (end_time, end_time, timeout); | |
3141 } | |
3142 else | |
3143 /* It's infinite. */ | |
3144 timeout_p = 0; | |
3145 | |
3146 /* Turn off periodic alarms (in case they are in use) | |
3147 because the select emulator uses alarms. */ | |
3148 stop_polling (); | |
3149 | |
3150 for (;;) | |
3151 { | |
3152 int nfds; | |
3153 | |
650 | 3154 waitchannels = XINT (read_kbd) ? 1 : 0; |
588 | 3155 |
3156 /* If calling from keyboard input, do not quit | |
3157 since we want to return C-g as an input character. | |
3158 Otherwise, do pending quit if requested. */ | |
650 | 3159 if (XINT (read_kbd) >= 0) |
588 | 3160 QUIT; |
3161 | |
3162 if (timeout_p) | |
3163 { | |
3164 EMACS_GET_TIME (*timeout_p); | |
3165 EMACS_SUB_TIME (*timeout_p, end_time, *timeout_p); | |
3166 if (EMACS_TIME_NEG_P (*timeout_p)) | |
3167 break; | |
3168 } | |
3169 | |
3170 /* Cause C-g and alarm signals to take immediate action, | |
3171 and cause input available signals to zero out timeout. */ | |
650 | 3172 if (XINT (read_kbd) < 0) |
588 | 3173 set_waiting_for_input (&timeout); |
3174 | |
765 | 3175 /* If a frame has been newly mapped and needs updating, |
588 | 3176 reprocess its display stuff. */ |
765 | 3177 if (frame_garbaged) |
588 | 3178 redisplay_preserve_echo_area (); |
3179 | |
650 | 3180 if (XINT (read_kbd) && detect_input_pending ()) |
588 | 3181 nfds = 0; |
3182 else | |
3183 nfds = select (1, &waitchannels, 0, 0, timeout_p); | |
3184 | |
3185 /* Make C-g and alarm signals set flags again */ | |
3186 clear_waiting_for_input (); | |
3187 | |
3188 /* If we woke up due to SIGWINCH, actually change size now. */ | |
3189 do_pending_window_change (); | |
3190 | |
3191 if (nfds == -1) | |
3192 { | |
3193 /* If the system call was interrupted, then go around the | |
3194 loop again. */ | |
3195 if (errno == EINTR) | |
3196 waitchannels = 0; | |
3197 } | |
3198 #ifdef sun | |
3199 else if (nfds > 0 && (waitchannels & 1) && interrupt_input) | |
3200 /* System sometimes fails to deliver SIGIO. */ | |
3201 kill (getpid (), SIGIO); | |
3202 #endif | |
3915
55ed7a65746e
(wait_reading_process_input): Use SIGIO only if defined.
Richard M. Stallman <rms@gnu.org>
parents:
3826
diff
changeset
|
3203 #ifdef SIGIO |
650 | 3204 if (XINT (read_kbd) && interrupt_input && (waitchannels & 1)) |
588 | 3205 kill (0, SIGIO); |
3915
55ed7a65746e
(wait_reading_process_input): Use SIGIO only if defined.
Richard M. Stallman <rms@gnu.org>
parents:
3826
diff
changeset
|
3206 #endif |
588 | 3207 |
3208 /* If we have timed out (nfds == 0) or found some input (nfds > 0), | |
3209 we should exit. */ | |
3210 if (nfds >= 0) | |
3211 break; | |
3212 } | |
3213 | |
2120
fc3cdca22f8d
* process.c (process_send_signal): In the TERMIOS code for sending
Jim Blandy <jimb@redhat.com>
parents:
1925
diff
changeset
|
3214 start_polling (); |
fc3cdca22f8d
* process.c (process_send_signal): In the TERMIOS code for sending
Jim Blandy <jimb@redhat.com>
parents:
1925
diff
changeset
|
3215 |
588 | 3216 return 0; |
3217 } | |
3218 | |
3219 | |
3220 DEFUN ("get-buffer-process", Fget_buffer_process, Sget_buffer_process, 1, 1, 0, | |
4231
91a883c56382
(Fget_buffer_process): Delete doc string from
Richard M. Stallman <rms@gnu.org>
parents:
4057
diff
changeset
|
3221 /* Don't confused make-docfile by having two doc strings for this function. |
91a883c56382
(Fget_buffer_process): Delete doc string from
Richard M. Stallman <rms@gnu.org>
parents:
4057
diff
changeset
|
3222 make-docfile does not pay attention to #if, for good reason! */ |
91a883c56382
(Fget_buffer_process): Delete doc string from
Richard M. Stallman <rms@gnu.org>
parents:
4057
diff
changeset
|
3223 0) |
588 | 3224 (name) |
3225 register Lisp_Object name; | |
3226 { | |
3227 return Qnil; | |
3228 } | |
3229 | |
3230 /* Kill all processes associated with `buffer'. | |
3231 If `buffer' is nil, kill all processes. | |
3232 Since we have no subprocesses, this does nothing. */ | |
3233 | |
3234 kill_buffer_processes (buffer) | |
3235 Lisp_Object buffer; | |
3236 { | |
3237 } | |
3238 | |
3239 init_process () | |
3240 { | |
3241 } | |
3242 | |
3243 syms_of_process () | |
3244 { | |
3245 defsubr (&Sget_buffer_process); | |
3246 } | |
3247 | |
3248 | |
3249 #endif /* not subprocesses */ |