Backport fix for Bug#11677 from trunk
[emacs.git] / src / callproc.c
blobd3ca7ebac957562757f9220b89bc5d7d8aa6f506
1 /* Synchronous subprocess invocation for GNU Emacs.
2 Copyright (C) 1985-1988, 1993-1995, 1999-2012
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
21 #include <config.h>
22 #include <signal.h>
23 #include <errno.h>
24 #include <stdio.h>
25 #include <setjmp.h>
26 #include <sys/types.h>
27 #include <unistd.h>
29 #include <sys/file.h>
30 #include <fcntl.h>
32 #include "lisp.h"
34 #ifdef WINDOWSNT
35 #define NOMINMAX
36 #include <windows.h>
37 #include "w32.h"
38 #define _P_NOWAIT 1 /* from process.h */
39 #endif
41 #ifdef MSDOS /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
42 #include <sys/stat.h>
43 #include <sys/param.h>
44 #endif /* MSDOS */
46 #include "commands.h"
47 #include "buffer.h"
48 #include "character.h"
49 #include "ccl.h"
50 #include "coding.h"
51 #include "composite.h"
52 #include <epaths.h>
53 #include "process.h"
54 #include "syssignal.h"
55 #include "systty.h"
56 #include "blockinput.h"
57 #include "frame.h"
58 #include "termhooks.h"
60 #ifdef MSDOS
61 #include "msdos.h"
62 #endif
64 #ifndef USE_CRT_DLL
65 extern char **environ;
66 #endif
68 #ifdef HAVE_SETPGID
69 #if !defined (USG)
70 #undef setpgrp
71 #define setpgrp setpgid
72 #endif
73 #endif
75 /* Pattern used by call-process-region to make temp files. */
76 static Lisp_Object Vtemp_file_name_pattern;
78 /* True if we are about to fork off a synchronous process or if we
79 are waiting for it. */
80 int synch_process_alive;
82 /* Nonzero => this is a string explaining death of synchronous subprocess. */
83 const char *synch_process_death;
85 /* Nonzero => this is the signal number that terminated the subprocess. */
86 int synch_process_termsig;
88 /* If synch_process_death is zero,
89 this is exit code of synchronous subprocess. */
90 int synch_process_retcode;
93 /* Clean up when exiting Fcall_process.
94 On MSDOS, delete the temporary file on any kind of termination.
95 On Unix, kill the process and any children on termination by signal. */
97 /* Nonzero if this is termination due to exit. */
98 static int call_process_exited;
100 static Lisp_Object Fgetenv_internal (Lisp_Object, Lisp_Object);
102 static Lisp_Object
103 call_process_kill (Lisp_Object fdpid)
105 emacs_close (XFASTINT (Fcar (fdpid)));
106 EMACS_KILLPG (XFASTINT (Fcdr (fdpid)), SIGKILL);
107 synch_process_alive = 0;
108 return Qnil;
111 static Lisp_Object
112 call_process_cleanup (Lisp_Object arg)
114 Lisp_Object fdpid = Fcdr (arg);
115 #if defined (MSDOS)
116 Lisp_Object file;
117 int fd;
118 #else
119 int pid;
120 #endif
122 Fset_buffer (Fcar (arg));
124 #if defined (MSDOS)
125 /* for MSDOS fdpid is really (fd . tempfile) */
126 fd = XFASTINT (Fcar (fdpid));
127 file = Fcdr (fdpid);
128 /* FD is -1 and FILE is "" when we didn't actually create a
129 temporary file in call-process. */
130 if (fd >= 0)
131 emacs_close (fd);
132 if (!(strcmp (SDATA (file), NULL_DEVICE) == 0 || SREF (file, 0) == '\0'))
133 unlink (SDATA (file));
134 #else /* not MSDOS */
135 pid = XFASTINT (Fcdr (fdpid));
137 if (call_process_exited)
139 emacs_close (XFASTINT (Fcar (fdpid)));
140 return Qnil;
143 if (EMACS_KILLPG (pid, SIGINT) == 0)
145 int count = SPECPDL_INDEX ();
146 record_unwind_protect (call_process_kill, fdpid);
147 message1 ("Waiting for process to die...(type C-g again to kill it instantly)");
148 immediate_quit = 1;
149 QUIT;
150 wait_for_termination (pid);
151 immediate_quit = 0;
152 specpdl_ptr = specpdl + count; /* Discard the unwind protect. */
153 message1 ("Waiting for process to die...done");
155 synch_process_alive = 0;
156 emacs_close (XFASTINT (Fcar (fdpid)));
157 #endif /* not MSDOS */
158 return Qnil;
161 DEFUN ("call-process", Fcall_process, Scall_process, 1, MANY, 0,
162 doc: /* Call PROGRAM synchronously in separate process.
163 The remaining arguments are optional.
164 The program's input comes from file INFILE (nil means `/dev/null').
165 Insert output in BUFFER before point; t means current buffer; nil for BUFFER
166 means discard it; 0 means discard and don't wait; and `(:file FILE)', where
167 FILE is a file name string, means that it should be written to that file
168 \(if the file already exists it is overwritten).
169 BUFFER can also have the form (REAL-BUFFER STDERR-FILE); in that case,
170 REAL-BUFFER says what to do with standard output, as above,
171 while STDERR-FILE says what to do with standard error in the child.
172 STDERR-FILE may be nil (discard standard error output),
173 t (mix it with ordinary output), or a file name string.
175 Fourth arg DISPLAY non-nil means redisplay buffer as output is inserted.
176 Remaining arguments are strings passed as command arguments to PROGRAM.
178 If executable PROGRAM can't be found as an executable, `call-process'
179 signals a Lisp error. `call-process' reports errors in execution of
180 the program only through its return and output.
182 If BUFFER is 0, `call-process' returns immediately with value nil.
183 Otherwise it waits for PROGRAM to terminate
184 and returns a numeric exit status or a signal description string.
185 If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.
187 usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS) */)
188 (ptrdiff_t nargs, Lisp_Object *args)
190 Lisp_Object infile, buffer, current_dir, path;
191 volatile int display_p_volatile;
192 int fd[2];
193 int filefd;
194 register int pid;
195 #define CALLPROC_BUFFER_SIZE_MIN (16 * 1024)
196 #define CALLPROC_BUFFER_SIZE_MAX (4 * CALLPROC_BUFFER_SIZE_MIN)
197 char buf[CALLPROC_BUFFER_SIZE_MAX];
198 int bufsize = CALLPROC_BUFFER_SIZE_MIN;
199 int count = SPECPDL_INDEX ();
200 volatile USE_SAFE_ALLOCA;
202 register const unsigned char **new_argv;
203 /* File to use for stderr in the child.
204 t means use same as standard output. */
205 Lisp_Object error_file;
206 Lisp_Object output_file = Qnil;
207 #ifdef MSDOS /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
208 char *outf, *tempfile = NULL;
209 int outfilefd;
210 #endif
211 int fd_output = -1;
212 struct coding_system process_coding; /* coding-system of process output */
213 struct coding_system argument_coding; /* coding-system of arguments */
214 /* Set to the return value of Ffind_operation_coding_system. */
215 Lisp_Object coding_systems;
216 int output_to_buffer = 1;
218 /* Qt denotes that Ffind_operation_coding_system is not yet called. */
219 coding_systems = Qt;
221 CHECK_STRING (args[0]);
223 error_file = Qt;
225 #ifndef subprocesses
226 /* Without asynchronous processes we cannot have BUFFER == 0. */
227 if (nargs >= 3
228 && (INTEGERP (CONSP (args[2]) ? XCAR (args[2]) : args[2])))
229 error ("Operating system cannot handle asynchronous subprocesses");
230 #endif /* subprocesses */
232 /* Decide the coding-system for giving arguments. */
234 Lisp_Object val, *args2;
235 ptrdiff_t i;
237 /* If arguments are supplied, we may have to encode them. */
238 if (nargs >= 5)
240 int must_encode = 0;
241 Lisp_Object coding_attrs;
243 for (i = 4; i < nargs; i++)
244 CHECK_STRING (args[i]);
246 for (i = 4; i < nargs; i++)
247 if (STRING_MULTIBYTE (args[i]))
248 must_encode = 1;
250 if (!NILP (Vcoding_system_for_write))
251 val = Vcoding_system_for_write;
252 else if (! must_encode)
253 val = Qraw_text;
254 else
256 SAFE_NALLOCA (args2, 1, nargs + 1);
257 args2[0] = Qcall_process;
258 for (i = 0; i < nargs; i++) args2[i + 1] = args[i];
259 coding_systems = Ffind_operation_coding_system (nargs + 1, args2);
260 val = CONSP (coding_systems) ? XCDR (coding_systems) : Qnil;
262 val = complement_process_encoding_system (val);
263 setup_coding_system (Fcheck_coding_system (val), &argument_coding);
264 coding_attrs = CODING_ID_ATTRS (argument_coding.id);
265 if (NILP (CODING_ATTR_ASCII_COMPAT (coding_attrs)))
267 /* We should not use an ASCII incompatible coding system. */
268 val = raw_text_coding_system (val);
269 setup_coding_system (val, &argument_coding);
274 if (nargs >= 2 && ! NILP (args[1]))
276 infile = Fexpand_file_name (args[1], BVAR (current_buffer, directory));
277 CHECK_STRING (infile);
279 else
280 infile = build_string (NULL_DEVICE);
282 if (nargs >= 3)
284 buffer = args[2];
286 /* If BUFFER is a list, its meaning is (BUFFER-FOR-STDOUT
287 FILE-FOR-STDERR), unless the first element is :file, in which case see
288 the next paragraph. */
289 if (CONSP (buffer)
290 && (! SYMBOLP (XCAR (buffer))
291 || strcmp (SSDATA (SYMBOL_NAME (XCAR (buffer))), ":file")))
293 if (CONSP (XCDR (buffer)))
295 Lisp_Object stderr_file;
296 stderr_file = XCAR (XCDR (buffer));
298 if (NILP (stderr_file) || EQ (Qt, stderr_file))
299 error_file = stderr_file;
300 else
301 error_file = Fexpand_file_name (stderr_file, Qnil);
304 buffer = XCAR (buffer);
307 /* If the buffer is (still) a list, it might be a (:file "file") spec. */
308 if (CONSP (buffer)
309 && SYMBOLP (XCAR (buffer))
310 && ! strcmp (SSDATA (SYMBOL_NAME (XCAR (buffer))), ":file"))
312 output_file = Fexpand_file_name (XCAR (XCDR (buffer)),
313 BVAR (current_buffer, directory));
314 CHECK_STRING (output_file);
315 buffer = Qnil;
318 if (!(EQ (buffer, Qnil)
319 || EQ (buffer, Qt)
320 || INTEGERP (buffer)))
322 Lisp_Object spec_buffer;
323 spec_buffer = buffer;
324 buffer = Fget_buffer_create (buffer);
325 /* Mention the buffer name for a better error message. */
326 if (NILP (buffer))
327 CHECK_BUFFER (spec_buffer);
328 CHECK_BUFFER (buffer);
331 else
332 buffer = Qnil;
334 /* Make sure that the child will be able to chdir to the current
335 buffer's current directory, or its unhandled equivalent. We
336 can't just have the child check for an error when it does the
337 chdir, since it's in a vfork.
339 We have to GCPRO around this because Fexpand_file_name,
340 Funhandled_file_name_directory, and Ffile_accessible_directory_p
341 might call a file name handling function. The argument list is
342 protected by the caller, so all we really have to worry about is
343 buffer. */
345 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
347 current_dir = BVAR (current_buffer, directory);
349 GCPRO5 (infile, buffer, current_dir, error_file, output_file);
351 current_dir = Funhandled_file_name_directory (current_dir);
352 if (NILP (current_dir))
353 /* If the file name handler says that current_dir is unreachable, use
354 a sensible default. */
355 current_dir = build_string ("~/");
356 current_dir = expand_and_dir_to_file (current_dir, Qnil);
357 current_dir = Ffile_name_as_directory (current_dir);
359 if (NILP (Ffile_accessible_directory_p (current_dir)))
360 report_file_error ("Setting current directory",
361 Fcons (BVAR (current_buffer, directory), Qnil));
363 if (STRING_MULTIBYTE (infile))
364 infile = ENCODE_FILE (infile);
365 if (STRING_MULTIBYTE (current_dir))
366 current_dir = ENCODE_FILE (current_dir);
367 if (STRINGP (error_file) && STRING_MULTIBYTE (error_file))
368 error_file = ENCODE_FILE (error_file);
369 if (STRINGP (output_file) && STRING_MULTIBYTE (output_file))
370 output_file = ENCODE_FILE (output_file);
371 UNGCPRO;
374 display_p_volatile = INTERACTIVE && nargs >= 4 && !NILP (args[3]);
376 filefd = emacs_open (SSDATA (infile), O_RDONLY, 0);
377 if (filefd < 0)
379 infile = DECODE_FILE (infile);
380 report_file_error ("Opening process input file", Fcons (infile, Qnil));
383 if (STRINGP (output_file))
385 #ifdef DOS_NT
386 fd_output = emacs_open (SSDATA (output_file),
387 O_WRONLY | O_TRUNC | O_CREAT | O_TEXT,
388 S_IREAD | S_IWRITE);
389 #else /* not DOS_NT */
390 fd_output = creat (SSDATA (output_file), 0666);
391 #endif /* not DOS_NT */
392 if (fd_output < 0)
394 output_file = DECODE_FILE (output_file);
395 report_file_error ("Opening process output file",
396 Fcons (output_file, Qnil));
398 if (STRINGP (error_file) || NILP (error_file))
399 output_to_buffer = 0;
402 /* Search for program; barf if not found. */
404 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
406 GCPRO4 (infile, buffer, current_dir, error_file);
407 openp (Vexec_path, args[0], Vexec_suffixes, &path, make_number (X_OK));
408 UNGCPRO;
410 if (NILP (path))
412 emacs_close (filefd);
413 report_file_error ("Searching for program", Fcons (args[0], Qnil));
416 /* If program file name starts with /: for quoting a magic name,
417 discard that. */
418 if (SBYTES (path) > 2 && SREF (path, 0) == '/'
419 && SREF (path, 1) == ':')
420 path = Fsubstring (path, make_number (2), Qnil);
422 SAFE_ALLOCA (new_argv, const unsigned char **,
423 (nargs > 4 ? nargs - 2 : 2) * sizeof *new_argv);
424 if (nargs > 4)
426 ptrdiff_t i;
427 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
429 GCPRO5 (infile, buffer, current_dir, path, error_file);
430 argument_coding.dst_multibyte = 0;
431 for (i = 4; i < nargs; i++)
433 argument_coding.src_multibyte = STRING_MULTIBYTE (args[i]);
434 if (CODING_REQUIRE_ENCODING (&argument_coding))
435 /* We must encode this argument. */
436 args[i] = encode_coding_string (&argument_coding, args[i], 1);
438 UNGCPRO;
439 for (i = 4; i < nargs; i++)
440 new_argv[i - 3] = SDATA (args[i]);
441 new_argv[i - 3] = 0;
443 else
444 new_argv[1] = 0;
445 new_argv[0] = SDATA (path);
447 #ifdef MSDOS /* MW, July 1993 */
449 /* If we're redirecting STDOUT to a file, that file is already open
450 on fd_output. */
451 if (fd_output < 0)
453 if ((outf = egetenv ("TMPDIR")))
454 strcpy (tempfile = alloca (strlen (outf) + 20), outf);
455 else
457 tempfile = alloca (20);
458 *tempfile = '\0';
460 dostounix_filename (tempfile);
461 if (*tempfile == '\0' || tempfile[strlen (tempfile) - 1] != '/')
462 strcat (tempfile, "/");
463 strcat (tempfile, "detmp.XXX");
464 mktemp (tempfile);
465 outfilefd = creat (tempfile, S_IREAD | S_IWRITE);
466 if (outfilefd < 0) {
467 emacs_close (filefd);
468 report_file_error ("Opening process output file",
469 Fcons (build_string (tempfile), Qnil));
472 else
473 outfilefd = fd_output;
474 fd[0] = filefd;
475 fd[1] = outfilefd;
476 #endif /* MSDOS */
478 if (INTEGERP (buffer))
479 fd[1] = emacs_open (NULL_DEVICE, O_WRONLY, 0), fd[0] = -1;
480 else
482 #ifndef MSDOS
483 errno = 0;
484 if (pipe (fd) == -1)
486 emacs_close (filefd);
487 report_file_error ("Creating process pipe", Qnil);
489 #endif
493 /* child_setup must clobber environ in systems with true vfork.
494 Protect it from permanent change. */
495 register char **save_environ = environ;
496 register int fd1 = fd[1];
497 int fd_error = fd1;
498 #ifdef HAVE_WORKING_VFORK
499 sigset_t procmask;
500 sigset_t blocked;
501 struct sigaction sigpipe_action;
502 #endif
504 if (fd_output >= 0)
505 fd1 = fd_output;
506 #if 0 /* Some systems don't have sigblock. */
507 mask = sigblock (sigmask (SIGCHLD));
508 #endif
510 /* Record that we're about to create a synchronous process. */
511 synch_process_alive = 1;
513 /* These vars record information from process termination.
514 Clear them now before process can possibly terminate,
515 to avoid timing error if process terminates soon. */
516 synch_process_death = 0;
517 synch_process_retcode = 0;
518 synch_process_termsig = 0;
520 if (NILP (error_file))
521 fd_error = emacs_open (NULL_DEVICE, O_WRONLY, 0);
522 else if (STRINGP (error_file))
524 #ifdef DOS_NT
525 fd_error = emacs_open (SSDATA (error_file),
526 O_WRONLY | O_TRUNC | O_CREAT | O_TEXT,
527 S_IREAD | S_IWRITE);
528 #else /* not DOS_NT */
529 fd_error = creat (SSDATA (error_file), 0666);
530 #endif /* not DOS_NT */
533 if (fd_error < 0)
535 emacs_close (filefd);
536 if (fd[0] != filefd)
537 emacs_close (fd[0]);
538 if (fd1 >= 0)
539 emacs_close (fd1);
540 #ifdef MSDOS
541 unlink (tempfile);
542 #endif
543 if (NILP (error_file))
544 error_file = build_string (NULL_DEVICE);
545 else if (STRINGP (error_file))
546 error_file = DECODE_FILE (error_file);
547 report_file_error ("Cannot redirect stderr", Fcons (error_file, Qnil));
550 #ifdef MSDOS /* MW, July 1993 */
551 /* Note that on MSDOS `child_setup' actually returns the child process
552 exit status, not its PID, so we assign it to `synch_process_retcode'
553 below. */
554 pid = child_setup (filefd, outfilefd, fd_error, (char **) new_argv,
555 0, current_dir);
557 /* Record that the synchronous process exited and note its
558 termination status. */
559 synch_process_alive = 0;
560 synch_process_retcode = pid;
561 if (synch_process_retcode < 0) /* means it couldn't be exec'ed */
563 synchronize_system_messages_locale ();
564 synch_process_death = strerror (errno);
567 emacs_close (outfilefd);
568 if (fd_error != outfilefd)
569 emacs_close (fd_error);
570 fd1 = -1; /* No harm in closing that one! */
571 if (tempfile)
573 /* Since CRLF is converted to LF within `decode_coding', we
574 can always open a file with binary mode. */
575 fd[0] = emacs_open (tempfile, O_RDONLY | O_BINARY, 0);
576 if (fd[0] < 0)
578 unlink (tempfile);
579 emacs_close (filefd);
580 report_file_error ("Cannot re-open temporary file",
581 Fcons (build_string (tempfile), Qnil));
584 else
585 fd[0] = -1; /* We are not going to read from tempfile. */
586 #else /* not MSDOS */
587 #ifdef WINDOWSNT
588 pid = child_setup (filefd, fd1, fd_error, (char **) new_argv,
589 0, current_dir);
590 #else /* not WINDOWSNT */
592 #ifdef HAVE_WORKING_VFORK
593 /* On many hosts (e.g. Solaris 2.4), if a vforked child calls `signal',
594 this sets the parent's signal handlers as well as the child's.
595 So delay all interrupts whose handlers the child might munge,
596 and record the current handlers so they can be restored later. */
597 sigemptyset (&blocked);
598 sigaddset (&blocked, SIGPIPE);
599 sigaction (SIGPIPE, 0, &sigpipe_action);
600 pthread_sigmask (SIG_BLOCK, &blocked, &procmask);
601 #endif
603 BLOCK_INPUT;
605 /* vfork, and prevent local vars from being clobbered by the vfork. */
607 Lisp_Object volatile buffer_volatile = buffer;
608 Lisp_Object volatile coding_systems_volatile = coding_systems;
609 Lisp_Object volatile current_dir_volatile = current_dir;
610 int volatile fd1_volatile = fd1;
611 int volatile fd_error_volatile = fd_error;
612 int volatile fd_output_volatile = fd_output;
613 int volatile output_to_buffer_volatile = output_to_buffer;
614 unsigned char const **volatile new_argv_volatile = new_argv;
616 pid = vfork ();
618 buffer = buffer_volatile;
619 coding_systems = coding_systems_volatile;
620 current_dir = current_dir_volatile;
621 fd1 = fd1_volatile;
622 fd_error = fd_error_volatile;
623 fd_output = fd_output_volatile;
624 output_to_buffer = output_to_buffer_volatile;
625 new_argv = new_argv_volatile;
628 if (pid == 0)
630 if (fd[0] >= 0)
631 emacs_close (fd[0]);
632 #ifdef HAVE_SETSID
633 setsid ();
634 #endif
635 #if defined (USG)
636 setpgrp ();
637 #else
638 setpgrp (pid, pid);
639 #endif /* USG */
641 /* GConf causes us to ignore SIGPIPE, make sure it is restored
642 in the child. */
643 signal (SIGPIPE, SIG_DFL);
644 #ifdef HAVE_WORKING_VFORK
645 pthread_sigmask (SIG_SETMASK, &procmask, 0);
646 #endif
648 child_setup (filefd, fd1, fd_error, (char **) new_argv,
649 0, current_dir);
652 UNBLOCK_INPUT;
654 #ifdef HAVE_WORKING_VFORK
655 /* Restore the signal state. */
656 sigaction (SIGPIPE, &sigpipe_action, 0);
657 pthread_sigmask (SIG_SETMASK, &procmask, 0);
658 #endif
660 #endif /* not WINDOWSNT */
662 /* The MSDOS case did this already. */
663 if (fd_error >= 0)
664 emacs_close (fd_error);
665 #endif /* not MSDOS */
667 environ = save_environ;
669 /* Close most of our fd's, but not fd[0]
670 since we will use that to read input from. */
671 emacs_close (filefd);
672 if (fd_output >= 0)
673 emacs_close (fd_output);
674 if (fd1 >= 0 && fd1 != fd_error)
675 emacs_close (fd1);
678 if (pid < 0)
680 if (fd[0] >= 0)
681 emacs_close (fd[0]);
682 report_file_error ("Doing vfork", Qnil);
685 if (INTEGERP (buffer))
687 if (fd[0] >= 0)
688 emacs_close (fd[0]);
689 return Qnil;
692 /* Enable sending signal if user quits below. */
693 call_process_exited = 0;
695 #if defined (MSDOS)
696 /* MSDOS needs different cleanup information. */
697 record_unwind_protect (call_process_cleanup,
698 Fcons (Fcurrent_buffer (),
699 Fcons (make_number (fd[0]),
700 build_string (tempfile ? tempfile : ""))));
701 #else
702 record_unwind_protect (call_process_cleanup,
703 Fcons (Fcurrent_buffer (),
704 Fcons (make_number (fd[0]), make_number (pid))));
705 #endif /* not MSDOS */
708 if (BUFFERP (buffer))
709 Fset_buffer (buffer);
711 if (NILP (buffer))
713 /* If BUFFER is nil, we must read process output once and then
714 discard it, so setup coding system but with nil. */
715 setup_coding_system (Qnil, &process_coding);
716 process_coding.dst_multibyte = 0;
718 else
720 Lisp_Object val, *args2;
722 val = Qnil;
723 if (!NILP (Vcoding_system_for_read))
724 val = Vcoding_system_for_read;
725 else
727 if (EQ (coding_systems, Qt))
729 ptrdiff_t i;
731 SAFE_NALLOCA (args2, 1, nargs + 1);
732 args2[0] = Qcall_process;
733 for (i = 0; i < nargs; i++) args2[i + 1] = args[i];
734 coding_systems
735 = Ffind_operation_coding_system (nargs + 1, args2);
737 if (CONSP (coding_systems))
738 val = XCAR (coding_systems);
739 else if (CONSP (Vdefault_process_coding_system))
740 val = XCAR (Vdefault_process_coding_system);
741 else
742 val = Qnil;
744 Fcheck_coding_system (val);
745 /* In unibyte mode, character code conversion should not take
746 place but EOL conversion should. So, setup raw-text or one
747 of the subsidiary according to the information just setup. */
748 if (NILP (BVAR (current_buffer, enable_multibyte_characters))
749 && !NILP (val))
750 val = raw_text_coding_system (val);
751 setup_coding_system (val, &process_coding);
752 process_coding.dst_multibyte
753 = ! NILP (BVAR (current_buffer, enable_multibyte_characters));
755 process_coding.src_multibyte = 0;
757 immediate_quit = 1;
758 QUIT;
760 if (output_to_buffer)
762 register EMACS_INT nread;
763 int first = 1;
764 EMACS_INT total_read = 0;
765 int carryover = 0;
766 int display_p = display_p_volatile;
767 int display_on_the_fly = display_p;
768 struct coding_system saved_coding;
770 saved_coding = process_coding;
771 while (1)
773 /* Repeatedly read until we've filled as much as possible
774 of the buffer size we have. But don't read
775 less than 1024--save that for the next bufferful. */
776 nread = carryover;
777 while (nread < bufsize - 1024)
779 int this_read = emacs_read (fd[0], buf + nread,
780 bufsize - nread);
782 if (this_read < 0)
783 goto give_up;
785 if (this_read == 0)
787 process_coding.mode |= CODING_MODE_LAST_BLOCK;
788 break;
791 nread += this_read;
792 total_read += this_read;
794 if (display_on_the_fly)
795 break;
798 /* Now NREAD is the total amount of data in the buffer. */
799 immediate_quit = 0;
801 if (!NILP (buffer))
803 if (NILP (BVAR (current_buffer, enable_multibyte_characters))
804 && ! CODING_MAY_REQUIRE_DECODING (&process_coding))
805 insert_1_both (buf, nread, nread, 0, 1, 0);
806 else
807 { /* We have to decode the input. */
808 Lisp_Object curbuf;
809 int count1 = SPECPDL_INDEX ();
811 XSETBUFFER (curbuf, current_buffer);
812 /* We cannot allow after-change-functions be run
813 during decoding, because that might modify the
814 buffer, while we rely on process_coding.produced to
815 faithfully reflect inserted text until we
816 TEMP_SET_PT_BOTH below. */
817 specbind (Qinhibit_modification_hooks, Qt);
818 decode_coding_c_string (&process_coding,
819 (unsigned char *) buf, nread, curbuf);
820 unbind_to (count1, Qnil);
821 if (display_on_the_fly
822 && CODING_REQUIRE_DETECTION (&saved_coding)
823 && ! CODING_REQUIRE_DETECTION (&process_coding))
825 /* We have detected some coding system. But,
826 there's a possibility that the detection was
827 done by insufficient data. So, we give up
828 displaying on the fly. */
829 if (process_coding.produced > 0)
830 del_range_2 (process_coding.dst_pos,
831 process_coding.dst_pos_byte,
832 process_coding.dst_pos
833 + process_coding.produced_char,
834 process_coding.dst_pos_byte
835 + process_coding.produced, 0);
836 display_on_the_fly = 0;
837 process_coding = saved_coding;
838 carryover = nread;
839 /* This is to make the above condition always
840 fails in the future. */
841 saved_coding.common_flags
842 &= ~CODING_REQUIRE_DETECTION_MASK;
843 continue;
846 TEMP_SET_PT_BOTH (PT + process_coding.produced_char,
847 PT_BYTE + process_coding.produced);
848 carryover = process_coding.carryover_bytes;
849 if (carryover > 0)
850 memcpy (buf, process_coding.carryover,
851 process_coding.carryover_bytes);
855 if (process_coding.mode & CODING_MODE_LAST_BLOCK)
856 break;
858 /* Make the buffer bigger as we continue to read more data,
859 but not past CALLPROC_BUFFER_SIZE_MAX. */
860 if (bufsize < CALLPROC_BUFFER_SIZE_MAX && total_read > 32 * bufsize)
861 if ((bufsize *= 2) > CALLPROC_BUFFER_SIZE_MAX)
862 bufsize = CALLPROC_BUFFER_SIZE_MAX;
864 if (display_p)
866 if (first)
867 prepare_menu_bars ();
868 first = 0;
869 redisplay_preserve_echo_area (1);
870 /* This variable might have been set to 0 for code
871 detection. In that case, we set it back to 1 because
872 we should have already detected a coding system. */
873 display_on_the_fly = 1;
875 immediate_quit = 1;
876 QUIT;
878 give_up: ;
880 Vlast_coding_system_used = CODING_ID_NAME (process_coding.id);
881 /* If the caller required, let the buffer inherit the
882 coding-system used to decode the process output. */
883 if (inherit_process_coding_system)
884 call1 (intern ("after-insert-file-set-buffer-file-coding-system"),
885 make_number (total_read));
888 #ifndef MSDOS
889 /* Wait for it to terminate, unless it already has. */
890 if (output_to_buffer)
891 wait_for_termination (pid);
892 else
893 interruptible_wait_for_termination (pid);
894 #endif
896 immediate_quit = 0;
898 /* Don't kill any children that the subprocess may have left behind
899 when exiting. */
900 call_process_exited = 1;
902 SAFE_FREE ();
903 unbind_to (count, Qnil);
905 if (synch_process_termsig)
907 const char *signame;
909 synchronize_system_messages_locale ();
910 signame = strsignal (synch_process_termsig);
912 if (signame == 0)
913 signame = "unknown";
915 synch_process_death = signame;
918 if (synch_process_death)
919 return code_convert_string_norecord (build_string (synch_process_death),
920 Vlocale_coding_system, 0);
921 return make_number (synch_process_retcode);
924 static Lisp_Object
925 delete_temp_file (Lisp_Object name)
927 /* Suppress jka-compr handling, etc. */
928 int count = SPECPDL_INDEX ();
929 specbind (intern ("file-name-handler-alist"), Qnil);
930 internal_delete_file (name);
931 unbind_to (count, Qnil);
932 return Qnil;
935 DEFUN ("call-process-region", Fcall_process_region, Scall_process_region,
936 3, MANY, 0,
937 doc: /* Send text from START to END to a synchronous process running PROGRAM.
938 The remaining arguments are optional.
939 Delete the text if fourth arg DELETE is non-nil.
941 Insert output in BUFFER before point; t means current buffer; nil for
942 BUFFER means discard it; 0 means discard and don't wait; and `(:file
943 FILE)', where FILE is a file name string, means that it should be
944 written to that file (if the file already exists it is overwritten).
945 BUFFER can also have the form (REAL-BUFFER STDERR-FILE); in that case,
946 REAL-BUFFER says what to do with standard output, as above,
947 while STDERR-FILE says what to do with standard error in the child.
948 STDERR-FILE may be nil (discard standard error output),
949 t (mix it with ordinary output), or a file name string.
951 Sixth arg DISPLAY non-nil means redisplay buffer as output is inserted.
952 Remaining args are passed to PROGRAM at startup as command args.
954 If BUFFER is 0, `call-process-region' returns immediately with value nil.
955 Otherwise it waits for PROGRAM to terminate
956 and returns a numeric exit status or a signal description string.
957 If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.
959 usage: (call-process-region START END PROGRAM &optional DELETE BUFFER DISPLAY &rest ARGS) */)
960 (ptrdiff_t nargs, Lisp_Object *args)
962 struct gcpro gcpro1;
963 Lisp_Object filename_string;
964 register Lisp_Object start, end;
965 int count = SPECPDL_INDEX ();
966 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
967 Lisp_Object coding_systems;
968 Lisp_Object val, *args2;
969 ptrdiff_t i;
970 char *tempfile;
971 Lisp_Object tmpdir, pattern;
973 if (STRINGP (Vtemporary_file_directory))
974 tmpdir = Vtemporary_file_directory;
975 else
977 #ifndef DOS_NT
978 if (getenv ("TMPDIR"))
979 tmpdir = build_string (getenv ("TMPDIR"));
980 else
981 tmpdir = build_string ("/tmp/");
982 #else /* DOS_NT */
983 char *outf;
984 if ((outf = egetenv ("TMPDIR"))
985 || (outf = egetenv ("TMP"))
986 || (outf = egetenv ("TEMP")))
987 tmpdir = build_string (outf);
988 else
989 tmpdir = Ffile_name_as_directory (build_string ("c:/temp"));
990 #endif
994 USE_SAFE_ALLOCA;
995 pattern = Fexpand_file_name (Vtemp_file_name_pattern, tmpdir);
996 SAFE_ALLOCA (tempfile, char *, SBYTES (pattern) + 1);
997 memcpy (tempfile, SDATA (pattern), SBYTES (pattern) + 1);
998 coding_systems = Qt;
1000 #ifdef HAVE_MKSTEMP
1002 int fd;
1004 BLOCK_INPUT;
1005 fd = mkstemp (tempfile);
1006 UNBLOCK_INPUT;
1007 if (fd == -1)
1008 report_file_error ("Failed to open temporary file",
1009 Fcons (Vtemp_file_name_pattern, Qnil));
1010 else
1011 close (fd);
1013 #else
1014 mktemp (tempfile);
1015 #endif
1017 filename_string = build_string (tempfile);
1018 GCPRO1 (filename_string);
1019 SAFE_FREE ();
1022 start = args[0];
1023 end = args[1];
1024 /* Decide coding-system of the contents of the temporary file. */
1025 if (!NILP (Vcoding_system_for_write))
1026 val = Vcoding_system_for_write;
1027 else if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
1028 val = Qraw_text;
1029 else
1031 USE_SAFE_ALLOCA;
1032 SAFE_NALLOCA (args2, 1, nargs + 1);
1033 args2[0] = Qcall_process_region;
1034 for (i = 0; i < nargs; i++) args2[i + 1] = args[i];
1035 coding_systems = Ffind_operation_coding_system (nargs + 1, args2);
1036 val = CONSP (coding_systems) ? XCDR (coding_systems) : Qnil;
1037 SAFE_FREE ();
1039 val = complement_process_encoding_system (val);
1042 int count1 = SPECPDL_INDEX ();
1044 specbind (intern ("coding-system-for-write"), val);
1045 /* POSIX lets mk[s]temp use "."; don't invoke jka-compr if we
1046 happen to get a ".Z" suffix. */
1047 specbind (intern ("file-name-handler-alist"), Qnil);
1048 Fwrite_region (start, end, filename_string, Qnil, Qlambda, Qnil, Qnil);
1050 unbind_to (count1, Qnil);
1053 /* Note that Fcall_process takes care of binding
1054 coding-system-for-read. */
1056 record_unwind_protect (delete_temp_file, filename_string);
1058 if (nargs > 3 && !NILP (args[3]))
1059 Fdelete_region (start, end);
1061 if (nargs > 3)
1063 args += 2;
1064 nargs -= 2;
1066 else
1068 args[0] = args[2];
1069 nargs = 2;
1071 args[1] = filename_string;
1073 RETURN_UNGCPRO (unbind_to (count, Fcall_process (nargs, args)));
1076 #ifndef WINDOWSNT
1077 static int relocate_fd (int fd, int minfd);
1078 #endif
1080 static char **
1081 add_env (char **env, char **new_env, char *string)
1083 char **ep;
1084 int ok = 1;
1085 if (string == NULL)
1086 return new_env;
1088 /* See if this string duplicates any string already in the env.
1089 If so, don't put it in.
1090 When an env var has multiple definitions,
1091 we keep the definition that comes first in process-environment. */
1092 for (ep = env; ok && ep != new_env; ep++)
1094 char *p = *ep, *q = string;
1095 while (ok)
1097 if (*q != *p)
1098 break;
1099 if (*q == 0)
1100 /* The string is a lone variable name; keep it for now, we
1101 will remove it later. It is a placeholder for a
1102 variable that is not to be included in the environment. */
1103 break;
1104 if (*q == '=')
1105 ok = 0;
1106 p++, q++;
1109 if (ok)
1110 *new_env++ = string;
1111 return new_env;
1114 /* This is the last thing run in a newly forked inferior
1115 either synchronous or asynchronous.
1116 Copy descriptors IN, OUT and ERR as descriptors 0, 1 and 2.
1117 Initialize inferior's priority, pgrp, connected dir and environment.
1118 then exec another program based on new_argv.
1120 This function may change environ for the superior process.
1121 Therefore, the superior process must save and restore the value
1122 of environ around the vfork and the call to this function.
1124 SET_PGRP is nonzero if we should put the subprocess into a separate
1125 process group.
1127 CURRENT_DIR is an elisp string giving the path of the current
1128 directory the subprocess should have. Since we can't really signal
1129 a decent error from within the child, this should be verified as an
1130 executable directory by the parent. */
1133 child_setup (int in, int out, int err, register char **new_argv, int set_pgrp, Lisp_Object current_dir)
1135 char **env;
1136 char *pwd_var;
1137 #ifdef WINDOWSNT
1138 int cpid;
1139 HANDLE handles[3];
1140 #endif /* WINDOWSNT */
1142 int pid = getpid ();
1144 /* Close Emacs's descriptors that this process should not have. */
1145 close_process_descs ();
1147 /* DOS_NT isn't in a vfork, so if we are in the middle of load-file,
1148 we will lose if we call close_load_descs here. */
1149 #ifndef DOS_NT
1150 close_load_descs ();
1151 #endif
1153 /* Note that use of alloca is always safe here. It's obvious for systems
1154 that do not have true vfork or that have true (stack) alloca.
1155 If using vfork and C_ALLOCA (when Emacs used to include
1156 src/alloca.c) it is safe because that changes the superior's
1157 static variables as if the superior had done alloca and will be
1158 cleaned up in the usual way. */
1160 register char *temp;
1161 size_t i; /* size_t, because ptrdiff_t might overflow here! */
1163 i = SBYTES (current_dir);
1164 #ifdef MSDOS
1165 /* MSDOS must have all environment variables malloc'ed, because
1166 low-level libc functions that launch subsidiary processes rely
1167 on that. */
1168 pwd_var = (char *) xmalloc (i + 6);
1169 #else
1170 pwd_var = (char *) alloca (i + 6);
1171 #endif
1172 temp = pwd_var + 4;
1173 memcpy (pwd_var, "PWD=", 4);
1174 memcpy (temp, SDATA (current_dir), i);
1175 if (!IS_DIRECTORY_SEP (temp[i - 1])) temp[i++] = DIRECTORY_SEP;
1176 temp[i] = 0;
1178 #ifndef DOS_NT
1179 /* We can't signal an Elisp error here; we're in a vfork. Since
1180 the callers check the current directory before forking, this
1181 should only return an error if the directory's permissions
1182 are changed between the check and this chdir, but we should
1183 at least check. */
1184 if (chdir (temp) < 0)
1185 _exit (errno);
1186 #else /* DOS_NT */
1187 /* Get past the drive letter, so that d:/ is left alone. */
1188 if (i > 2 && IS_DEVICE_SEP (temp[1]) && IS_DIRECTORY_SEP (temp[2]))
1190 temp += 2;
1191 i -= 2;
1193 #endif /* DOS_NT */
1195 /* Strip trailing slashes for PWD, but leave "/" and "//" alone. */
1196 while (i > 2 && IS_DIRECTORY_SEP (temp[i - 1]))
1197 temp[--i] = 0;
1200 /* Set `env' to a vector of the strings in the environment. */
1202 register Lisp_Object tem;
1203 register char **new_env;
1204 char **p, **q;
1205 register int new_length;
1206 Lisp_Object display = Qnil;
1208 new_length = 0;
1210 for (tem = Vprocess_environment;
1211 CONSP (tem) && STRINGP (XCAR (tem));
1212 tem = XCDR (tem))
1214 if (strncmp (SSDATA (XCAR (tem)), "DISPLAY", 7) == 0
1215 && (SDATA (XCAR (tem)) [7] == '\0'
1216 || SDATA (XCAR (tem)) [7] == '='))
1217 /* DISPLAY is specified in process-environment. */
1218 display = Qt;
1219 new_length++;
1222 /* If not provided yet, use the frame's DISPLAY. */
1223 if (NILP (display))
1225 Lisp_Object tmp = Fframe_parameter (selected_frame, Qdisplay);
1226 if (!STRINGP (tmp) && CONSP (Vinitial_environment))
1227 /* If still not found, Look for DISPLAY in Vinitial_environment. */
1228 tmp = Fgetenv_internal (build_string ("DISPLAY"),
1229 Vinitial_environment);
1230 if (STRINGP (tmp))
1232 display = tmp;
1233 new_length++;
1237 /* new_length + 2 to include PWD and terminating 0. */
1238 env = new_env = (char **) alloca ((new_length + 2) * sizeof (char *));
1239 /* If we have a PWD envvar, pass one down,
1240 but with corrected value. */
1241 if (egetenv ("PWD"))
1242 *new_env++ = pwd_var;
1244 if (STRINGP (display))
1246 char *vdata = (char *) alloca (sizeof "DISPLAY=" + SBYTES (display));
1247 strcpy (vdata, "DISPLAY=");
1248 strcat (vdata, SSDATA (display));
1249 new_env = add_env (env, new_env, vdata);
1252 /* Overrides. */
1253 for (tem = Vprocess_environment;
1254 CONSP (tem) && STRINGP (XCAR (tem));
1255 tem = XCDR (tem))
1256 new_env = add_env (env, new_env, SSDATA (XCAR (tem)));
1258 *new_env = 0;
1260 /* Remove variable names without values. */
1261 p = q = env;
1262 while (*p != 0)
1264 while (*q != 0 && strchr (*q, '=') == NULL)
1265 q++;
1266 *p = *q++;
1267 if (*p != 0)
1268 p++;
1273 #ifdef WINDOWSNT
1274 prepare_standard_handles (in, out, err, handles);
1275 set_process_dir (SDATA (current_dir));
1276 /* Spawn the child. (See ntproc.c:Spawnve). */
1277 cpid = spawnve (_P_NOWAIT, new_argv[0], new_argv, env);
1278 reset_standard_handles (in, out, err, handles);
1279 if (cpid == -1)
1280 /* An error occurred while trying to spawn the process. */
1281 report_file_error ("Spawning child process", Qnil);
1282 return cpid;
1284 #else /* not WINDOWSNT */
1285 /* Make sure that in, out, and err are not actually already in
1286 descriptors zero, one, or two; this could happen if Emacs is
1287 started with its standard in, out, or error closed, as might
1288 happen under X. */
1290 int oin = in, oout = out;
1292 /* We have to avoid relocating the same descriptor twice! */
1294 in = relocate_fd (in, 3);
1296 if (out == oin)
1297 out = in;
1298 else
1299 out = relocate_fd (out, 3);
1301 if (err == oin)
1302 err = in;
1303 else if (err == oout)
1304 err = out;
1305 else
1306 err = relocate_fd (err, 3);
1309 #ifndef MSDOS
1310 emacs_close (0);
1311 emacs_close (1);
1312 emacs_close (2);
1314 dup2 (in, 0);
1315 dup2 (out, 1);
1316 dup2 (err, 2);
1317 emacs_close (in);
1318 if (out != in)
1319 emacs_close (out);
1320 if (err != in && err != out)
1321 emacs_close (err);
1323 #if defined (USG)
1324 #ifndef SETPGRP_RELEASES_CTTY
1325 setpgrp (); /* No arguments but equivalent in this case */
1326 #endif
1327 #else /* not USG */
1328 setpgrp (pid, pid);
1329 #endif /* not USG */
1331 /* setpgrp_of_tty is incorrect here; it uses input_fd. */
1332 tcsetpgrp (0, pid);
1334 /* execvp does not accept an environment arg so the only way
1335 to pass this environment is to set environ. Our caller
1336 is responsible for restoring the ambient value of environ. */
1337 environ = env;
1338 execvp (new_argv[0], new_argv);
1340 emacs_write (1, "Can't exec program: ", 20);
1341 emacs_write (1, new_argv[0], strlen (new_argv[0]));
1342 emacs_write (1, "\n", 1);
1343 _exit (1);
1345 #else /* MSDOS */
1346 pid = run_msdos_command (new_argv, pwd_var + 4, in, out, err, env);
1347 xfree (pwd_var);
1348 if (pid == -1)
1349 /* An error occurred while trying to run the subprocess. */
1350 report_file_error ("Spawning child process", Qnil);
1351 return pid;
1352 #endif /* MSDOS */
1353 #endif /* not WINDOWSNT */
1356 #ifndef WINDOWSNT
1357 /* Move the file descriptor FD so that its number is not less than MINFD.
1358 If the file descriptor is moved at all, the original is freed. */
1359 static int
1360 relocate_fd (int fd, int minfd)
1362 if (fd >= minfd)
1363 return fd;
1364 else
1366 int new;
1367 #ifdef F_DUPFD
1368 new = fcntl (fd, F_DUPFD, minfd);
1369 #else
1370 new = dup (fd);
1371 if (new != -1)
1372 /* Note that we hold the original FD open while we recurse,
1373 to guarantee we'll get a new FD if we need it. */
1374 new = relocate_fd (new, minfd);
1375 #endif
1376 if (new == -1)
1378 const char *message_1 = "Error while setting up child: ";
1379 const char *errmessage = strerror (errno);
1380 const char *message_2 = "\n";
1381 emacs_write (2, message_1, strlen (message_1));
1382 emacs_write (2, errmessage, strlen (errmessage));
1383 emacs_write (2, message_2, strlen (message_2));
1384 _exit (1);
1386 emacs_close (fd);
1387 return new;
1390 #endif /* not WINDOWSNT */
1392 static int
1393 getenv_internal_1 (const char *var, ptrdiff_t varlen, char **value,
1394 ptrdiff_t *valuelen, Lisp_Object env)
1396 for (; CONSP (env); env = XCDR (env))
1398 Lisp_Object entry = XCAR (env);
1399 if (STRINGP (entry)
1400 && SBYTES (entry) >= varlen
1401 #ifdef WINDOWSNT
1402 /* NT environment variables are case insensitive. */
1403 && ! strnicmp (SDATA (entry), var, varlen)
1404 #else /* not WINDOWSNT */
1405 && ! memcmp (SDATA (entry), var, varlen)
1406 #endif /* not WINDOWSNT */
1409 if (SBYTES (entry) > varlen && SREF (entry, varlen) == '=')
1411 *value = SSDATA (entry) + (varlen + 1);
1412 *valuelen = SBYTES (entry) - (varlen + 1);
1413 return 1;
1415 else if (SBYTES (entry) == varlen)
1417 /* Lone variable names in Vprocess_environment mean that
1418 variable should be removed from the environment. */
1419 *value = NULL;
1420 return 1;
1424 return 0;
1427 static int
1428 getenv_internal (const char *var, ptrdiff_t varlen, char **value,
1429 ptrdiff_t *valuelen, Lisp_Object frame)
1431 /* Try to find VAR in Vprocess_environment first. */
1432 if (getenv_internal_1 (var, varlen, value, valuelen,
1433 Vprocess_environment))
1434 return *value ? 1 : 0;
1436 /* For DISPLAY try to get the values from the frame or the initial env. */
1437 if (strcmp (var, "DISPLAY") == 0)
1439 Lisp_Object display
1440 = Fframe_parameter (NILP (frame) ? selected_frame : frame, Qdisplay);
1441 if (STRINGP (display))
1443 *value = SSDATA (display);
1444 *valuelen = SBYTES (display);
1445 return 1;
1447 /* If still not found, Look for DISPLAY in Vinitial_environment. */
1448 if (getenv_internal_1 (var, varlen, value, valuelen,
1449 Vinitial_environment))
1450 return *value ? 1 : 0;
1453 return 0;
1456 DEFUN ("getenv-internal", Fgetenv_internal, Sgetenv_internal, 1, 2, 0,
1457 doc: /* Get the value of environment variable VARIABLE.
1458 VARIABLE should be a string. Value is nil if VARIABLE is undefined in
1459 the environment. Otherwise, value is a string.
1461 This function searches `process-environment' for VARIABLE.
1463 If optional parameter ENV is a list, then search this list instead of
1464 `process-environment', and return t when encountering a negative entry
1465 \(an entry for a variable with no value). */)
1466 (Lisp_Object variable, Lisp_Object env)
1468 char *value;
1469 ptrdiff_t valuelen;
1471 CHECK_STRING (variable);
1472 if (CONSP (env))
1474 if (getenv_internal_1 (SSDATA (variable), SBYTES (variable),
1475 &value, &valuelen, env))
1476 return value ? make_string (value, valuelen) : Qt;
1477 else
1478 return Qnil;
1480 else if (getenv_internal (SSDATA (variable), SBYTES (variable),
1481 &value, &valuelen, env))
1482 return make_string (value, valuelen);
1483 else
1484 return Qnil;
1487 /* A version of getenv that consults the Lisp environment lists,
1488 easily callable from C. */
1489 char *
1490 egetenv (const char *var)
1492 char *value;
1493 ptrdiff_t valuelen;
1495 if (getenv_internal (var, strlen (var), &value, &valuelen, Qnil))
1496 return value;
1497 else
1498 return 0;
1502 /* This is run before init_cmdargs. */
1504 void
1505 init_callproc_1 (void)
1507 char *data_dir = egetenv ("EMACSDATA");
1508 char *doc_dir = egetenv ("EMACSDOC");
1510 Vdata_directory
1511 = Ffile_name_as_directory (build_string (data_dir ? data_dir
1512 : PATH_DATA));
1513 Vdoc_directory
1514 = Ffile_name_as_directory (build_string (doc_dir ? doc_dir
1515 : PATH_DOC));
1517 /* Check the EMACSPATH environment variable, defaulting to the
1518 PATH_EXEC path from epaths.h. */
1519 Vexec_path = decode_env_path ("EMACSPATH", PATH_EXEC);
1520 Vexec_directory = Ffile_name_as_directory (Fcar (Vexec_path));
1521 Vexec_path = nconc2 (decode_env_path ("PATH", ""), Vexec_path);
1524 /* This is run after init_cmdargs, when Vinstallation_directory is valid. */
1526 void
1527 init_callproc (void)
1529 char *data_dir = egetenv ("EMACSDATA");
1531 register char * sh;
1532 Lisp_Object tempdir;
1534 if (!NILP (Vinstallation_directory))
1536 /* Add to the path the lib-src subdir of the installation dir. */
1537 Lisp_Object tem;
1538 tem = Fexpand_file_name (build_string ("lib-src"),
1539 Vinstallation_directory);
1540 #ifndef DOS_NT
1541 /* MSDOS uses wrapped binaries, so don't do this. */
1542 if (NILP (Fmember (tem, Vexec_path)))
1544 Vexec_path = decode_env_path ("EMACSPATH", PATH_EXEC);
1545 Vexec_path = Fcons (tem, Vexec_path);
1546 Vexec_path = nconc2 (decode_env_path ("PATH", ""), Vexec_path);
1549 Vexec_directory = Ffile_name_as_directory (tem);
1550 #endif /* not DOS_NT */
1552 /* Maybe use ../etc as well as ../lib-src. */
1553 if (data_dir == 0)
1555 tem = Fexpand_file_name (build_string ("etc"),
1556 Vinstallation_directory);
1557 Vdoc_directory = Ffile_name_as_directory (tem);
1561 /* Look for the files that should be in etc. We don't use
1562 Vinstallation_directory, because these files are never installed
1563 near the executable, and they are never in the build
1564 directory when that's different from the source directory.
1566 Instead, if these files are not in the nominal place, we try the
1567 source directory. */
1568 if (data_dir == 0)
1570 Lisp_Object tem, tem1, srcdir;
1572 srcdir = Fexpand_file_name (build_string ("../src/"),
1573 build_string (PATH_DUMPLOADSEARCH));
1574 tem = Fexpand_file_name (build_string ("GNU"), Vdata_directory);
1575 tem1 = Ffile_exists_p (tem);
1576 if (!NILP (Fequal (srcdir, Vinvocation_directory)) || NILP (tem1))
1578 Lisp_Object newdir;
1579 newdir = Fexpand_file_name (build_string ("../etc/"),
1580 build_string (PATH_DUMPLOADSEARCH));
1581 tem = Fexpand_file_name (build_string ("GNU"), newdir);
1582 tem1 = Ffile_exists_p (tem);
1583 if (!NILP (tem1))
1584 Vdata_directory = newdir;
1588 #ifndef CANNOT_DUMP
1589 if (initialized)
1590 #endif
1592 tempdir = Fdirectory_file_name (Vexec_directory);
1593 if (access (SSDATA (tempdir), 0) < 0)
1594 dir_warning ("Warning: arch-dependent data dir (%s) does not exist.\n",
1595 Vexec_directory);
1598 tempdir = Fdirectory_file_name (Vdata_directory);
1599 if (access (SSDATA (tempdir), 0) < 0)
1600 dir_warning ("Warning: arch-independent data dir (%s) does not exist.\n",
1601 Vdata_directory);
1603 sh = (char *) getenv ("SHELL");
1604 Vshell_file_name = build_string (sh ? sh : "/bin/sh");
1606 #ifdef DOS_NT
1607 Vshared_game_score_directory = Qnil;
1608 #else
1609 Vshared_game_score_directory = build_string (PATH_GAME);
1610 if (NILP (Ffile_directory_p (Vshared_game_score_directory)))
1611 Vshared_game_score_directory = Qnil;
1612 #endif
1615 void
1616 set_initial_environment (void)
1618 char **envp;
1619 for (envp = environ; *envp; envp++)
1620 Vprocess_environment = Fcons (build_string (*envp),
1621 Vprocess_environment);
1622 /* Ideally, the `copy' shouldn't be necessary, but it seems it's frequent
1623 to use `delete' and friends on process-environment. */
1624 Vinitial_environment = Fcopy_sequence (Vprocess_environment);
1627 void
1628 syms_of_callproc (void)
1630 #ifndef DOS_NT
1631 Vtemp_file_name_pattern = build_string ("emacsXXXXXX");
1632 #elif defined (WINDOWSNT)
1633 Vtemp_file_name_pattern = build_string ("emXXXXXX");
1634 #else
1635 Vtemp_file_name_pattern = build_string ("detmp.XXX");
1636 #endif
1637 staticpro (&Vtemp_file_name_pattern);
1639 DEFVAR_LISP ("shell-file-name", Vshell_file_name,
1640 doc: /* *File name to load inferior shells from.
1641 Initialized from the SHELL environment variable, or to a system-dependent
1642 default if SHELL is not set. */);
1644 DEFVAR_LISP ("exec-path", Vexec_path,
1645 doc: /* *List of directories to search programs to run in subprocesses.
1646 Each element is a string (directory name) or nil (try default directory). */);
1648 DEFVAR_LISP ("exec-suffixes", Vexec_suffixes,
1649 doc: /* *List of suffixes to try to find executable file names.
1650 Each element is a string. */);
1651 Vexec_suffixes = Qnil;
1653 DEFVAR_LISP ("exec-directory", Vexec_directory,
1654 doc: /* Directory for executables for Emacs to invoke.
1655 More generally, this includes any architecture-dependent files
1656 that are built and installed from the Emacs distribution. */);
1658 DEFVAR_LISP ("data-directory", Vdata_directory,
1659 doc: /* Directory of machine-independent files that come with GNU Emacs.
1660 These are files intended for Emacs to use while it runs. */);
1662 DEFVAR_LISP ("doc-directory", Vdoc_directory,
1663 doc: /* Directory containing the DOC file that comes with GNU Emacs.
1664 This is usually the same as `data-directory'. */);
1666 DEFVAR_LISP ("configure-info-directory", Vconfigure_info_directory,
1667 doc: /* For internal use by the build procedure only.
1668 This is the name of the directory in which the build procedure installed
1669 Emacs's info files; the default value for `Info-default-directory-list'
1670 includes this. */);
1671 Vconfigure_info_directory = build_string (PATH_INFO);
1673 DEFVAR_LISP ("shared-game-score-directory", Vshared_game_score_directory,
1674 doc: /* Directory of score files for games which come with GNU Emacs.
1675 If this variable is nil, then Emacs is unable to use a shared directory. */);
1676 #ifdef DOS_NT
1677 Vshared_game_score_directory = Qnil;
1678 #else
1679 Vshared_game_score_directory = build_string (PATH_GAME);
1680 #endif
1682 DEFVAR_LISP ("initial-environment", Vinitial_environment,
1683 doc: /* List of environment variables inherited from the parent process.
1684 Each element should be a string of the form ENVVARNAME=VALUE.
1685 The elements must normally be decoded (using `locale-coding-system') for use. */);
1686 Vinitial_environment = Qnil;
1688 DEFVAR_LISP ("process-environment", Vprocess_environment,
1689 doc: /* List of overridden environment variables for subprocesses to inherit.
1690 Each element should be a string of the form ENVVARNAME=VALUE.
1692 Entries in this list take precedence to those in the frame-local
1693 environments. Therefore, let-binding `process-environment' is an easy
1694 way to temporarily change the value of an environment variable,
1695 irrespective of where it comes from. To use `process-environment' to
1696 remove an environment variable, include only its name in the list,
1697 without "=VALUE".
1699 This variable is set to nil when Emacs starts.
1701 If multiple entries define the same variable, the first one always
1702 takes precedence.
1704 Non-ASCII characters are encoded according to the initial value of
1705 `locale-coding-system', i.e. the elements must normally be decoded for
1706 use.
1708 See `setenv' and `getenv'. */);
1709 Vprocess_environment = Qnil;
1711 defsubr (&Scall_process);
1712 defsubr (&Sgetenv_internal);
1713 defsubr (&Scall_process_region);