Fix typos.
[emacs.git] / src / callproc.c
blob01772efce3015a4f3599caaebef9103d90949625
1 /* Synchronous subprocess invocation for GNU Emacs.
2 Copyright (C) 1985-1988, 1993-1995, 1999-2011
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 BUFFER can also have the form (REAL-BUFFER STDERR-FILE); in that case,
169 REAL-BUFFER says what to do with standard output, as above,
170 while STDERR-FILE says what to do with standard error in the child.
171 STDERR-FILE may be nil (discard standard error output),
172 t (mix it with ordinary output), or a file name string.
174 Fourth arg DISPLAY non-nil means redisplay buffer as output is inserted.
175 Remaining arguments are strings passed as command arguments to PROGRAM.
177 If executable PROGRAM can't be found as an executable, `call-process'
178 signals a Lisp error. `call-process' reports errors in execution of
179 the program only through its return and output.
181 If BUFFER is 0, `call-process' returns immediately with value nil.
182 Otherwise it waits for PROGRAM to terminate
183 and returns a numeric exit status or a signal description string.
184 If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.
186 usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS) */)
187 (ptrdiff_t nargs, Lisp_Object *args)
189 Lisp_Object infile, buffer, current_dir, path;
190 volatile int display_p_volatile;
191 int fd[2];
192 int filefd;
193 register int pid;
194 #define CALLPROC_BUFFER_SIZE_MIN (16 * 1024)
195 #define CALLPROC_BUFFER_SIZE_MAX (4 * CALLPROC_BUFFER_SIZE_MIN)
196 char buf[CALLPROC_BUFFER_SIZE_MAX];
197 int bufsize = CALLPROC_BUFFER_SIZE_MIN;
198 int count = SPECPDL_INDEX ();
199 volatile USE_SAFE_ALLOCA;
201 register const unsigned char **new_argv;
202 /* File to use for stderr in the child.
203 t means use same as standard output. */
204 Lisp_Object error_file;
205 Lisp_Object output_file = Qnil;
206 #ifdef MSDOS /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
207 char *outf, *tempfile = NULL;
208 int outfilefd;
209 #endif
210 int fd_output = -1;
211 struct coding_system process_coding; /* coding-system of process output */
212 struct coding_system argument_coding; /* coding-system of arguments */
213 /* Set to the return value of Ffind_operation_coding_system. */
214 Lisp_Object coding_systems;
215 int output_to_buffer = 1;
217 /* Qt denotes that Ffind_operation_coding_system is not yet called. */
218 coding_systems = Qt;
220 CHECK_STRING (args[0]);
222 error_file = Qt;
224 #ifndef subprocesses
225 /* Without asynchronous processes we cannot have BUFFER == 0. */
226 if (nargs >= 3
227 && (INTEGERP (CONSP (args[2]) ? XCAR (args[2]) : args[2])))
228 error ("Operating system cannot handle asynchronous subprocesses");
229 #endif /* subprocesses */
231 /* Decide the coding-system for giving arguments. */
233 Lisp_Object val, *args2;
234 ptrdiff_t i;
236 /* If arguments are supplied, we may have to encode them. */
237 if (nargs >= 5)
239 int must_encode = 0;
240 Lisp_Object coding_attrs;
242 for (i = 4; i < nargs; i++)
243 CHECK_STRING (args[i]);
245 for (i = 4; i < nargs; i++)
246 if (STRING_MULTIBYTE (args[i]))
247 must_encode = 1;
249 if (!NILP (Vcoding_system_for_write))
250 val = Vcoding_system_for_write;
251 else if (! must_encode)
252 val = Qraw_text;
253 else
255 SAFE_NALLOCA (args2, 1, nargs + 1);
256 args2[0] = Qcall_process;
257 for (i = 0; i < nargs; i++) args2[i + 1] = args[i];
258 coding_systems = Ffind_operation_coding_system (nargs + 1, args2);
259 val = CONSP (coding_systems) ? XCDR (coding_systems) : Qnil;
261 val = complement_process_encoding_system (val);
262 setup_coding_system (Fcheck_coding_system (val), &argument_coding);
263 coding_attrs = CODING_ID_ATTRS (argument_coding.id);
264 if (NILP (CODING_ATTR_ASCII_COMPAT (coding_attrs)))
266 /* We should not use an ASCII incompatible coding system. */
267 val = raw_text_coding_system (val);
268 setup_coding_system (val, &argument_coding);
273 if (nargs >= 2 && ! NILP (args[1]))
275 infile = Fexpand_file_name (args[1], BVAR (current_buffer, directory));
276 CHECK_STRING (infile);
278 else
279 infile = build_string (NULL_DEVICE);
281 if (nargs >= 3)
283 buffer = args[2];
285 /* If BUFFER is a list, its meaning is (BUFFER-FOR-STDOUT
286 FILE-FOR-STDERR), unless the first element is :file, in which case see
287 the next paragraph. */
288 if (CONSP (buffer)
289 && (! SYMBOLP (XCAR (buffer))
290 || strcmp (SSDATA (SYMBOL_NAME (XCAR (buffer))), ":file")))
292 if (CONSP (XCDR (buffer)))
294 Lisp_Object stderr_file;
295 stderr_file = XCAR (XCDR (buffer));
297 if (NILP (stderr_file) || EQ (Qt, stderr_file))
298 error_file = stderr_file;
299 else
300 error_file = Fexpand_file_name (stderr_file, Qnil);
303 buffer = XCAR (buffer);
306 /* If the buffer is (still) a list, it might be a (:file "file") spec. */
307 if (CONSP (buffer)
308 && SYMBOLP (XCAR (buffer))
309 && ! strcmp (SSDATA (SYMBOL_NAME (XCAR (buffer))), ":file"))
311 output_file = Fexpand_file_name (XCAR (XCDR (buffer)),
312 BVAR (current_buffer, directory));
313 CHECK_STRING (output_file);
314 buffer = Qnil;
317 if (!(EQ (buffer, Qnil)
318 || EQ (buffer, Qt)
319 || INTEGERP (buffer)))
321 Lisp_Object spec_buffer;
322 spec_buffer = buffer;
323 buffer = Fget_buffer_create (buffer);
324 /* Mention the buffer name for a better error message. */
325 if (NILP (buffer))
326 CHECK_BUFFER (spec_buffer);
327 CHECK_BUFFER (buffer);
330 else
331 buffer = Qnil;
333 /* Make sure that the child will be able to chdir to the current
334 buffer's current directory, or its unhandled equivalent. We
335 can't just have the child check for an error when it does the
336 chdir, since it's in a vfork.
338 We have to GCPRO around this because Fexpand_file_name,
339 Funhandled_file_name_directory, and Ffile_accessible_directory_p
340 might call a file name handling function. The argument list is
341 protected by the caller, so all we really have to worry about is
342 buffer. */
344 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
346 current_dir = BVAR (current_buffer, directory);
348 GCPRO5 (infile, buffer, current_dir, error_file, output_file);
350 current_dir = Funhandled_file_name_directory (current_dir);
351 if (NILP (current_dir))
352 /* If the file name handler says that current_dir is unreachable, use
353 a sensible default. */
354 current_dir = build_string ("~/");
355 current_dir = expand_and_dir_to_file (current_dir, Qnil);
356 current_dir = Ffile_name_as_directory (current_dir);
358 if (NILP (Ffile_accessible_directory_p (current_dir)))
359 report_file_error ("Setting current directory",
360 Fcons (BVAR (current_buffer, directory), Qnil));
362 if (STRING_MULTIBYTE (infile))
363 infile = ENCODE_FILE (infile);
364 if (STRING_MULTIBYTE (current_dir))
365 current_dir = ENCODE_FILE (current_dir);
366 if (STRINGP (error_file) && STRING_MULTIBYTE (error_file))
367 error_file = ENCODE_FILE (error_file);
368 if (STRINGP (output_file) && STRING_MULTIBYTE (output_file))
369 output_file = ENCODE_FILE (output_file);
370 UNGCPRO;
373 display_p_volatile = INTERACTIVE && nargs >= 4 && !NILP (args[3]);
375 filefd = emacs_open (SSDATA (infile), O_RDONLY, 0);
376 if (filefd < 0)
378 infile = DECODE_FILE (infile);
379 report_file_error ("Opening process input file", Fcons (infile, Qnil));
382 if (STRINGP (output_file))
384 #ifdef DOS_NT
385 fd_output = emacs_open (SSDATA (output_file),
386 O_WRONLY | O_TRUNC | O_CREAT | O_TEXT,
387 S_IREAD | S_IWRITE);
388 #else /* not DOS_NT */
389 fd_output = creat (SSDATA (output_file), 0666);
390 #endif /* not DOS_NT */
391 if (fd_output < 0)
393 output_file = DECODE_FILE (output_file);
394 report_file_error ("Opening process output file",
395 Fcons (output_file, Qnil));
397 if (STRINGP (error_file) || NILP (error_file))
398 output_to_buffer = 0;
401 /* Search for program; barf if not found. */
403 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
405 GCPRO4 (infile, buffer, current_dir, error_file);
406 openp (Vexec_path, args[0], Vexec_suffixes, &path, make_number (X_OK));
407 UNGCPRO;
409 if (NILP (path))
411 emacs_close (filefd);
412 report_file_error ("Searching for program", Fcons (args[0], Qnil));
415 /* If program file name starts with /: for quoting a magic name,
416 discard that. */
417 if (SBYTES (path) > 2 && SREF (path, 0) == '/'
418 && SREF (path, 1) == ':')
419 path = Fsubstring (path, make_number (2), Qnil);
421 SAFE_ALLOCA (new_argv, const unsigned char **,
422 (nargs > 4 ? nargs - 2 : 2) * sizeof *new_argv);
423 if (nargs > 4)
425 ptrdiff_t i;
426 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
428 GCPRO5 (infile, buffer, current_dir, path, error_file);
429 argument_coding.dst_multibyte = 0;
430 for (i = 4; i < nargs; i++)
432 argument_coding.src_multibyte = STRING_MULTIBYTE (args[i]);
433 if (CODING_REQUIRE_ENCODING (&argument_coding))
434 /* We must encode this argument. */
435 args[i] = encode_coding_string (&argument_coding, args[i], 1);
437 UNGCPRO;
438 for (i = 4; i < nargs; i++)
439 new_argv[i - 3] = SDATA (args[i]);
440 new_argv[i - 3] = 0;
442 else
443 new_argv[1] = 0;
444 new_argv[0] = SDATA (path);
446 #ifdef MSDOS /* MW, July 1993 */
448 /* If we're redirecting STDOUT to a file, that file is already open
449 on fd_output. */
450 if (fd_output < 0)
452 if ((outf = egetenv ("TMPDIR")))
453 strcpy (tempfile = alloca (strlen (outf) + 20), outf);
454 else
456 tempfile = alloca (20);
457 *tempfile = '\0';
459 dostounix_filename (tempfile);
460 if (*tempfile == '\0' || tempfile[strlen (tempfile) - 1] != '/')
461 strcat (tempfile, "/");
462 strcat (tempfile, "detmp.XXX");
463 mktemp (tempfile);
464 outfilefd = creat (tempfile, S_IREAD | S_IWRITE);
465 if (outfilefd < 0) {
466 emacs_close (filefd);
467 report_file_error ("Opening process output file",
468 Fcons (build_string (tempfile), Qnil));
471 else
472 outfilefd = fd_output;
473 fd[0] = filefd;
474 fd[1] = outfilefd;
475 #endif /* MSDOS */
477 if (INTEGERP (buffer))
478 fd[1] = emacs_open (NULL_DEVICE, O_WRONLY, 0), fd[0] = -1;
479 else
481 #ifndef MSDOS
482 errno = 0;
483 if (pipe (fd) == -1)
485 emacs_close (filefd);
486 report_file_error ("Creating process pipe", Qnil);
488 #endif
492 /* child_setup must clobber environ in systems with true vfork.
493 Protect it from permanent change. */
494 register char **save_environ = environ;
495 register int fd1 = fd[1];
496 int fd_error = fd1;
497 #ifdef HAVE_WORKING_VFORK
498 sigset_t procmask;
499 sigset_t blocked;
500 struct sigaction sigpipe_action;
501 #endif
503 if (fd_output >= 0)
504 fd1 = fd_output;
505 #if 0 /* Some systems don't have sigblock. */
506 mask = sigblock (sigmask (SIGCHLD));
507 #endif
509 /* Record that we're about to create a synchronous process. */
510 synch_process_alive = 1;
512 /* These vars record information from process termination.
513 Clear them now before process can possibly terminate,
514 to avoid timing error if process terminates soon. */
515 synch_process_death = 0;
516 synch_process_retcode = 0;
517 synch_process_termsig = 0;
519 if (NILP (error_file))
520 fd_error = emacs_open (NULL_DEVICE, O_WRONLY, 0);
521 else if (STRINGP (error_file))
523 #ifdef DOS_NT
524 fd_error = emacs_open (SSDATA (error_file),
525 O_WRONLY | O_TRUNC | O_CREAT | O_TEXT,
526 S_IREAD | S_IWRITE);
527 #else /* not DOS_NT */
528 fd_error = creat (SSDATA (error_file), 0666);
529 #endif /* not DOS_NT */
532 if (fd_error < 0)
534 emacs_close (filefd);
535 if (fd[0] != filefd)
536 emacs_close (fd[0]);
537 if (fd1 >= 0)
538 emacs_close (fd1);
539 #ifdef MSDOS
540 unlink (tempfile);
541 #endif
542 if (NILP (error_file))
543 error_file = build_string (NULL_DEVICE);
544 else if (STRINGP (error_file))
545 error_file = DECODE_FILE (error_file);
546 report_file_error ("Cannot redirect stderr", Fcons (error_file, Qnil));
549 #ifdef MSDOS /* MW, July 1993 */
550 /* Note that on MSDOS `child_setup' actually returns the child process
551 exit status, not its PID, so we assign it to `synch_process_retcode'
552 below. */
553 pid = child_setup (filefd, outfilefd, fd_error, (char **) new_argv,
554 0, current_dir);
556 /* Record that the synchronous process exited and note its
557 termination status. */
558 synch_process_alive = 0;
559 synch_process_retcode = pid;
560 if (synch_process_retcode < 0) /* means it couldn't be exec'ed */
562 synchronize_system_messages_locale ();
563 synch_process_death = strerror (errno);
566 emacs_close (outfilefd);
567 if (fd_error != outfilefd)
568 emacs_close (fd_error);
569 fd1 = -1; /* No harm in closing that one! */
570 if (tempfile)
572 /* Since CRLF is converted to LF within `decode_coding', we
573 can always open a file with binary mode. */
574 fd[0] = emacs_open (tempfile, O_RDONLY | O_BINARY, 0);
575 if (fd[0] < 0)
577 unlink (tempfile);
578 emacs_close (filefd);
579 report_file_error ("Cannot re-open temporary file",
580 Fcons (build_string (tempfile), Qnil));
583 else
584 fd[0] = -1; /* We are not going to read from tempfile. */
585 #else /* not MSDOS */
586 #ifdef WINDOWSNT
587 pid = child_setup (filefd, fd1, fd_error, (char **) new_argv,
588 0, current_dir);
589 #else /* not WINDOWSNT */
591 #ifdef HAVE_WORKING_VFORK
592 /* On many hosts (e.g. Solaris 2.4), if a vforked child calls `signal',
593 this sets the parent's signal handlers as well as the child's.
594 So delay all interrupts whose handlers the child might munge,
595 and record the current handlers so they can be restored later. */
596 sigemptyset (&blocked);
597 sigaddset (&blocked, SIGPIPE);
598 sigaction (SIGPIPE, 0, &sigpipe_action);
599 pthread_sigmask (SIG_BLOCK, &blocked, &procmask);
600 #endif
602 BLOCK_INPUT;
604 /* vfork, and prevent local vars from being clobbered by the vfork. */
606 Lisp_Object volatile buffer_volatile = buffer;
607 Lisp_Object volatile coding_systems_volatile = coding_systems;
608 Lisp_Object volatile current_dir_volatile = current_dir;
609 int volatile fd1_volatile = fd1;
610 int volatile fd_error_volatile = fd_error;
611 int volatile fd_output_volatile = fd_output;
612 int volatile output_to_buffer_volatile = output_to_buffer;
613 unsigned char const **volatile new_argv_volatile = new_argv;
615 pid = vfork ();
617 buffer = buffer_volatile;
618 coding_systems = coding_systems_volatile;
619 current_dir = current_dir_volatile;
620 fd1 = fd1_volatile;
621 fd_error = fd_error_volatile;
622 fd_output = fd_output_volatile;
623 output_to_buffer = output_to_buffer_volatile;
624 new_argv = new_argv_volatile;
627 if (pid == 0)
629 if (fd[0] >= 0)
630 emacs_close (fd[0]);
631 #ifdef HAVE_SETSID
632 setsid ();
633 #endif
634 #if defined (USG)
635 setpgrp ();
636 #else
637 setpgrp (pid, pid);
638 #endif /* USG */
640 /* GConf causes us to ignore SIGPIPE, make sure it is restored
641 in the child. */
642 //signal (SIGPIPE, SIG_DFL);
643 #ifdef HAVE_WORKING_VFORK
644 pthread_sigmask (SIG_SETMASK, &procmask, 0);
645 #endif
647 child_setup (filefd, fd1, fd_error, (char **) new_argv,
648 0, current_dir);
651 UNBLOCK_INPUT;
653 #ifdef HAVE_WORKING_VFORK
654 /* Restore the signal state. */
655 sigaction (SIGPIPE, &sigpipe_action, 0);
656 pthread_sigmask (SIG_SETMASK, &procmask, 0);
657 #endif
659 #endif /* not WINDOWSNT */
661 /* The MSDOS case did this already. */
662 if (fd_error >= 0)
663 emacs_close (fd_error);
664 #endif /* not MSDOS */
666 environ = save_environ;
668 /* Close most of our fd's, but not fd[0]
669 since we will use that to read input from. */
670 emacs_close (filefd);
671 if (fd_output >= 0)
672 emacs_close (fd_output);
673 if (fd1 >= 0 && fd1 != fd_error)
674 emacs_close (fd1);
677 if (pid < 0)
679 if (fd[0] >= 0)
680 emacs_close (fd[0]);
681 report_file_error ("Doing vfork", Qnil);
684 if (INTEGERP (buffer))
686 if (fd[0] >= 0)
687 emacs_close (fd[0]);
688 return Qnil;
691 /* Enable sending signal if user quits below. */
692 call_process_exited = 0;
694 #if defined (MSDOS)
695 /* MSDOS needs different cleanup information. */
696 record_unwind_protect (call_process_cleanup,
697 Fcons (Fcurrent_buffer (),
698 Fcons (make_number (fd[0]),
699 build_string (tempfile ? tempfile : ""))));
700 #else
701 record_unwind_protect (call_process_cleanup,
702 Fcons (Fcurrent_buffer (),
703 Fcons (make_number (fd[0]), make_number (pid))));
704 #endif /* not MSDOS */
707 if (BUFFERP (buffer))
708 Fset_buffer (buffer);
710 if (NILP (buffer))
712 /* If BUFFER is nil, we must read process output once and then
713 discard it, so setup coding system but with nil. */
714 setup_coding_system (Qnil, &process_coding);
715 process_coding.dst_multibyte = 0;
717 else
719 Lisp_Object val, *args2;
721 val = Qnil;
722 if (!NILP (Vcoding_system_for_read))
723 val = Vcoding_system_for_read;
724 else
726 if (EQ (coding_systems, Qt))
728 ptrdiff_t i;
730 SAFE_NALLOCA (args2, 1, nargs + 1);
731 args2[0] = Qcall_process;
732 for (i = 0; i < nargs; i++) args2[i + 1] = args[i];
733 coding_systems
734 = Ffind_operation_coding_system (nargs + 1, args2);
736 if (CONSP (coding_systems))
737 val = XCAR (coding_systems);
738 else if (CONSP (Vdefault_process_coding_system))
739 val = XCAR (Vdefault_process_coding_system);
740 else
741 val = Qnil;
743 Fcheck_coding_system (val);
744 /* In unibyte mode, character code conversion should not take
745 place but EOL conversion should. So, setup raw-text or one
746 of the subsidiary according to the information just setup. */
747 if (NILP (BVAR (current_buffer, enable_multibyte_characters))
748 && !NILP (val))
749 val = raw_text_coding_system (val);
750 setup_coding_system (val, &process_coding);
751 process_coding.dst_multibyte
752 = ! NILP (BVAR (current_buffer, enable_multibyte_characters));
754 process_coding.src_multibyte = 0;
756 immediate_quit = 1;
757 QUIT;
759 if (output_to_buffer)
761 register EMACS_INT nread;
762 int first = 1;
763 EMACS_INT total_read = 0;
764 int carryover = 0;
765 int display_p = display_p_volatile;
766 int display_on_the_fly = display_p;
767 struct coding_system saved_coding;
769 saved_coding = process_coding;
770 while (1)
772 /* Repeatedly read until we've filled as much as possible
773 of the buffer size we have. But don't read
774 less than 1024--save that for the next bufferful. */
775 nread = carryover;
776 while (nread < bufsize - 1024)
778 int this_read = emacs_read (fd[0], buf + nread,
779 bufsize - nread);
781 if (this_read < 0)
782 goto give_up;
784 if (this_read == 0)
786 process_coding.mode |= CODING_MODE_LAST_BLOCK;
787 break;
790 nread += this_read;
791 total_read += this_read;
793 if (display_on_the_fly)
794 break;
797 /* Now NREAD is the total amount of data in the buffer. */
798 immediate_quit = 0;
800 if (!NILP (buffer))
802 if (NILP (BVAR (current_buffer, enable_multibyte_characters))
803 && ! CODING_MAY_REQUIRE_DECODING (&process_coding))
804 insert_1_both (buf, nread, nread, 0, 1, 0);
805 else
806 { /* We have to decode the input. */
807 Lisp_Object curbuf;
808 int count1 = SPECPDL_INDEX ();
810 XSETBUFFER (curbuf, current_buffer);
811 /* We cannot allow after-change-functions be run
812 during decoding, because that might modify the
813 buffer, while we rely on process_coding.produced to
814 faithfully reflect inserted text until we
815 TEMP_SET_PT_BOTH below. */
816 specbind (Qinhibit_modification_hooks, Qt);
817 decode_coding_c_string (&process_coding,
818 (unsigned char *) buf, nread, curbuf);
819 unbind_to (count1, Qnil);
820 if (display_on_the_fly
821 && CODING_REQUIRE_DETECTION (&saved_coding)
822 && ! CODING_REQUIRE_DETECTION (&process_coding))
824 /* We have detected some coding system. But,
825 there's a possibility that the detection was
826 done by insufficient data. So, we give up
827 displaying on the fly. */
828 if (process_coding.produced > 0)
829 del_range_2 (process_coding.dst_pos,
830 process_coding.dst_pos_byte,
831 process_coding.dst_pos
832 + process_coding.produced_char,
833 process_coding.dst_pos_byte
834 + process_coding.produced, 0);
835 display_on_the_fly = 0;
836 process_coding = saved_coding;
837 carryover = nread;
838 /* This is to make the above condition always
839 fails in the future. */
840 saved_coding.common_flags
841 &= ~CODING_REQUIRE_DETECTION_MASK;
842 continue;
845 TEMP_SET_PT_BOTH (PT + process_coding.produced_char,
846 PT_BYTE + process_coding.produced);
847 carryover = process_coding.carryover_bytes;
848 if (carryover > 0)
849 memcpy (buf, process_coding.carryover,
850 process_coding.carryover_bytes);
854 if (process_coding.mode & CODING_MODE_LAST_BLOCK)
855 break;
857 /* Make the buffer bigger as we continue to read more data,
858 but not past CALLPROC_BUFFER_SIZE_MAX. */
859 if (bufsize < CALLPROC_BUFFER_SIZE_MAX && total_read > 32 * bufsize)
860 if ((bufsize *= 2) > CALLPROC_BUFFER_SIZE_MAX)
861 bufsize = CALLPROC_BUFFER_SIZE_MAX;
863 if (display_p)
865 if (first)
866 prepare_menu_bars ();
867 first = 0;
868 redisplay_preserve_echo_area (1);
869 /* This variable might have been set to 0 for code
870 detection. In that case, we set it back to 1 because
871 we should have already detected a coding system. */
872 display_on_the_fly = 1;
874 immediate_quit = 1;
875 QUIT;
877 give_up: ;
879 Vlast_coding_system_used = CODING_ID_NAME (process_coding.id);
880 /* If the caller required, let the buffer inherit the
881 coding-system used to decode the process output. */
882 if (inherit_process_coding_system)
883 call1 (intern ("after-insert-file-set-buffer-file-coding-system"),
884 make_number (total_read));
887 #ifndef MSDOS
888 /* Wait for it to terminate, unless it already has. */
889 if (output_to_buffer)
890 wait_for_termination (pid);
891 else
892 interruptible_wait_for_termination (pid);
893 #endif
895 immediate_quit = 0;
897 /* Don't kill any children that the subprocess may have left behind
898 when exiting. */
899 call_process_exited = 1;
901 SAFE_FREE ();
902 unbind_to (count, Qnil);
904 if (synch_process_termsig)
906 const char *signame;
908 synchronize_system_messages_locale ();
909 signame = strsignal (synch_process_termsig);
911 if (signame == 0)
912 signame = "unknown";
914 synch_process_death = signame;
917 if (synch_process_death)
918 return code_convert_string_norecord (build_string (synch_process_death),
919 Vlocale_coding_system, 0);
920 return make_number (synch_process_retcode);
923 static Lisp_Object
924 delete_temp_file (Lisp_Object name)
926 /* Suppress jka-compr handling, etc. */
927 int count = SPECPDL_INDEX ();
928 specbind (intern ("file-name-handler-alist"), Qnil);
929 internal_delete_file (name);
930 unbind_to (count, Qnil);
931 return Qnil;
934 DEFUN ("call-process-region", Fcall_process_region, Scall_process_region,
935 3, MANY, 0,
936 doc: /* Send text from START to END to a synchronous process running PROGRAM.
937 The remaining arguments are optional.
938 Delete the text if fourth arg DELETE is non-nil.
940 Insert output in BUFFER before point; t means current buffer; nil for
941 BUFFER means discard it; 0 means discard and don't wait; and `(:file
942 FILE)', where FILE is a file name string, means that it should be
943 written to that file.
944 BUFFER can also have the form (REAL-BUFFER STDERR-FILE); in that case,
945 REAL-BUFFER says what to do with standard output, as above,
946 while STDERR-FILE says what to do with standard error in the child.
947 STDERR-FILE may be nil (discard standard error output),
948 t (mix it with ordinary output), or a file name string.
950 Sixth arg DISPLAY non-nil means redisplay buffer as output is inserted.
951 Remaining args are passed to PROGRAM at startup as command args.
953 If BUFFER is 0, `call-process-region' returns immediately with value nil.
954 Otherwise it waits for PROGRAM to terminate
955 and returns a numeric exit status or a signal description string.
956 If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.
958 usage: (call-process-region START END PROGRAM &optional DELETE BUFFER DISPLAY &rest ARGS) */)
959 (ptrdiff_t nargs, Lisp_Object *args)
961 struct gcpro gcpro1;
962 Lisp_Object filename_string;
963 register Lisp_Object start, end;
964 int count = SPECPDL_INDEX ();
965 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
966 Lisp_Object coding_systems;
967 Lisp_Object val, *args2;
968 ptrdiff_t i;
969 char *tempfile;
970 Lisp_Object tmpdir, pattern;
972 if (STRINGP (Vtemporary_file_directory))
973 tmpdir = Vtemporary_file_directory;
974 else
976 #ifndef DOS_NT
977 if (getenv ("TMPDIR"))
978 tmpdir = build_string (getenv ("TMPDIR"));
979 else
980 tmpdir = build_string ("/tmp/");
981 #else /* DOS_NT */
982 char *outf;
983 if ((outf = egetenv ("TMPDIR"))
984 || (outf = egetenv ("TMP"))
985 || (outf = egetenv ("TEMP")))
986 tmpdir = build_string (outf);
987 else
988 tmpdir = Ffile_name_as_directory (build_string ("c:/temp"));
989 #endif
993 USE_SAFE_ALLOCA;
994 pattern = Fexpand_file_name (Vtemp_file_name_pattern, tmpdir);
995 SAFE_ALLOCA (tempfile, char *, SBYTES (pattern) + 1);
996 memcpy (tempfile, SDATA (pattern), SBYTES (pattern) + 1);
997 coding_systems = Qt;
999 #ifdef HAVE_MKSTEMP
1001 int fd;
1003 BLOCK_INPUT;
1004 fd = mkstemp (tempfile);
1005 UNBLOCK_INPUT;
1006 if (fd == -1)
1007 report_file_error ("Failed to open temporary file",
1008 Fcons (Vtemp_file_name_pattern, Qnil));
1009 else
1010 close (fd);
1012 #else
1013 mktemp (tempfile);
1014 #endif
1016 filename_string = build_string (tempfile);
1017 GCPRO1 (filename_string);
1018 SAFE_FREE ();
1021 start = args[0];
1022 end = args[1];
1023 /* Decide coding-system of the contents of the temporary file. */
1024 if (!NILP (Vcoding_system_for_write))
1025 val = Vcoding_system_for_write;
1026 else if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
1027 val = Qraw_text;
1028 else
1030 USE_SAFE_ALLOCA;
1031 SAFE_NALLOCA (args2, 1, nargs + 1);
1032 args2[0] = Qcall_process_region;
1033 for (i = 0; i < nargs; i++) args2[i + 1] = args[i];
1034 coding_systems = Ffind_operation_coding_system (nargs + 1, args2);
1035 val = CONSP (coding_systems) ? XCDR (coding_systems) : Qnil;
1036 SAFE_FREE ();
1038 val = complement_process_encoding_system (val);
1041 int count1 = SPECPDL_INDEX ();
1043 specbind (intern ("coding-system-for-write"), val);
1044 /* POSIX lets mk[s]temp use "."; don't invoke jka-compr if we
1045 happen to get a ".Z" suffix. */
1046 specbind (intern ("file-name-handler-alist"), Qnil);
1047 Fwrite_region (start, end, filename_string, Qnil, Qlambda, Qnil, Qnil);
1049 unbind_to (count1, Qnil);
1052 /* Note that Fcall_process takes care of binding
1053 coding-system-for-read. */
1055 record_unwind_protect (delete_temp_file, filename_string);
1057 if (nargs > 3 && !NILP (args[3]))
1058 Fdelete_region (start, end);
1060 if (nargs > 3)
1062 args += 2;
1063 nargs -= 2;
1065 else
1067 args[0] = args[2];
1068 nargs = 2;
1070 args[1] = filename_string;
1072 RETURN_UNGCPRO (unbind_to (count, Fcall_process (nargs, args)));
1075 #ifndef WINDOWSNT
1076 static int relocate_fd (int fd, int minfd);
1077 #endif
1079 static char **
1080 add_env (char **env, char **new_env, char *string)
1082 char **ep;
1083 int ok = 1;
1084 if (string == NULL)
1085 return new_env;
1087 /* See if this string duplicates any string already in the env.
1088 If so, don't put it in.
1089 When an env var has multiple definitions,
1090 we keep the definition that comes first in process-environment. */
1091 for (ep = env; ok && ep != new_env; ep++)
1093 char *p = *ep, *q = string;
1094 while (ok)
1096 if (*q != *p)
1097 break;
1098 if (*q == 0)
1099 /* The string is a lone variable name; keep it for now, we
1100 will remove it later. It is a placeholder for a
1101 variable that is not to be included in the environment. */
1102 break;
1103 if (*q == '=')
1104 ok = 0;
1105 p++, q++;
1108 if (ok)
1109 *new_env++ = string;
1110 return new_env;
1113 /* This is the last thing run in a newly forked inferior
1114 either synchronous or asynchronous.
1115 Copy descriptors IN, OUT and ERR as descriptors 0, 1 and 2.
1116 Initialize inferior's priority, pgrp, connected dir and environment.
1117 then exec another program based on new_argv.
1119 This function may change environ for the superior process.
1120 Therefore, the superior process must save and restore the value
1121 of environ around the vfork and the call to this function.
1123 SET_PGRP is nonzero if we should put the subprocess into a separate
1124 process group.
1126 CURRENT_DIR is an elisp string giving the path of the current
1127 directory the subprocess should have. Since we can't really signal
1128 a decent error from within the child, this should be verified as an
1129 executable directory by the parent. */
1132 child_setup (int in, int out, int err, register char **new_argv, int set_pgrp, Lisp_Object current_dir)
1134 char **env;
1135 char *pwd_var;
1136 #ifdef WINDOWSNT
1137 int cpid;
1138 HANDLE handles[3];
1139 #endif /* WINDOWSNT */
1141 int pid = getpid ();
1143 /* Close Emacs's descriptors that this process should not have. */
1144 close_process_descs ();
1146 /* DOS_NT isn't in a vfork, so if we are in the middle of load-file,
1147 we will lose if we call close_load_descs here. */
1148 #ifndef DOS_NT
1149 close_load_descs ();
1150 #endif
1152 /* Note that use of alloca is always safe here. It's obvious for systems
1153 that do not have true vfork or that have true (stack) alloca.
1154 If using vfork and C_ALLOCA (when Emacs used to include
1155 src/alloca.c) it is safe because that changes the superior's
1156 static variables as if the superior had done alloca and will be
1157 cleaned up in the usual way. */
1159 register char *temp;
1160 size_t i; /* size_t, because ptrdiff_t might overflow here! */
1162 i = SBYTES (current_dir);
1163 #ifdef MSDOS
1164 /* MSDOS must have all environment variables malloc'ed, because
1165 low-level libc functions that launch subsidiary processes rely
1166 on that. */
1167 pwd_var = (char *) xmalloc (i + 6);
1168 #else
1169 pwd_var = (char *) alloca (i + 6);
1170 #endif
1171 temp = pwd_var + 4;
1172 memcpy (pwd_var, "PWD=", 4);
1173 memcpy (temp, SDATA (current_dir), i);
1174 if (!IS_DIRECTORY_SEP (temp[i - 1])) temp[i++] = DIRECTORY_SEP;
1175 temp[i] = 0;
1177 #ifndef DOS_NT
1178 /* We can't signal an Elisp error here; we're in a vfork. Since
1179 the callers check the current directory before forking, this
1180 should only return an error if the directory's permissions
1181 are changed between the check and this chdir, but we should
1182 at least check. */
1183 if (chdir (temp) < 0)
1184 _exit (errno);
1185 #else /* DOS_NT */
1186 /* Get past the drive letter, so that d:/ is left alone. */
1187 if (i > 2 && IS_DEVICE_SEP (temp[1]) && IS_DIRECTORY_SEP (temp[2]))
1189 temp += 2;
1190 i -= 2;
1192 #endif /* DOS_NT */
1194 /* Strip trailing slashes for PWD, but leave "/" and "//" alone. */
1195 while (i > 2 && IS_DIRECTORY_SEP (temp[i - 1]))
1196 temp[--i] = 0;
1199 /* Set `env' to a vector of the strings in the environment. */
1201 register Lisp_Object tem;
1202 register char **new_env;
1203 char **p, **q;
1204 register int new_length;
1205 Lisp_Object display = Qnil;
1207 new_length = 0;
1209 for (tem = Vprocess_environment;
1210 CONSP (tem) && STRINGP (XCAR (tem));
1211 tem = XCDR (tem))
1213 if (strncmp (SSDATA (XCAR (tem)), "DISPLAY", 7) == 0
1214 && (SDATA (XCAR (tem)) [7] == '\0'
1215 || SDATA (XCAR (tem)) [7] == '='))
1216 /* DISPLAY is specified in process-environment. */
1217 display = Qt;
1218 new_length++;
1221 /* If not provided yet, use the frame's DISPLAY. */
1222 if (NILP (display))
1224 Lisp_Object tmp = Fframe_parameter (selected_frame, Qdisplay);
1225 if (!STRINGP (tmp) && CONSP (Vinitial_environment))
1226 /* If still not found, Look for DISPLAY in Vinitial_environment. */
1227 tmp = Fgetenv_internal (build_string ("DISPLAY"),
1228 Vinitial_environment);
1229 if (STRINGP (tmp))
1231 display = tmp;
1232 new_length++;
1236 /* new_length + 2 to include PWD and terminating 0. */
1237 env = new_env = (char **) alloca ((new_length + 2) * sizeof (char *));
1238 /* If we have a PWD envvar, pass one down,
1239 but with corrected value. */
1240 if (egetenv ("PWD"))
1241 *new_env++ = pwd_var;
1243 if (STRINGP (display))
1245 char *vdata = (char *) alloca (sizeof "DISPLAY=" + SBYTES (display));
1246 strcpy (vdata, "DISPLAY=");
1247 strcat (vdata, SSDATA (display));
1248 new_env = add_env (env, new_env, vdata);
1251 /* Overrides. */
1252 for (tem = Vprocess_environment;
1253 CONSP (tem) && STRINGP (XCAR (tem));
1254 tem = XCDR (tem))
1255 new_env = add_env (env, new_env, SSDATA (XCAR (tem)));
1257 *new_env = 0;
1259 /* Remove variable names without values. */
1260 p = q = env;
1261 while (*p != 0)
1263 while (*q != 0 && strchr (*q, '=') == NULL)
1264 q++;
1265 *p = *q++;
1266 if (*p != 0)
1267 p++;
1272 #ifdef WINDOWSNT
1273 prepare_standard_handles (in, out, err, handles);
1274 set_process_dir (SDATA (current_dir));
1275 /* Spawn the child. (See ntproc.c:Spawnve). */
1276 cpid = spawnve (_P_NOWAIT, new_argv[0], new_argv, env);
1277 reset_standard_handles (in, out, err, handles);
1278 if (cpid == -1)
1279 /* An error occurred while trying to spawn the process. */
1280 report_file_error ("Spawning child process", Qnil);
1281 return cpid;
1283 #else /* not WINDOWSNT */
1284 /* Make sure that in, out, and err are not actually already in
1285 descriptors zero, one, or two; this could happen if Emacs is
1286 started with its standard in, out, or error closed, as might
1287 happen under X. */
1289 int oin = in, oout = out;
1291 /* We have to avoid relocating the same descriptor twice! */
1293 in = relocate_fd (in, 3);
1295 if (out == oin)
1296 out = in;
1297 else
1298 out = relocate_fd (out, 3);
1300 if (err == oin)
1301 err = in;
1302 else if (err == oout)
1303 err = out;
1304 else
1305 err = relocate_fd (err, 3);
1308 #ifndef MSDOS
1309 emacs_close (0);
1310 emacs_close (1);
1311 emacs_close (2);
1313 dup2 (in, 0);
1314 dup2 (out, 1);
1315 dup2 (err, 2);
1316 emacs_close (in);
1317 if (out != in)
1318 emacs_close (out);
1319 if (err != in && err != out)
1320 emacs_close (err);
1322 #if defined (USG)
1323 #ifndef SETPGRP_RELEASES_CTTY
1324 setpgrp (); /* No arguments but equivalent in this case */
1325 #endif
1326 #else /* not USG */
1327 setpgrp (pid, pid);
1328 #endif /* not USG */
1330 /* setpgrp_of_tty is incorrect here; it uses input_fd. */
1331 tcsetpgrp (0, pid);
1333 /* execvp does not accept an environment arg so the only way
1334 to pass this environment is to set environ. Our caller
1335 is responsible for restoring the ambient value of environ. */
1336 environ = env;
1337 execvp (new_argv[0], new_argv);
1339 emacs_write (1, "Can't exec program: ", 20);
1340 emacs_write (1, new_argv[0], strlen (new_argv[0]));
1341 emacs_write (1, "\n", 1);
1342 _exit (1);
1344 #else /* MSDOS */
1345 pid = run_msdos_command (new_argv, pwd_var + 4, in, out, err, env);
1346 xfree (pwd_var);
1347 if (pid == -1)
1348 /* An error occurred while trying to run the subprocess. */
1349 report_file_error ("Spawning child process", Qnil);
1350 return pid;
1351 #endif /* MSDOS */
1352 #endif /* not WINDOWSNT */
1355 #ifndef WINDOWSNT
1356 /* Move the file descriptor FD so that its number is not less than MINFD.
1357 If the file descriptor is moved at all, the original is freed. */
1358 static int
1359 relocate_fd (int fd, int minfd)
1361 if (fd >= minfd)
1362 return fd;
1363 else
1365 int new;
1366 #ifdef F_DUPFD
1367 new = fcntl (fd, F_DUPFD, minfd);
1368 #else
1369 new = dup (fd);
1370 if (new != -1)
1371 /* Note that we hold the original FD open while we recurse,
1372 to guarantee we'll get a new FD if we need it. */
1373 new = relocate_fd (new, minfd);
1374 #endif
1375 if (new == -1)
1377 const char *message_1 = "Error while setting up child: ";
1378 const char *errmessage = strerror (errno);
1379 const char *message_2 = "\n";
1380 emacs_write (2, message_1, strlen (message_1));
1381 emacs_write (2, errmessage, strlen (errmessage));
1382 emacs_write (2, message_2, strlen (message_2));
1383 _exit (1);
1385 emacs_close (fd);
1386 return new;
1389 #endif /* not WINDOWSNT */
1391 static int
1392 getenv_internal_1 (const char *var, ptrdiff_t varlen, char **value,
1393 ptrdiff_t *valuelen, Lisp_Object env)
1395 for (; CONSP (env); env = XCDR (env))
1397 Lisp_Object entry = XCAR (env);
1398 if (STRINGP (entry)
1399 && SBYTES (entry) >= varlen
1400 #ifdef WINDOWSNT
1401 /* NT environment variables are case insensitive. */
1402 && ! strnicmp (SDATA (entry), var, varlen)
1403 #else /* not WINDOWSNT */
1404 && ! memcmp (SDATA (entry), var, varlen)
1405 #endif /* not WINDOWSNT */
1408 if (SBYTES (entry) > varlen && SREF (entry, varlen) == '=')
1410 *value = SSDATA (entry) + (varlen + 1);
1411 *valuelen = SBYTES (entry) - (varlen + 1);
1412 return 1;
1414 else if (SBYTES (entry) == varlen)
1416 /* Lone variable names in Vprocess_environment mean that
1417 variable should be removed from the environment. */
1418 *value = NULL;
1419 return 1;
1423 return 0;
1426 static int
1427 getenv_internal (const char *var, ptrdiff_t varlen, char **value,
1428 ptrdiff_t *valuelen, Lisp_Object frame)
1430 /* Try to find VAR in Vprocess_environment first. */
1431 if (getenv_internal_1 (var, varlen, value, valuelen,
1432 Vprocess_environment))
1433 return *value ? 1 : 0;
1435 /* For DISPLAY try to get the values from the frame or the initial env. */
1436 if (strcmp (var, "DISPLAY") == 0)
1438 Lisp_Object display
1439 = Fframe_parameter (NILP (frame) ? selected_frame : frame, Qdisplay);
1440 if (STRINGP (display))
1442 *value = SSDATA (display);
1443 *valuelen = SBYTES (display);
1444 return 1;
1446 /* If still not found, Look for DISPLAY in Vinitial_environment. */
1447 if (getenv_internal_1 (var, varlen, value, valuelen,
1448 Vinitial_environment))
1449 return *value ? 1 : 0;
1452 return 0;
1455 DEFUN ("getenv-internal", Fgetenv_internal, Sgetenv_internal, 1, 2, 0,
1456 doc: /* Get the value of environment variable VARIABLE.
1457 VARIABLE should be a string. Value is nil if VARIABLE is undefined in
1458 the environment. Otherwise, value is a string.
1460 This function searches `process-environment' for VARIABLE.
1462 If optional parameter ENV is a list, then search this list instead of
1463 `process-environment', and return t when encountering a negative entry
1464 \(an entry for a variable with no value). */)
1465 (Lisp_Object variable, Lisp_Object env)
1467 char *value;
1468 ptrdiff_t valuelen;
1470 CHECK_STRING (variable);
1471 if (CONSP (env))
1473 if (getenv_internal_1 (SSDATA (variable), SBYTES (variable),
1474 &value, &valuelen, env))
1475 return value ? make_string (value, valuelen) : Qt;
1476 else
1477 return Qnil;
1479 else if (getenv_internal (SSDATA (variable), SBYTES (variable),
1480 &value, &valuelen, env))
1481 return make_string (value, valuelen);
1482 else
1483 return Qnil;
1486 /* A version of getenv that consults the Lisp environment lists,
1487 easily callable from C. */
1488 char *
1489 egetenv (const char *var)
1491 char *value;
1492 ptrdiff_t valuelen;
1494 if (getenv_internal (var, strlen (var), &value, &valuelen, Qnil))
1495 return value;
1496 else
1497 return 0;
1501 /* This is run before init_cmdargs. */
1503 void
1504 init_callproc_1 (void)
1506 char *data_dir = egetenv ("EMACSDATA");
1507 char *doc_dir = egetenv ("EMACSDOC");
1509 Vdata_directory
1510 = Ffile_name_as_directory (build_string (data_dir ? data_dir
1511 : PATH_DATA));
1512 Vdoc_directory
1513 = Ffile_name_as_directory (build_string (doc_dir ? doc_dir
1514 : PATH_DOC));
1516 /* Check the EMACSPATH environment variable, defaulting to the
1517 PATH_EXEC path from epaths.h. */
1518 Vexec_path = decode_env_path ("EMACSPATH", PATH_EXEC);
1519 Vexec_directory = Ffile_name_as_directory (Fcar (Vexec_path));
1520 Vexec_path = nconc2 (decode_env_path ("PATH", ""), Vexec_path);
1523 /* This is run after init_cmdargs, when Vinstallation_directory is valid. */
1525 void
1526 init_callproc (void)
1528 char *data_dir = egetenv ("EMACSDATA");
1530 register char * sh;
1531 Lisp_Object tempdir;
1533 if (!NILP (Vinstallation_directory))
1535 /* Add to the path the lib-src subdir of the installation dir. */
1536 Lisp_Object tem;
1537 tem = Fexpand_file_name (build_string ("lib-src"),
1538 Vinstallation_directory);
1539 #ifndef DOS_NT
1540 /* MSDOS uses wrapped binaries, so don't do this. */
1541 if (NILP (Fmember (tem, Vexec_path)))
1543 Vexec_path = decode_env_path ("EMACSPATH", PATH_EXEC);
1544 Vexec_path = Fcons (tem, Vexec_path);
1545 Vexec_path = nconc2 (decode_env_path ("PATH", ""), Vexec_path);
1548 Vexec_directory = Ffile_name_as_directory (tem);
1549 #endif /* not DOS_NT */
1551 /* Maybe use ../etc as well as ../lib-src. */
1552 if (data_dir == 0)
1554 tem = Fexpand_file_name (build_string ("etc"),
1555 Vinstallation_directory);
1556 Vdoc_directory = Ffile_name_as_directory (tem);
1560 /* Look for the files that should be in etc. We don't use
1561 Vinstallation_directory, because these files are never installed
1562 near the executable, and they are never in the build
1563 directory when that's different from the source directory.
1565 Instead, if these files are not in the nominal place, we try the
1566 source directory. */
1567 if (data_dir == 0)
1569 Lisp_Object tem, tem1, srcdir;
1571 srcdir = Fexpand_file_name (build_string ("../src/"),
1572 build_string (PATH_DUMPLOADSEARCH));
1573 tem = Fexpand_file_name (build_string ("GNU"), Vdata_directory);
1574 tem1 = Ffile_exists_p (tem);
1575 if (!NILP (Fequal (srcdir, Vinvocation_directory)) || NILP (tem1))
1577 Lisp_Object newdir;
1578 newdir = Fexpand_file_name (build_string ("../etc/"),
1579 build_string (PATH_DUMPLOADSEARCH));
1580 tem = Fexpand_file_name (build_string ("GNU"), newdir);
1581 tem1 = Ffile_exists_p (tem);
1582 if (!NILP (tem1))
1583 Vdata_directory = newdir;
1587 #ifndef CANNOT_DUMP
1588 if (initialized)
1589 #endif
1591 tempdir = Fdirectory_file_name (Vexec_directory);
1592 if (access (SSDATA (tempdir), 0) < 0)
1593 dir_warning ("Warning: arch-dependent data dir (%s) does not exist.\n",
1594 Vexec_directory);
1597 tempdir = Fdirectory_file_name (Vdata_directory);
1598 if (access (SSDATA (tempdir), 0) < 0)
1599 dir_warning ("Warning: arch-independent data dir (%s) does not exist.\n",
1600 Vdata_directory);
1602 sh = (char *) getenv ("SHELL");
1603 Vshell_file_name = build_string (sh ? sh : "/bin/sh");
1605 #ifdef DOS_NT
1606 Vshared_game_score_directory = Qnil;
1607 #else
1608 Vshared_game_score_directory = build_string (PATH_GAME);
1609 if (NILP (Ffile_directory_p (Vshared_game_score_directory)))
1610 Vshared_game_score_directory = Qnil;
1611 #endif
1614 void
1615 set_initial_environment (void)
1617 char **envp;
1618 for (envp = environ; *envp; envp++)
1619 Vprocess_environment = Fcons (build_string (*envp),
1620 Vprocess_environment);
1621 /* Ideally, the `copy' shouldn't be necessary, but it seems it's frequent
1622 to use `delete' and friends on process-environment. */
1623 Vinitial_environment = Fcopy_sequence (Vprocess_environment);
1626 void
1627 syms_of_callproc (void)
1629 #ifndef DOS_NT
1630 Vtemp_file_name_pattern = build_string ("emacsXXXXXX");
1631 #elif defined (WINDOWSNT)
1632 Vtemp_file_name_pattern = build_string ("emXXXXXX");
1633 #else
1634 Vtemp_file_name_pattern = build_string ("detmp.XXX");
1635 #endif
1636 staticpro (&Vtemp_file_name_pattern);
1638 DEFVAR_LISP ("shell-file-name", Vshell_file_name,
1639 doc: /* *File name to load inferior shells from.
1640 Initialized from the SHELL environment variable, or to a system-dependent
1641 default if SHELL is not set. */);
1643 DEFVAR_LISP ("exec-path", Vexec_path,
1644 doc: /* *List of directories to search programs to run in subprocesses.
1645 Each element is a string (directory name) or nil (try default directory). */);
1647 DEFVAR_LISP ("exec-suffixes", Vexec_suffixes,
1648 doc: /* *List of suffixes to try to find executable file names.
1649 Each element is a string. */);
1650 Vexec_suffixes = Qnil;
1652 DEFVAR_LISP ("exec-directory", Vexec_directory,
1653 doc: /* Directory for executables for Emacs to invoke.
1654 More generally, this includes any architecture-dependent files
1655 that are built and installed from the Emacs distribution. */);
1657 DEFVAR_LISP ("data-directory", Vdata_directory,
1658 doc: /* Directory of machine-independent files that come with GNU Emacs.
1659 These are files intended for Emacs to use while it runs. */);
1661 DEFVAR_LISP ("doc-directory", Vdoc_directory,
1662 doc: /* Directory containing the DOC file that comes with GNU Emacs.
1663 This is usually the same as `data-directory'. */);
1665 DEFVAR_LISP ("configure-info-directory", Vconfigure_info_directory,
1666 doc: /* For internal use by the build procedure only.
1667 This is the name of the directory in which the build procedure installed
1668 Emacs's info files; the default value for `Info-default-directory-list'
1669 includes this. */);
1670 Vconfigure_info_directory = build_string (PATH_INFO);
1672 DEFVAR_LISP ("shared-game-score-directory", Vshared_game_score_directory,
1673 doc: /* Directory of score files for games which come with GNU Emacs.
1674 If this variable is nil, then Emacs is unable to use a shared directory. */);
1675 #ifdef DOS_NT
1676 Vshared_game_score_directory = Qnil;
1677 #else
1678 Vshared_game_score_directory = build_string (PATH_GAME);
1679 #endif
1681 DEFVAR_LISP ("initial-environment", Vinitial_environment,
1682 doc: /* List of environment variables inherited from the parent process.
1683 Each element should be a string of the form ENVVARNAME=VALUE.
1684 The elements must normally be decoded (using `locale-coding-system') for use. */);
1685 Vinitial_environment = Qnil;
1687 DEFVAR_LISP ("process-environment", Vprocess_environment,
1688 doc: /* List of overridden environment variables for subprocesses to inherit.
1689 Each element should be a string of the form ENVVARNAME=VALUE.
1691 Entries in this list take precedence to those in the frame-local
1692 environments. Therefore, let-binding `process-environment' is an easy
1693 way to temporarily change the value of an environment variable,
1694 irrespective of where it comes from. To use `process-environment' to
1695 remove an environment variable, include only its name in the list,
1696 without "=VALUE".
1698 This variable is set to nil when Emacs starts.
1700 If multiple entries define the same variable, the first one always
1701 takes precedence.
1703 Non-ASCII characters are encoded according to the initial value of
1704 `locale-coding-system', i.e. the elements must normally be decoded for
1705 use.
1707 See `setenv' and `getenv'. */);
1708 Vprocess_environment = Qnil;
1710 defsubr (&Scall_process);
1711 defsubr (&Sgetenv_internal);
1712 defsubr (&Scall_process_region);