*** empty log message ***
[emacs.git] / src / callproc.c
blob00068a908fbb057e2015c19bb51b7ba4a12fb6b3
1 /* Synchronous subprocess invocation for GNU Emacs.
2 Copyright (C) 1985,86,87,88,93,94,95,99, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 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; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 #include <config.h>
24 #include <signal.h>
25 #include <errno.h>
26 #include <stdio.h>
28 #ifndef USE_CRT_DLL
29 extern int errno;
30 #endif
32 /* Define SIGCHLD as an alias for SIGCLD. */
34 #if !defined (SIGCHLD) && defined (SIGCLD)
35 #define SIGCHLD SIGCLD
36 #endif /* SIGCLD */
38 #include <sys/types.h>
40 #ifdef HAVE_UNISTD_H
41 #include <unistd.h>
42 #endif
44 #include <sys/file.h>
45 #ifdef HAVE_FCNTL_H
46 #define INCLUDED_FCNTL
47 #include <fcntl.h>
48 #endif
50 #ifdef WINDOWSNT
51 #define NOMINMAX
52 #include <windows.h>
53 #include <stdlib.h> /* for proper declaration of environ */
54 #include <fcntl.h>
55 #include "w32.h"
56 #define _P_NOWAIT 1 /* from process.h */
57 #endif
59 #ifdef MSDOS /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
60 #define INCLUDED_FCNTL
61 #include <fcntl.h>
62 #include <sys/stat.h>
63 #include <sys/param.h>
64 #include <errno.h>
65 #endif /* MSDOS */
67 #ifndef O_RDONLY
68 #define O_RDONLY 0
69 #endif
71 #ifndef O_WRONLY
72 #define O_WRONLY 1
73 #endif
75 #include "lisp.h"
76 #include "commands.h"
77 #include "buffer.h"
78 #include "charset.h"
79 #include "ccl.h"
80 #include "coding.h"
81 #include "composite.h"
82 #include <epaths.h>
83 #include "process.h"
84 #include "syssignal.h"
85 #include "systty.h"
87 #ifdef MSDOS
88 #include "msdos.h"
89 #endif
91 #ifdef VMS
92 extern noshare char **environ;
93 #else
94 #ifndef USE_CRT_DLL
95 extern char **environ;
96 #endif
97 #endif
99 #ifdef HAVE_SETPGID
100 #if !defined (USG) || defined (BSD_PGRPS)
101 #undef setpgrp
102 #define setpgrp setpgid
103 #endif
104 #endif
106 Lisp_Object Vexec_path, Vexec_directory, Vexec_suffixes;
107 Lisp_Object Vdata_directory, Vdoc_directory;
108 Lisp_Object Vconfigure_info_directory, Vshared_game_score_directory;
109 Lisp_Object Vtemp_file_name_pattern;
111 Lisp_Object Vshell_file_name;
113 Lisp_Object Vprocess_environment;
115 #ifdef DOS_NT
116 Lisp_Object Qbuffer_file_type;
117 #endif /* DOS_NT */
119 /* True iff we are about to fork off a synchronous process or if we
120 are waiting for it. */
121 int synch_process_alive;
123 /* Nonzero => this is a string explaining death of synchronous subprocess. */
124 char *synch_process_death;
126 /* If synch_process_death is zero,
127 this is exit code of synchronous subprocess. */
128 int synch_process_retcode;
130 extern Lisp_Object Vdoc_file_name;
132 extern Lisp_Object Vfile_name_coding_system, Vdefault_file_name_coding_system;
134 /* Clean up when exiting Fcall_process.
135 On MSDOS, delete the temporary file on any kind of termination.
136 On Unix, kill the process and any children on termination by signal. */
138 /* Nonzero if this is termination due to exit. */
139 static int call_process_exited;
141 #ifndef VMS /* VMS version is in vmsproc.c. */
143 static Lisp_Object
144 call_process_kill (fdpid)
145 Lisp_Object fdpid;
147 emacs_close (XFASTINT (Fcar (fdpid)));
148 EMACS_KILLPG (XFASTINT (Fcdr (fdpid)), SIGKILL);
149 synch_process_alive = 0;
150 return Qnil;
153 Lisp_Object
154 call_process_cleanup (fdpid)
155 Lisp_Object fdpid;
157 #if defined (MSDOS) || defined (MAC_OS8)
158 /* for MSDOS fdpid is really (fd . tempfile) */
159 register Lisp_Object file;
160 file = Fcdr (fdpid);
161 emacs_close (XFASTINT (Fcar (fdpid)));
162 if (strcmp (SDATA (file), NULL_DEVICE) != 0)
163 unlink (SDATA (file));
164 #else /* not MSDOS and not MAC_OS8 */
165 register int pid = XFASTINT (Fcdr (fdpid));
167 if (call_process_exited)
169 emacs_close (XFASTINT (Fcar (fdpid)));
170 return Qnil;
173 if (EMACS_KILLPG (pid, SIGINT) == 0)
175 int count = SPECPDL_INDEX ();
176 record_unwind_protect (call_process_kill, fdpid);
177 message1 ("Waiting for process to die...(type C-g again to kill it instantly)");
178 immediate_quit = 1;
179 QUIT;
180 wait_for_termination (pid);
181 immediate_quit = 0;
182 specpdl_ptr = specpdl + count; /* Discard the unwind protect. */
183 message1 ("Waiting for process to die...done");
185 synch_process_alive = 0;
186 emacs_close (XFASTINT (Fcar (fdpid)));
187 #endif /* not MSDOS */
188 return Qnil;
191 DEFUN ("call-process", Fcall_process, Scall_process, 1, MANY, 0,
192 doc: /* Call PROGRAM synchronously in separate process.
193 The remaining arguments are optional.
194 The program's input comes from file INFILE (nil means `/dev/null').
195 Insert output in BUFFER before point; t means current buffer;
196 nil for BUFFER means discard it; 0 means discard and don't wait.
197 BUFFER can also have the form (REAL-BUFFER STDERR-FILE); in that case,
198 REAL-BUFFER says what to do with standard output, as above,
199 while STDERR-FILE says what to do with standard error in the child.
200 STDERR-FILE may be nil (discard standard error output),
201 t (mix it with ordinary output), or a file name string.
203 Fourth arg DISPLAY non-nil means redisplay buffer as output is inserted.
204 Remaining arguments are strings passed as command arguments to PROGRAM.
206 If BUFFER is 0, `call-process' returns immediately with value nil.
207 Otherwise it waits for PROGRAM to terminate
208 and returns a numeric exit status or a signal description string.
209 If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.
211 usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS) */)
212 (nargs, args)
213 int nargs;
214 register Lisp_Object *args;
216 Lisp_Object infile, buffer, current_dir, display, path;
217 int fd[2];
218 int filefd;
219 register int pid;
220 char buf[16384];
221 char *bufptr = buf;
222 int bufsize = 16384;
223 int count = SPECPDL_INDEX ();
225 register const unsigned char **new_argv
226 = (const unsigned char **) alloca ((max (2, nargs - 2)) * sizeof (char *));
227 struct buffer *old = current_buffer;
228 /* File to use for stderr in the child.
229 t means use same as standard output. */
230 Lisp_Object error_file;
231 #ifdef MSDOS /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
232 char *outf, *tempfile;
233 int outfilefd;
234 #endif
235 #ifdef MAC_OS8
236 char *tempfile;
237 int outfilefd;
238 #endif
239 #if 0
240 int mask;
241 #endif
242 struct coding_system process_coding; /* coding-system of process output */
243 struct coding_system argument_coding; /* coding-system of arguments */
244 /* Set to the return value of Ffind_operation_coding_system. */
245 Lisp_Object coding_systems;
247 /* Qt denotes that Ffind_operation_coding_system is not yet called. */
248 coding_systems = Qt;
250 CHECK_STRING (args[0]);
252 error_file = Qt;
254 #ifndef subprocesses
255 /* Without asynchronous processes we cannot have BUFFER == 0. */
256 if (nargs >= 3
257 && (INTEGERP (CONSP (args[2]) ? XCAR (args[2]) : args[2])))
258 error ("Operating system cannot handle asynchronous subprocesses");
259 #endif /* subprocesses */
261 /* Decide the coding-system for giving arguments. */
263 Lisp_Object val, *args2;
264 int i;
266 /* If arguments are supplied, we may have to encode them. */
267 if (nargs >= 5)
269 int must_encode = 0;
271 for (i = 4; i < nargs; i++)
272 CHECK_STRING (args[i]);
274 for (i = 4; i < nargs; i++)
275 if (STRING_MULTIBYTE (args[i]))
276 must_encode = 1;
278 if (!NILP (Vcoding_system_for_write))
279 val = Vcoding_system_for_write;
280 else if (! must_encode)
281 val = Qnil;
282 else
284 args2 = (Lisp_Object *) alloca ((nargs + 1) * sizeof *args2);
285 args2[0] = Qcall_process;
286 for (i = 0; i < nargs; i++) args2[i + 1] = args[i];
287 coding_systems = Ffind_operation_coding_system (nargs + 1, args2);
288 if (CONSP (coding_systems))
289 val = XCDR (coding_systems);
290 else if (CONSP (Vdefault_process_coding_system))
291 val = XCDR (Vdefault_process_coding_system);
292 else
293 val = Qnil;
295 setup_coding_system (Fcheck_coding_system (val), &argument_coding);
299 if (nargs >= 2 && ! NILP (args[1]))
301 infile = Fexpand_file_name (args[1], current_buffer->directory);
302 CHECK_STRING (infile);
304 else
305 infile = build_string (NULL_DEVICE);
307 if (nargs >= 3)
309 buffer = args[2];
311 /* If BUFFER is a list, its meaning is
312 (BUFFER-FOR-STDOUT FILE-FOR-STDERR). */
313 if (CONSP (buffer))
315 if (CONSP (XCDR (buffer)))
317 Lisp_Object stderr_file;
318 stderr_file = XCAR (XCDR (buffer));
320 if (NILP (stderr_file) || EQ (Qt, stderr_file))
321 error_file = stderr_file;
322 else
323 error_file = Fexpand_file_name (stderr_file, Qnil);
326 buffer = XCAR (buffer);
329 if (!(EQ (buffer, Qnil)
330 || EQ (buffer, Qt)
331 || INTEGERP (buffer)))
333 Lisp_Object spec_buffer;
334 spec_buffer = buffer;
335 buffer = Fget_buffer_create (buffer);
336 /* Mention the buffer name for a better error message. */
337 if (NILP (buffer))
338 CHECK_BUFFER (spec_buffer);
339 CHECK_BUFFER (buffer);
342 else
343 buffer = Qnil;
345 /* Make sure that the child will be able to chdir to the current
346 buffer's current directory, or its unhandled equivalent. We
347 can't just have the child check for an error when it does the
348 chdir, since it's in a vfork.
350 We have to GCPRO around this because Fexpand_file_name,
351 Funhandled_file_name_directory, and Ffile_accessible_directory_p
352 might call a file name handling function. The argument list is
353 protected by the caller, so all we really have to worry about is
354 buffer. */
356 struct gcpro gcpro1, gcpro2, gcpro3;
358 current_dir = current_buffer->directory;
360 GCPRO3 (infile, buffer, current_dir);
362 current_dir
363 = expand_and_dir_to_file (Funhandled_file_name_directory (current_dir),
364 Qnil);
365 if (NILP (Ffile_accessible_directory_p (current_dir)))
366 report_file_error ("Setting current directory",
367 Fcons (current_buffer->directory, Qnil));
369 UNGCPRO;
372 display = nargs >= 4 ? args[3] : Qnil;
374 filefd = emacs_open (SDATA (infile), O_RDONLY, 0);
375 if (filefd < 0)
377 report_file_error ("Opening process input file", Fcons (infile, Qnil));
379 /* Search for program; barf if not found. */
381 struct gcpro gcpro1;
383 GCPRO1 (current_dir);
384 openp (Vexec_path, args[0], Vexec_suffixes, &path, make_number (X_OK));
385 UNGCPRO;
387 if (NILP (path))
389 emacs_close (filefd);
390 report_file_error ("Searching for program", Fcons (args[0], Qnil));
393 /* If program file name starts with /: for quoting a magic name,
394 discard that. */
395 if (SBYTES (path) > 2 && SREF (path, 0) == '/'
396 && SREF (path, 1) == ':')
397 path = Fsubstring (path, make_number (2), Qnil);
399 new_argv[0] = SDATA (path);
400 if (nargs > 4)
402 register int i;
403 struct gcpro gcpro1, gcpro2, gcpro3;
405 GCPRO3 (infile, buffer, current_dir);
406 argument_coding.dst_multibyte = 0;
407 for (i = 4; i < nargs; i++)
409 argument_coding.src_multibyte = STRING_MULTIBYTE (args[i]);
410 if (CODING_REQUIRE_ENCODING (&argument_coding))
412 /* We must encode this argument. */
413 args[i] = encode_coding_string (args[i], &argument_coding, 1);
414 if (argument_coding.type == coding_type_ccl)
415 setup_ccl_program (&(argument_coding.spec.ccl.encoder), Qnil);
417 new_argv[i - 3] = SDATA (args[i]);
419 UNGCPRO;
420 new_argv[nargs - 3] = 0;
422 else
423 new_argv[1] = 0;
425 #ifdef MSDOS /* MW, July 1993 */
426 if ((outf = egetenv ("TMPDIR")))
427 strcpy (tempfile = alloca (strlen (outf) + 20), outf);
428 else
430 tempfile = alloca (20);
431 *tempfile = '\0';
433 dostounix_filename (tempfile);
434 if (*tempfile == '\0' || tempfile[strlen (tempfile) - 1] != '/')
435 strcat (tempfile, "/");
436 strcat (tempfile, "detmp.XXX");
437 mktemp (tempfile);
439 outfilefd = creat (tempfile, S_IREAD | S_IWRITE);
440 if (outfilefd < 0)
442 emacs_close (filefd);
443 report_file_error ("Opening process output file",
444 Fcons (build_string (tempfile), Qnil));
446 fd[0] = filefd;
447 fd[1] = outfilefd;
448 #endif /* MSDOS */
450 #ifdef MAC_OS8
451 /* Since we don't have pipes on the Mac, create a temporary file to
452 hold the output of the subprocess. */
453 tempfile = (char *) alloca (SBYTES (Vtemp_file_name_pattern) + 1);
454 bcopy (SDATA (Vtemp_file_name_pattern), tempfile,
455 SBYTES (Vtemp_file_name_pattern) + 1);
457 mktemp (tempfile);
459 outfilefd = creat (tempfile, S_IREAD | S_IWRITE);
460 if (outfilefd < 0)
462 close (filefd);
463 report_file_error ("Opening process output file",
464 Fcons (build_string (tempfile), Qnil));
466 fd[0] = filefd;
467 fd[1] = outfilefd;
468 #endif /* MAC_OS8 */
470 if (INTEGERP (buffer))
471 fd[1] = emacs_open (NULL_DEVICE, O_WRONLY, 0), fd[0] = -1;
472 else
474 #ifndef MSDOS
475 #ifndef MAC_OS8
476 errno = 0;
477 if (pipe (fd) == -1)
479 emacs_close (filefd);
480 report_file_error ("Creating process pipe", Qnil);
482 #endif
483 #endif
484 #if 0
485 /* Replaced by close_process_descs */
486 set_exclusive_use (fd[0]);
487 #endif
491 /* child_setup must clobber environ in systems with true vfork.
492 Protect it from permanent change. */
493 register char **save_environ = environ;
494 register int fd1 = fd[1];
495 int fd_error = fd1;
497 #if 0 /* Some systems don't have sigblock. */
498 mask = sigblock (sigmask (SIGCHLD));
499 #endif
501 /* Record that we're about to create a synchronous process. */
502 synch_process_alive = 1;
504 /* These vars record information from process termination.
505 Clear them now before process can possibly terminate,
506 to avoid timing error if process terminates soon. */
507 synch_process_death = 0;
508 synch_process_retcode = 0;
510 if (NILP (error_file))
511 fd_error = emacs_open (NULL_DEVICE, O_WRONLY, 0);
512 else if (STRINGP (error_file))
514 #ifdef DOS_NT
515 fd_error = emacs_open (SDATA (error_file),
516 O_WRONLY | O_TRUNC | O_CREAT | O_TEXT,
517 S_IREAD | S_IWRITE);
518 #else /* not DOS_NT */
519 fd_error = creat (SDATA (error_file), 0666);
520 #endif /* not DOS_NT */
523 if (fd_error < 0)
525 emacs_close (filefd);
526 if (fd[0] != filefd)
527 emacs_close (fd[0]);
528 if (fd1 >= 0)
529 emacs_close (fd1);
530 #ifdef MSDOS
531 unlink (tempfile);
532 #endif
533 report_file_error ("Cannot redirect stderr",
534 Fcons ((NILP (error_file)
535 ? build_string (NULL_DEVICE) : error_file),
536 Qnil));
539 current_dir = ENCODE_FILE (current_dir);
541 #ifdef MAC_OS8
543 /* Call run_mac_command in sysdep.c here directly instead of doing
544 a child_setup as for MSDOS and other platforms. Note that this
545 code does not handle passing the environment to the synchronous
546 Mac subprocess. */
547 char *infn, *outfn, *errfn, *currdn;
549 /* close these files so subprocess can write to them */
550 close (outfilefd);
551 if (fd_error != outfilefd)
552 close (fd_error);
553 fd1 = -1; /* No harm in closing that one! */
555 infn = SDATA (infile);
556 outfn = tempfile;
557 if (NILP (error_file))
558 errfn = NULL_DEVICE;
559 else if (EQ (Qt, error_file))
560 errfn = outfn;
561 else
562 errfn = SDATA (error_file);
563 currdn = SDATA (current_dir);
564 pid = run_mac_command (new_argv, currdn, infn, outfn, errfn);
566 /* Record that the synchronous process exited and note its
567 termination status. */
568 synch_process_alive = 0;
569 synch_process_retcode = pid;
570 if (synch_process_retcode < 0) /* means it couldn't be exec'ed */
572 synchronize_system_messages_locale ();
573 synch_process_death = strerror (errno);
576 /* Since CRLF is converted to LF within `decode_coding', we can
577 always open a file with binary mode. */
578 fd[0] = open (tempfile, O_BINARY);
579 if (fd[0] < 0)
581 unlink (tempfile);
582 close (filefd);
583 report_file_error ("Cannot re-open temporary file", Qnil);
586 #else /* not MAC_OS8 */
587 #ifdef MSDOS /* MW, July 1993 */
588 /* Note that on MSDOS `child_setup' actually returns the child process
589 exit status, not its PID, so we assign it to `synch_process_retcode'
590 below. */
591 pid = child_setup (filefd, outfilefd, fd_error, (char **) new_argv,
592 0, current_dir);
594 /* Record that the synchronous process exited and note its
595 termination status. */
596 synch_process_alive = 0;
597 synch_process_retcode = pid;
598 if (synch_process_retcode < 0) /* means it couldn't be exec'ed */
600 synchronize_system_messages_locale ();
601 synch_process_death = strerror (errno);
604 emacs_close (outfilefd);
605 if (fd_error != outfilefd)
606 emacs_close (fd_error);
607 fd1 = -1; /* No harm in closing that one! */
608 /* Since CRLF is converted to LF within `decode_coding', we can
609 always open a file with binary mode. */
610 fd[0] = emacs_open (tempfile, O_RDONLY | O_BINARY, 0);
611 if (fd[0] < 0)
613 unlink (tempfile);
614 emacs_close (filefd);
615 report_file_error ("Cannot re-open temporary file", Qnil);
617 #else /* not MSDOS */
618 #ifdef WINDOWSNT
619 pid = child_setup (filefd, fd1, fd_error, (char **) new_argv,
620 0, current_dir);
621 #else /* not WINDOWSNT */
622 pid = vfork ();
624 if (pid == 0)
626 if (fd[0] >= 0)
627 emacs_close (fd[0]);
628 #ifdef HAVE_SETSID
629 setsid ();
630 #endif
631 #if defined (USG) && !defined (BSD_PGRPS)
632 setpgrp ();
633 #else
634 setpgrp (pid, pid);
635 #endif /* USG */
636 child_setup (filefd, fd1, fd_error, (char **) new_argv,
637 0, current_dir);
639 #endif /* not WINDOWSNT */
641 /* The MSDOS case did this already. */
642 if (fd_error >= 0)
643 emacs_close (fd_error);
644 #endif /* not MSDOS */
645 #endif /* not MAC_OS8 */
647 environ = save_environ;
649 /* Close most of our fd's, but not fd[0]
650 since we will use that to read input from. */
651 emacs_close (filefd);
652 if (fd1 >= 0 && fd1 != fd_error)
653 emacs_close (fd1);
656 if (pid < 0)
658 if (fd[0] >= 0)
659 emacs_close (fd[0]);
660 report_file_error ("Doing vfork", Qnil);
663 if (INTEGERP (buffer))
665 if (fd[0] >= 0)
666 emacs_close (fd[0]);
667 #ifndef subprocesses
668 /* If Emacs has been built with asynchronous subprocess support,
669 we don't need to do this, I think because it will then have
670 the facilities for handling SIGCHLD. */
671 wait_without_blocking ();
672 #endif /* subprocesses */
673 return Qnil;
676 /* Enable sending signal if user quits below. */
677 call_process_exited = 0;
679 #if defined(MSDOS) || defined(MAC_OS8)
680 /* MSDOS needs different cleanup information. */
681 record_unwind_protect (call_process_cleanup,
682 Fcons (make_number (fd[0]), build_string (tempfile)));
683 #else
684 record_unwind_protect (call_process_cleanup,
685 Fcons (make_number (fd[0]), make_number (pid)));
686 #endif /* not MSDOS and not MAC_OS8 */
689 if (BUFFERP (buffer))
690 Fset_buffer (buffer);
692 if (NILP (buffer))
694 /* If BUFFER is nil, we must read process output once and then
695 discard it, so setup coding system but with nil. */
696 setup_coding_system (Qnil, &process_coding);
698 else
700 Lisp_Object val, *args2;
702 val = Qnil;
703 if (!NILP (Vcoding_system_for_read))
704 val = Vcoding_system_for_read;
705 else
707 if (EQ (coding_systems, Qt))
709 int i;
711 args2 = (Lisp_Object *) alloca ((nargs + 1) * sizeof *args2);
712 args2[0] = Qcall_process;
713 for (i = 0; i < nargs; i++) args2[i + 1] = args[i];
714 coding_systems
715 = Ffind_operation_coding_system (nargs + 1, args2);
717 if (CONSP (coding_systems))
718 val = XCAR (coding_systems);
719 else if (CONSP (Vdefault_process_coding_system))
720 val = XCAR (Vdefault_process_coding_system);
721 else
722 val = Qnil;
724 setup_coding_system (Fcheck_coding_system (val), &process_coding);
725 /* In unibyte mode, character code conversion should not take
726 place but EOL conversion should. So, setup raw-text or one
727 of the subsidiary according to the information just setup. */
728 if (NILP (current_buffer->enable_multibyte_characters)
729 && !NILP (val))
730 setup_raw_text_coding_system (&process_coding);
732 process_coding.src_multibyte = 0;
733 process_coding.dst_multibyte
734 = (BUFFERP (buffer)
735 ? ! NILP (XBUFFER (buffer)->enable_multibyte_characters)
736 : ! NILP (current_buffer->enable_multibyte_characters));
738 immediate_quit = 1;
739 QUIT;
742 register int nread;
743 int first = 1;
744 int total_read = 0;
745 int carryover = 0;
746 int display_on_the_fly = !NILP (display) && INTERACTIVE;
747 struct coding_system saved_coding;
748 int pt_orig = PT, pt_byte_orig = PT_BYTE;
749 int inserted;
751 saved_coding = process_coding;
752 if (process_coding.composing != COMPOSITION_DISABLED)
753 coding_allocate_composition_data (&process_coding, PT);
754 while (1)
756 /* Repeatedly read until we've filled as much as possible
757 of the buffer size we have. But don't read
758 less than 1024--save that for the next bufferful. */
759 nread = carryover;
760 while (nread < bufsize - 1024)
762 int this_read = emacs_read (fd[0], bufptr + nread,
763 bufsize - nread);
765 if (this_read < 0)
766 goto give_up;
768 if (this_read == 0)
770 process_coding.mode |= CODING_MODE_LAST_BLOCK;
771 break;
774 nread += this_read;
775 total_read += this_read;
777 if (display_on_the_fly)
778 break;
781 /* Now NREAD is the total amount of data in the buffer. */
782 immediate_quit = 0;
784 if (!NILP (buffer))
786 if (! CODING_MAY_REQUIRE_DECODING (&process_coding))
787 insert_1_both (bufptr, nread, nread, 0, 1, 0);
788 else
789 { /* We have to decode the input. */
790 int size;
791 char *decoding_buf;
793 repeat_decoding:
794 size = decoding_buffer_size (&process_coding, nread);
795 decoding_buf = (char *) xmalloc (size);
797 /* We can't use the macro CODING_REQUIRE_DETECTION
798 because it always returns nonzero if the coding
799 system requires EOL detection. Here, we have to
800 check only whether or not the coding system
801 requires text-encoding detection. */
802 if (process_coding.type == coding_type_undecided)
804 detect_coding (&process_coding, bufptr, nread);
805 if (process_coding.composing != COMPOSITION_DISABLED)
806 coding_allocate_composition_data (&process_coding, PT);
808 if (process_coding.cmp_data)
809 process_coding.cmp_data->char_offset = PT;
811 decode_coding (&process_coding, bufptr, decoding_buf,
812 nread, size);
814 if (display_on_the_fly
815 && saved_coding.type == coding_type_undecided
816 && process_coding.type != coding_type_undecided)
818 /* We have detected some coding system. But,
819 there's a possibility that the detection was
820 done by insufficient data. So, we give up
821 displaying on the fly. */
822 xfree (decoding_buf);
823 display_on_the_fly = 0;
824 process_coding = saved_coding;
825 carryover = nread;
826 continue;
829 if (process_coding.produced > 0)
830 insert_1_both (decoding_buf, process_coding.produced_char,
831 process_coding.produced, 0, 1, 0);
832 xfree (decoding_buf);
834 if (process_coding.result == CODING_FINISH_INCONSISTENT_EOL)
836 Lisp_Object eol_type, coding;
838 if (process_coding.eol_type == CODING_EOL_CR)
840 /* CRs have been replaced with LFs. Undo
841 that in the text inserted above. */
842 unsigned char *p;
844 move_gap_both (PT, PT_BYTE);
846 p = BYTE_POS_ADDR (pt_byte_orig);
847 for (; p < GPT_ADDR; ++p)
848 if (*p == '\n')
849 *p = '\r';
851 else if (process_coding.eol_type == CODING_EOL_CRLF)
853 /* CR LFs have been replaced with LFs. Undo
854 that by inserting CRs in front of LFs in
855 the text inserted above. */
856 EMACS_INT bytepos, old_pt, old_pt_byte, nCR;
858 old_pt = PT;
859 old_pt_byte = PT_BYTE;
860 nCR = 0;
862 for (bytepos = PT_BYTE - 1;
863 bytepos >= pt_byte_orig;
864 --bytepos)
865 if (FETCH_BYTE (bytepos) == '\n')
867 EMACS_INT charpos = BYTE_TO_CHAR (bytepos);
868 TEMP_SET_PT_BOTH (charpos, bytepos);
869 insert_1_both ("\r", 1, 1, 0, 1, 0);
870 ++nCR;
873 TEMP_SET_PT_BOTH (old_pt + nCR, old_pt_byte + nCR);
876 /* Set the coding system symbol to that for
877 Unix-like EOL. */
878 eol_type = Fget (saved_coding.symbol, Qeol_type);
879 if (VECTORP (eol_type)
880 && ASIZE (eol_type) == 3
881 && SYMBOLP (AREF (eol_type, CODING_EOL_LF)))
882 coding = AREF (eol_type, CODING_EOL_LF);
883 else
884 coding = saved_coding.symbol;
886 process_coding.symbol = coding;
887 process_coding.eol_type = CODING_EOL_LF;
888 process_coding.mode
889 &= ~CODING_MODE_INHIBIT_INCONSISTENT_EOL;
892 nread -= process_coding.consumed;
893 carryover = nread;
894 if (carryover > 0)
895 /* As CARRYOVER should not be that large, we had
896 better avoid overhead of bcopy. */
897 BCOPY_SHORT (bufptr + process_coding.consumed, bufptr,
898 carryover);
899 if (process_coding.result == CODING_FINISH_INSUFFICIENT_CMP)
901 /* The decoding ended because of insufficient data
902 area to record information about composition.
903 We must try decoding with additional data area
904 before reading more output for the process. */
905 coding_allocate_composition_data (&process_coding, PT);
906 goto repeat_decoding;
911 if (process_coding.mode & CODING_MODE_LAST_BLOCK)
912 break;
914 /* Make the buffer bigger as we continue to read more data,
915 but not past 64k. */
916 if (bufsize < 64 * 1024 && total_read > 32 * bufsize)
918 char *tempptr;
919 bufsize *= 2;
921 tempptr = (char *) alloca (bufsize);
922 bcopy (bufptr, tempptr, bufsize / 2);
923 bufptr = tempptr;
926 if (!NILP (display) && INTERACTIVE)
928 if (first)
929 prepare_menu_bars ();
930 first = 0;
931 redisplay_preserve_echo_area (1);
933 immediate_quit = 1;
934 QUIT;
936 give_up: ;
938 if (!NILP (buffer)
939 && process_coding.cmp_data)
941 coding_restore_composition (&process_coding, Fcurrent_buffer ());
942 coding_free_composition_data (&process_coding);
946 int post_read_count = SPECPDL_INDEX ();
948 record_unwind_protect (save_excursion_restore, save_excursion_save ());
949 inserted = PT - pt_orig;
950 TEMP_SET_PT_BOTH (pt_orig, pt_byte_orig);
951 if (SYMBOLP (process_coding.post_read_conversion)
952 && !NILP (Ffboundp (process_coding.post_read_conversion)))
953 call1 (process_coding.post_read_conversion, make_number (inserted));
955 Vlast_coding_system_used = process_coding.symbol;
957 /* If the caller required, let the buffer inherit the
958 coding-system used to decode the process output. */
959 if (inherit_process_coding_system)
960 call1 (intern ("after-insert-file-set-buffer-file-coding-system"),
961 make_number (total_read));
963 unbind_to (post_read_count, Qnil);
967 /* Wait for it to terminate, unless it already has. */
968 wait_for_termination (pid);
970 immediate_quit = 0;
972 set_buffer_internal (old);
974 /* Don't kill any children that the subprocess may have left behind
975 when exiting. */
976 call_process_exited = 1;
978 unbind_to (count, Qnil);
980 if (synch_process_death)
981 return code_convert_string_norecord (build_string (synch_process_death),
982 Vlocale_coding_system, 0);
983 return make_number (synch_process_retcode);
985 #endif
987 static Lisp_Object
988 delete_temp_file (name)
989 Lisp_Object name;
991 /* Use Fdelete_file (indirectly) because that runs a file name handler.
992 We did that when writing the file, so we should do so when deleting. */
993 internal_delete_file (name);
994 return Qnil;
997 DEFUN ("call-process-region", Fcall_process_region, Scall_process_region,
998 3, MANY, 0,
999 doc: /* Send text from START to END to a synchronous process running PROGRAM.
1000 The remaining arguments are optional.
1001 Delete the text if fourth arg DELETE is non-nil.
1003 Insert output in BUFFER before point; t means current buffer;
1004 nil for BUFFER means discard it; 0 means discard and don't wait.
1005 BUFFER can also have the form (REAL-BUFFER STDERR-FILE); in that case,
1006 REAL-BUFFER says what to do with standard output, as above,
1007 while STDERR-FILE says what to do with standard error in the child.
1008 STDERR-FILE may be nil (discard standard error output),
1009 t (mix it with ordinary output), or a file name string.
1011 Sixth arg DISPLAY non-nil means redisplay buffer as output is inserted.
1012 Remaining args are passed to PROGRAM at startup as command args.
1014 If BUFFER is 0, `call-process-region' returns immediately with value nil.
1015 Otherwise it waits for PROGRAM to terminate
1016 and returns a numeric exit status or a signal description string.
1017 If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.
1019 usage: (call-process-region START END PROGRAM &optional DELETE BUFFER DISPLAY &rest ARGS) */)
1020 (nargs, args)
1021 int nargs;
1022 register Lisp_Object *args;
1024 struct gcpro gcpro1;
1025 Lisp_Object filename_string;
1026 register Lisp_Object start, end;
1027 int count = SPECPDL_INDEX ();
1028 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
1029 Lisp_Object coding_systems;
1030 Lisp_Object val, *args2;
1031 int i;
1032 #ifdef DOS_NT
1033 char *tempfile;
1034 char *outf = '\0';
1036 if ((outf = egetenv ("TMPDIR"))
1037 || (outf = egetenv ("TMP"))
1038 || (outf = egetenv ("TEMP")))
1039 strcpy (tempfile = alloca (strlen (outf) + 20), outf);
1040 else
1042 tempfile = alloca (20);
1043 *tempfile = '\0';
1045 if (!IS_DIRECTORY_SEP (tempfile[strlen (tempfile) - 1]))
1046 strcat (tempfile, "/");
1047 if ('/' == DIRECTORY_SEP)
1048 dostounix_filename (tempfile);
1049 else
1050 unixtodos_filename (tempfile);
1051 #ifdef WINDOWSNT
1052 strcat (tempfile, "emXXXXXX");
1053 #else
1054 strcat (tempfile, "detmp.XXX");
1055 #endif
1056 #else /* not DOS_NT */
1057 char *tempfile = (char *) alloca (SBYTES (Vtemp_file_name_pattern) + 1);
1058 bcopy (SDATA (Vtemp_file_name_pattern), tempfile,
1059 SBYTES (Vtemp_file_name_pattern) + 1);
1060 #endif /* not DOS_NT */
1062 coding_systems = Qt;
1064 #ifdef HAVE_MKSTEMP
1066 int fd = mkstemp (tempfile);
1067 if (fd == -1)
1068 report_file_error ("Failed to open temporary file",
1069 Fcons (Vtemp_file_name_pattern, Qnil));
1070 else
1071 close (fd);
1073 #else
1074 mktemp (tempfile);
1075 #endif
1077 filename_string = build_string (tempfile);
1078 GCPRO1 (filename_string);
1079 start = args[0];
1080 end = args[1];
1081 /* Decide coding-system of the contents of the temporary file. */
1082 if (!NILP (Vcoding_system_for_write))
1083 val = Vcoding_system_for_write;
1084 else if (NILP (current_buffer->enable_multibyte_characters))
1085 val = Qnil;
1086 else
1088 args2 = (Lisp_Object *) alloca ((nargs + 1) * sizeof *args2);
1089 args2[0] = Qcall_process_region;
1090 for (i = 0; i < nargs; i++) args2[i + 1] = args[i];
1091 coding_systems = Ffind_operation_coding_system (nargs + 1, args2);
1092 if (CONSP (coding_systems))
1093 val = XCDR (coding_systems);
1094 else if (CONSP (Vdefault_process_coding_system))
1095 val = XCDR (Vdefault_process_coding_system);
1096 else
1097 val = Qnil;
1101 int count1 = SPECPDL_INDEX ();
1103 specbind (intern ("coding-system-for-write"), val);
1104 Fwrite_region (start, end, filename_string, Qnil, Qlambda, Qnil, Qnil);
1106 unbind_to (count1, Qnil);
1109 /* Note that Fcall_process takes care of binding
1110 coding-system-for-read. */
1112 record_unwind_protect (delete_temp_file, filename_string);
1114 if (nargs > 3 && !NILP (args[3]))
1115 Fdelete_region (start, end);
1117 if (nargs > 3)
1119 args += 2;
1120 nargs -= 2;
1122 else
1124 args[0] = args[2];
1125 nargs = 2;
1127 args[1] = filename_string;
1129 RETURN_UNGCPRO (unbind_to (count, Fcall_process (nargs, args)));
1132 #ifndef VMS /* VMS version is in vmsproc.c. */
1134 static int relocate_fd ();
1136 /* This is the last thing run in a newly forked inferior
1137 either synchronous or asynchronous.
1138 Copy descriptors IN, OUT and ERR as descriptors 0, 1 and 2.
1139 Initialize inferior's priority, pgrp, connected dir and environment.
1140 then exec another program based on new_argv.
1142 This function may change environ for the superior process.
1143 Therefore, the superior process must save and restore the value
1144 of environ around the vfork and the call to this function.
1146 SET_PGRP is nonzero if we should put the subprocess into a separate
1147 process group.
1149 CURRENT_DIR is an elisp string giving the path of the current
1150 directory the subprocess should have. Since we can't really signal
1151 a decent error from within the child, this should be verified as an
1152 executable directory by the parent. */
1155 child_setup (in, out, err, new_argv, set_pgrp, current_dir)
1156 int in, out, err;
1157 register char **new_argv;
1158 int set_pgrp;
1159 Lisp_Object current_dir;
1161 char **env;
1162 char *pwd_var;
1163 #ifdef WINDOWSNT
1164 int cpid;
1165 HANDLE handles[3];
1166 #endif /* WINDOWSNT */
1168 int pid = getpid ();
1170 #ifdef SET_EMACS_PRIORITY
1172 extern EMACS_INT emacs_priority;
1174 if (emacs_priority < 0)
1175 nice (- emacs_priority);
1177 #endif
1179 #ifdef subprocesses
1180 /* Close Emacs's descriptors that this process should not have. */
1181 close_process_descs ();
1182 #endif
1183 /* DOS_NT isn't in a vfork, so if we are in the middle of load-file,
1184 we will lose if we call close_load_descs here. */
1185 #ifndef DOS_NT
1186 close_load_descs ();
1187 #endif
1189 /* Note that use of alloca is always safe here. It's obvious for systems
1190 that do not have true vfork or that have true (stack) alloca.
1191 If using vfork and C_ALLOCA it is safe because that changes
1192 the superior's static variables as if the superior had done alloca
1193 and will be cleaned up in the usual way. */
1195 register char *temp;
1196 register int i;
1198 i = SBYTES (current_dir);
1199 #ifdef MSDOS
1200 /* MSDOS must have all environment variables malloc'ed, because
1201 low-level libc functions that launch subsidiary processes rely
1202 on that. */
1203 pwd_var = (char *) xmalloc (i + 6);
1204 #else
1205 pwd_var = (char *) alloca (i + 6);
1206 #endif
1207 temp = pwd_var + 4;
1208 bcopy ("PWD=", pwd_var, 4);
1209 bcopy (SDATA (current_dir), temp, i);
1210 if (!IS_DIRECTORY_SEP (temp[i - 1])) temp[i++] = DIRECTORY_SEP;
1211 temp[i] = 0;
1213 #ifndef DOS_NT
1214 /* We can't signal an Elisp error here; we're in a vfork. Since
1215 the callers check the current directory before forking, this
1216 should only return an error if the directory's permissions
1217 are changed between the check and this chdir, but we should
1218 at least check. */
1219 if (chdir (temp) < 0)
1220 _exit (errno);
1221 #endif
1223 #ifdef DOS_NT
1224 /* Get past the drive letter, so that d:/ is left alone. */
1225 if (i > 2 && IS_DEVICE_SEP (temp[1]) && IS_DIRECTORY_SEP (temp[2]))
1227 temp += 2;
1228 i -= 2;
1230 #endif
1232 /* Strip trailing slashes for PWD, but leave "/" and "//" alone. */
1233 while (i > 2 && IS_DIRECTORY_SEP (temp[i - 1]))
1234 temp[--i] = 0;
1237 /* Set `env' to a vector of the strings in Vprocess_environment. */
1239 register Lisp_Object tem;
1240 register char **new_env;
1241 register int new_length;
1243 new_length = 0;
1244 for (tem = Vprocess_environment;
1245 CONSP (tem) && STRINGP (XCAR (tem));
1246 tem = XCDR (tem))
1247 new_length++;
1249 /* new_length + 2 to include PWD and terminating 0. */
1250 env = new_env = (char **) alloca ((new_length + 2) * sizeof (char *));
1252 /* If we have a PWD envvar, pass one down,
1253 but with corrected value. */
1254 if (getenv ("PWD"))
1255 *new_env++ = pwd_var;
1257 /* Copy the Vprocess_environment strings into new_env. */
1258 for (tem = Vprocess_environment;
1259 CONSP (tem) && STRINGP (XCAR (tem));
1260 tem = XCDR (tem))
1262 char **ep = env;
1263 char *string = (char *) SDATA (XCAR (tem));
1264 /* See if this string duplicates any string already in the env.
1265 If so, don't put it in.
1266 When an env var has multiple definitions,
1267 we keep the definition that comes first in process-environment. */
1268 for (; ep != new_env; ep++)
1270 char *p = *ep, *q = string;
1271 while (1)
1273 if (*q == 0)
1274 /* The string is malformed; might as well drop it. */
1275 goto duplicate;
1276 if (*q != *p)
1277 break;
1278 if (*q == '=')
1279 goto duplicate;
1280 p++, q++;
1283 *new_env++ = string;
1284 duplicate: ;
1286 *new_env = 0;
1288 #ifdef WINDOWSNT
1289 prepare_standard_handles (in, out, err, handles);
1290 set_process_dir (SDATA (current_dir));
1291 #else /* not WINDOWSNT */
1292 /* Make sure that in, out, and err are not actually already in
1293 descriptors zero, one, or two; this could happen if Emacs is
1294 started with its standard in, out, or error closed, as might
1295 happen under X. */
1297 int oin = in, oout = out;
1299 /* We have to avoid relocating the same descriptor twice! */
1301 in = relocate_fd (in, 3);
1303 if (out == oin)
1304 out = in;
1305 else
1306 out = relocate_fd (out, 3);
1308 if (err == oin)
1309 err = in;
1310 else if (err == oout)
1311 err = out;
1312 else
1313 err = relocate_fd (err, 3);
1316 #ifndef MSDOS
1317 emacs_close (0);
1318 emacs_close (1);
1319 emacs_close (2);
1321 dup2 (in, 0);
1322 dup2 (out, 1);
1323 dup2 (err, 2);
1324 emacs_close (in);
1325 emacs_close (out);
1326 emacs_close (err);
1327 #endif /* not MSDOS */
1328 #endif /* not WINDOWSNT */
1330 #if defined(USG) && !defined(BSD_PGRPS)
1331 #ifndef SETPGRP_RELEASES_CTTY
1332 setpgrp (); /* No arguments but equivalent in this case */
1333 #endif
1334 #else
1335 setpgrp (pid, pid);
1336 #endif /* USG */
1337 /* setpgrp_of_tty is incorrect here; it uses input_fd. */
1338 EMACS_SET_TTY_PGRP (0, &pid);
1340 #ifdef MSDOS
1341 pid = run_msdos_command (new_argv, pwd_var + 4, in, out, err, env);
1342 xfree (pwd_var);
1343 if (pid == -1)
1344 /* An error occurred while trying to run the subprocess. */
1345 report_file_error ("Spawning child process", Qnil);
1346 return pid;
1347 #else /* not MSDOS */
1348 #ifdef WINDOWSNT
1349 /* Spawn the child. (See ntproc.c:Spawnve). */
1350 cpid = spawnve (_P_NOWAIT, new_argv[0], new_argv, env);
1351 reset_standard_handles (in, out, err, handles);
1352 if (cpid == -1)
1353 /* An error occurred while trying to spawn the process. */
1354 report_file_error ("Spawning child process", Qnil);
1355 return cpid;
1356 #else /* not WINDOWSNT */
1357 /* execvp does not accept an environment arg so the only way
1358 to pass this environment is to set environ. Our caller
1359 is responsible for restoring the ambient value of environ. */
1360 environ = env;
1361 execvp (new_argv[0], new_argv);
1363 emacs_write (1, "Can't exec program: ", 20);
1364 emacs_write (1, new_argv[0], strlen (new_argv[0]));
1365 emacs_write (1, "\n", 1);
1366 _exit (1);
1367 #endif /* not WINDOWSNT */
1368 #endif /* not MSDOS */
1371 /* Move the file descriptor FD so that its number is not less than MINFD.
1372 If the file descriptor is moved at all, the original is freed. */
1373 static int
1374 relocate_fd (fd, minfd)
1375 int fd, minfd;
1377 if (fd >= minfd)
1378 return fd;
1379 else
1381 int new = dup (fd);
1382 if (new == -1)
1384 char *message1 = "Error while setting up child: ";
1385 char *errmessage = strerror (errno);
1386 char *message2 = "\n";
1387 emacs_write (2, message1, strlen (message1));
1388 emacs_write (2, errmessage, strlen (errmessage));
1389 emacs_write (2, message2, strlen (message2));
1390 _exit (1);
1392 /* Note that we hold the original FD open while we recurse,
1393 to guarantee we'll get a new FD if we need it. */
1394 new = relocate_fd (new, minfd);
1395 emacs_close (fd);
1396 return new;
1400 static int
1401 getenv_internal (var, varlen, value, valuelen)
1402 char *var;
1403 int varlen;
1404 char **value;
1405 int *valuelen;
1407 Lisp_Object scan;
1409 for (scan = Vprocess_environment; CONSP (scan); scan = XCDR (scan))
1411 Lisp_Object entry;
1413 entry = XCAR (scan);
1414 if (STRINGP (entry)
1415 && SBYTES (entry) > varlen
1416 && SREF (entry, varlen) == '='
1417 #ifdef WINDOWSNT
1418 /* NT environment variables are case insensitive. */
1419 && ! strnicmp (SDATA (entry), var, varlen)
1420 #else /* not WINDOWSNT */
1421 && ! bcmp (SDATA (entry), var, varlen)
1422 #endif /* not WINDOWSNT */
1425 *value = (char *) SDATA (entry) + (varlen + 1);
1426 *valuelen = SBYTES (entry) - (varlen + 1);
1427 return 1;
1431 return 0;
1434 DEFUN ("getenv-internal", Fgetenv_internal, Sgetenv_internal, 1, 1, 0,
1435 doc: /* Return the value of environment variable VAR, as a string.
1436 VAR should be a string. Value is nil if VAR is undefined in the environment.
1437 This function consults the variable ``process-environment'' for its value. */)
1438 (var)
1439 Lisp_Object var;
1441 char *value;
1442 int valuelen;
1444 CHECK_STRING (var);
1445 if (getenv_internal (SDATA (var), SBYTES (var),
1446 &value, &valuelen))
1447 return make_string (value, valuelen);
1448 else
1449 return Qnil;
1452 /* A version of getenv that consults process_environment, easily
1453 callable from C. */
1454 char *
1455 egetenv (var)
1456 char *var;
1458 char *value;
1459 int valuelen;
1461 if (getenv_internal (var, strlen (var), &value, &valuelen))
1462 return value;
1463 else
1464 return 0;
1467 #endif /* not VMS */
1469 /* This is run before init_cmdargs. */
1471 void
1472 init_callproc_1 ()
1474 char *data_dir = egetenv ("EMACSDATA");
1475 char *doc_dir = egetenv ("EMACSDOC");
1477 Vdata_directory
1478 = Ffile_name_as_directory (build_string (data_dir ? data_dir
1479 : PATH_DATA));
1480 Vdoc_directory
1481 = Ffile_name_as_directory (build_string (doc_dir ? doc_dir
1482 : PATH_DOC));
1484 /* Check the EMACSPATH environment variable, defaulting to the
1485 PATH_EXEC path from epaths.h. */
1486 Vexec_path = decode_env_path ("EMACSPATH", PATH_EXEC);
1487 Vexec_directory = Ffile_name_as_directory (Fcar (Vexec_path));
1488 Vexec_path = nconc2 (decode_env_path ("PATH", ""), Vexec_path);
1491 /* This is run after init_cmdargs, when Vinstallation_directory is valid. */
1493 void
1494 init_callproc ()
1496 char *data_dir = egetenv ("EMACSDATA");
1498 register char * sh;
1499 Lisp_Object tempdir;
1501 if (!NILP (Vinstallation_directory))
1503 /* Add to the path the lib-src subdir of the installation dir. */
1504 Lisp_Object tem;
1505 tem = Fexpand_file_name (build_string ("lib-src"),
1506 Vinstallation_directory);
1507 #ifndef DOS_NT
1508 /* MSDOS uses wrapped binaries, so don't do this. */
1509 if (NILP (Fmember (tem, Vexec_path)))
1511 Vexec_path = decode_env_path ("EMACSPATH", PATH_EXEC);
1512 Vexec_path = Fcons (tem, Vexec_path);
1513 Vexec_path = nconc2 (decode_env_path ("PATH", ""), Vexec_path);
1516 Vexec_directory = Ffile_name_as_directory (tem);
1517 #endif /* not DOS_NT */
1519 /* Maybe use ../etc as well as ../lib-src. */
1520 if (data_dir == 0)
1522 tem = Fexpand_file_name (build_string ("etc"),
1523 Vinstallation_directory);
1524 Vdoc_directory = Ffile_name_as_directory (tem);
1528 /* Look for the files that should be in etc. We don't use
1529 Vinstallation_directory, because these files are never installed
1530 near the executable, and they are never in the build
1531 directory when that's different from the source directory.
1533 Instead, if these files are not in the nominal place, we try the
1534 source directory. */
1535 if (data_dir == 0)
1537 Lisp_Object tem, tem1, srcdir;
1539 srcdir = Fexpand_file_name (build_string ("../src/"),
1540 build_string (PATH_DUMPLOADSEARCH));
1541 tem = Fexpand_file_name (build_string ("GNU"), Vdata_directory);
1542 tem1 = Ffile_exists_p (tem);
1543 if (!NILP (Fequal (srcdir, Vinvocation_directory)) || NILP (tem1))
1545 Lisp_Object newdir;
1546 newdir = Fexpand_file_name (build_string ("../etc/"),
1547 build_string (PATH_DUMPLOADSEARCH));
1548 tem = Fexpand_file_name (build_string ("GNU"), newdir);
1549 tem1 = Ffile_exists_p (tem);
1550 if (!NILP (tem1))
1551 Vdata_directory = newdir;
1555 #ifndef CANNOT_DUMP
1556 if (initialized)
1557 #endif
1559 tempdir = Fdirectory_file_name (Vexec_directory);
1560 if (access (SDATA (tempdir), 0) < 0)
1561 dir_warning ("Warning: arch-dependent data dir (%s) does not exist.\n",
1562 Vexec_directory);
1565 tempdir = Fdirectory_file_name (Vdata_directory);
1566 if (access (SDATA (tempdir), 0) < 0)
1567 dir_warning ("Warning: arch-independent data dir (%s) does not exist.\n",
1568 Vdata_directory);
1570 #ifdef VMS
1571 Vshell_file_name = build_string ("*dcl*");
1572 #else
1573 sh = (char *) getenv ("SHELL");
1574 Vshell_file_name = build_string (sh ? sh : "/bin/sh");
1575 #endif
1577 #ifdef VMS
1578 Vtemp_file_name_pattern = build_string ("tmp:emacsXXXXXX.");
1579 #else
1580 if (getenv ("TMPDIR"))
1582 char *dir = getenv ("TMPDIR");
1583 Vtemp_file_name_pattern
1584 = Fexpand_file_name (build_string ("emacsXXXXXX"),
1585 build_string (dir));
1587 else
1588 Vtemp_file_name_pattern = build_string ("/tmp/emacsXXXXXX");
1589 #endif
1591 #ifdef DOS_NT
1592 Vshared_game_score_directory = Qnil;
1593 #else
1594 Vshared_game_score_directory = build_string (PATH_GAME);
1595 if (NILP (Ffile_directory_p (Vshared_game_score_directory)))
1596 Vshared_game_score_directory = Qnil;
1597 #endif
1600 void
1601 set_process_environment ()
1603 register char **envp;
1605 Vprocess_environment = Qnil;
1606 #ifndef CANNOT_DUMP
1607 if (initialized)
1608 #endif
1609 for (envp = environ; *envp; envp++)
1610 Vprocess_environment = Fcons (build_string (*envp),
1611 Vprocess_environment);
1614 void
1615 syms_of_callproc ()
1617 #ifdef DOS_NT
1618 Qbuffer_file_type = intern ("buffer-file-type");
1619 staticpro (&Qbuffer_file_type);
1620 #endif /* DOS_NT */
1622 DEFVAR_LISP ("shell-file-name", &Vshell_file_name,
1623 doc: /* *File name to load inferior shells from.
1624 Initialized from the SHELL environment variable. */);
1626 DEFVAR_LISP ("exec-path", &Vexec_path,
1627 doc: /* *List of directories to search programs to run in subprocesses.
1628 Each element is a string (directory name) or nil (try default directory). */);
1630 DEFVAR_LISP ("exec-suffixes", &Vexec_suffixes,
1631 doc: /* *List of suffixes to try to find executable file names.
1632 Each element is a string. */);
1633 Vexec_suffixes = Qnil;
1635 DEFVAR_LISP ("exec-directory", &Vexec_directory,
1636 doc: /* Directory for executables for Emacs to invoke.
1637 More generally, this includes any architecture-dependent files
1638 that are built and installed from the Emacs distribution. */);
1640 DEFVAR_LISP ("data-directory", &Vdata_directory,
1641 doc: /* Directory of machine-independent files that come with GNU Emacs.
1642 These are files intended for Emacs to use while it runs. */);
1644 DEFVAR_LISP ("doc-directory", &Vdoc_directory,
1645 doc: /* Directory containing the DOC file that comes with GNU Emacs.
1646 This is usually the same as data-directory. */);
1648 DEFVAR_LISP ("configure-info-directory", &Vconfigure_info_directory,
1649 doc: /* For internal use by the build procedure only.
1650 This is the name of the directory in which the build procedure installed
1651 Emacs's info files; the default value for Info-default-directory-list
1652 includes this. */);
1653 Vconfigure_info_directory = build_string (PATH_INFO);
1655 DEFVAR_LISP ("shared-game-score-directory", &Vshared_game_score_directory,
1656 doc: /* Directory of score files for games which come with GNU Emacs.
1657 If this variable is nil, then Emacs is unable to use a shared directory. */);
1658 #ifdef DOS_NT
1659 Vshared_game_score_directory = Qnil;
1660 #else
1661 Vshared_game_score_directory = build_string (PATH_GAME);
1662 #endif
1664 DEFVAR_LISP ("temp-file-name-pattern", &Vtemp_file_name_pattern,
1665 doc: /* Pattern for making names for temporary files.
1666 This is used by `call-process-region'. */);
1667 /* This variable is initialized in init_callproc. */
1669 DEFVAR_LISP ("process-environment", &Vprocess_environment,
1670 doc: /* List of environment variables for subprocesses to inherit.
1671 Each element should be a string of the form ENVVARNAME=VALUE.
1672 If multiple entries define the same variable, the first one always
1673 takes precedence.
1674 The environment which Emacs inherits is placed in this variable
1675 when Emacs starts.
1676 Non-ASCII characters are encoded according to the initial value of
1677 `locale-coding-system', i.e. the elements must normally be decoded for use.
1678 See `setenv' and `getenv'. */);
1680 #ifndef VMS
1681 defsubr (&Scall_process);
1682 defsubr (&Sgetenv_internal);
1683 #endif
1684 defsubr (&Scall_process_region);
1687 /* arch-tag: 769b8045-1df7-4d2b-8968-e3fb49017f95
1688 (do not change this comment) */