*** empty log message ***
[emacs.git] / src / callproc.c
blob1a3ff6fcca903ccfedf3a65bedaa1e0649911559
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 USG5
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 (XSTRING (file)-> data, NULL_DEVICE) != 0)
163 unlink (XSTRING (file)->data);
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_ptr - specpdl;
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_ptr - specpdl;
225 register unsigned char **new_argv
226 = (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 (XSTRING (infile)->data, 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));
392 new_argv[0] = XSTRING (path)->data;
393 if (nargs > 4)
395 register int i;
396 struct gcpro gcpro1, gcpro2, gcpro3;
398 GCPRO3 (infile, buffer, current_dir);
399 argument_coding.dst_multibyte = 0;
400 for (i = 4; i < nargs; i++)
402 argument_coding.src_multibyte = STRING_MULTIBYTE (args[i]);
403 if (CODING_REQUIRE_ENCODING (&argument_coding))
405 /* We must encode this argument. */
406 args[i] = encode_coding_string (args[i], &argument_coding, 1);
407 if (argument_coding.type == coding_type_ccl)
408 setup_ccl_program (&(argument_coding.spec.ccl.encoder), Qnil);
410 new_argv[i - 3] = XSTRING (args[i])->data;
412 UNGCPRO;
413 new_argv[nargs - 3] = 0;
415 else
416 new_argv[1] = 0;
418 #ifdef MSDOS /* MW, July 1993 */
419 if ((outf = egetenv ("TMPDIR")))
420 strcpy (tempfile = alloca (strlen (outf) + 20), outf);
421 else
423 tempfile = alloca (20);
424 *tempfile = '\0';
426 dostounix_filename (tempfile);
427 if (*tempfile == '\0' || tempfile[strlen (tempfile) - 1] != '/')
428 strcat (tempfile, "/");
429 strcat (tempfile, "detmp.XXX");
430 mktemp (tempfile);
432 outfilefd = creat (tempfile, S_IREAD | S_IWRITE);
433 if (outfilefd < 0)
435 emacs_close (filefd);
436 report_file_error ("Opening process output file",
437 Fcons (build_string (tempfile), Qnil));
439 fd[0] = filefd;
440 fd[1] = outfilefd;
441 #endif /* MSDOS */
443 #ifdef MAC_OS8
444 /* Since we don't have pipes on the Mac, create a temporary file to
445 hold the output of the subprocess. */
446 tempfile = (char *) alloca (STRING_BYTES (XSTRING (Vtemp_file_name_pattern)) + 1);
447 bcopy (XSTRING (Vtemp_file_name_pattern)->data, tempfile,
448 STRING_BYTES (XSTRING (Vtemp_file_name_pattern)) + 1);
450 mktemp (tempfile);
452 outfilefd = creat (tempfile, S_IREAD | S_IWRITE);
453 if (outfilefd < 0)
455 close (filefd);
456 report_file_error ("Opening process output file",
457 Fcons (build_string (tempfile), Qnil));
459 fd[0] = filefd;
460 fd[1] = outfilefd;
461 #endif /* MAC_OS8 */
463 if (INTEGERP (buffer))
464 fd[1] = emacs_open (NULL_DEVICE, O_WRONLY, 0), fd[0] = -1;
465 else
467 #ifndef MSDOS
468 #ifndef MAC_OS8
469 errno = 0;
470 if (pipe (fd) == -1)
472 emacs_close (filefd);
473 report_file_error ("Creating process pipe", Qnil);
475 #endif
476 #endif
477 #if 0
478 /* Replaced by close_process_descs */
479 set_exclusive_use (fd[0]);
480 #endif
484 /* child_setup must clobber environ in systems with true vfork.
485 Protect it from permanent change. */
486 register char **save_environ = environ;
487 register int fd1 = fd[1];
488 int fd_error = fd1;
490 #if 0 /* Some systems don't have sigblock. */
491 mask = sigblock (sigmask (SIGCHLD));
492 #endif
494 /* Record that we're about to create a synchronous process. */
495 synch_process_alive = 1;
497 /* These vars record information from process termination.
498 Clear them now before process can possibly terminate,
499 to avoid timing error if process terminates soon. */
500 synch_process_death = 0;
501 synch_process_retcode = 0;
503 if (NILP (error_file))
504 fd_error = emacs_open (NULL_DEVICE, O_WRONLY, 0);
505 else if (STRINGP (error_file))
507 #ifdef DOS_NT
508 fd_error = emacs_open (XSTRING (error_file)->data,
509 O_WRONLY | O_TRUNC | O_CREAT | O_TEXT,
510 S_IREAD | S_IWRITE);
511 #else /* not DOS_NT */
512 fd_error = creat (XSTRING (error_file)->data, 0666);
513 #endif /* not DOS_NT */
516 if (fd_error < 0)
518 emacs_close (filefd);
519 if (fd[0] != filefd)
520 emacs_close (fd[0]);
521 if (fd1 >= 0)
522 emacs_close (fd1);
523 #ifdef MSDOS
524 unlink (tempfile);
525 #endif
526 report_file_error ("Cannot redirect stderr",
527 Fcons ((NILP (error_file)
528 ? build_string (NULL_DEVICE) : error_file),
529 Qnil));
532 current_dir = ENCODE_FILE (current_dir);
534 #ifdef MAC_OS8
536 /* Call run_mac_command in sysdep.c here directly instead of doing
537 a child_setup as for MSDOS and other platforms. Note that this
538 code does not handle passing the environment to the synchronous
539 Mac subprocess. */
540 char *infn, *outfn, *errfn, *currdn;
542 /* close these files so subprocess can write to them */
543 close (outfilefd);
544 if (fd_error != outfilefd)
545 close (fd_error);
546 fd1 = -1; /* No harm in closing that one! */
548 infn = XSTRING (infile)->data;
549 outfn = tempfile;
550 if (NILP (error_file))
551 errfn = NULL_DEVICE;
552 else if (EQ (Qt, error_file))
553 errfn = outfn;
554 else
555 errfn = XSTRING (error_file)->data;
556 currdn = XSTRING (current_dir)->data;
557 pid = run_mac_command (new_argv, currdn, infn, outfn, errfn);
559 /* Record that the synchronous process exited and note its
560 termination status. */
561 synch_process_alive = 0;
562 synch_process_retcode = pid;
563 if (synch_process_retcode < 0) /* means it couldn't be exec'ed */
565 synchronize_system_messages_locale ();
566 synch_process_death = strerror (errno);
569 /* Since CRLF is converted to LF within `decode_coding', we can
570 always open a file with binary mode. */
571 fd[0] = open (tempfile, O_BINARY);
572 if (fd[0] < 0)
574 unlink (tempfile);
575 close (filefd);
576 report_file_error ("Cannot re-open temporary file", Qnil);
579 #else /* not MAC_OS8 */
580 #ifdef MSDOS /* MW, July 1993 */
581 /* Note that on MSDOS `child_setup' actually returns the child process
582 exit status, not its PID, so we assign it to `synch_process_retcode'
583 below. */
584 pid = child_setup (filefd, outfilefd, fd_error, (char **) new_argv,
585 0, current_dir);
587 /* Record that the synchronous process exited and note its
588 termination status. */
589 synch_process_alive = 0;
590 synch_process_retcode = pid;
591 if (synch_process_retcode < 0) /* means it couldn't be exec'ed */
593 synchronize_system_messages_locale ();
594 synch_process_death = strerror (errno);
597 emacs_close (outfilefd);
598 if (fd_error != outfilefd)
599 emacs_close (fd_error);
600 fd1 = -1; /* No harm in closing that one! */
601 /* Since CRLF is converted to LF within `decode_coding', we can
602 always open a file with binary mode. */
603 fd[0] = emacs_open (tempfile, O_RDONLY | O_BINARY, 0);
604 if (fd[0] < 0)
606 unlink (tempfile);
607 emacs_close (filefd);
608 report_file_error ("Cannot re-open temporary file", Qnil);
610 #else /* not MSDOS */
611 #ifdef WINDOWSNT
612 pid = child_setup (filefd, fd1, fd_error, (char **) new_argv,
613 0, current_dir);
614 #else /* not WINDOWSNT */
615 pid = vfork ();
617 if (pid == 0)
619 if (fd[0] >= 0)
620 emacs_close (fd[0]);
621 #ifdef HAVE_SETSID
622 setsid ();
623 #endif
624 #if defined (USG) && !defined (BSD_PGRPS)
625 setpgrp ();
626 #else
627 setpgrp (pid, pid);
628 #endif /* USG */
629 child_setup (filefd, fd1, fd_error, (char **) new_argv,
630 0, current_dir);
632 #endif /* not WINDOWSNT */
634 /* The MSDOS case did this already. */
635 if (fd_error >= 0)
636 emacs_close (fd_error);
637 #endif /* not MSDOS */
638 #endif /* not MAC_OS8 */
640 environ = save_environ;
642 /* Close most of our fd's, but not fd[0]
643 since we will use that to read input from. */
644 emacs_close (filefd);
645 if (fd1 >= 0 && fd1 != fd_error)
646 emacs_close (fd1);
649 if (pid < 0)
651 if (fd[0] >= 0)
652 emacs_close (fd[0]);
653 report_file_error ("Doing vfork", Qnil);
656 if (INTEGERP (buffer))
658 if (fd[0] >= 0)
659 emacs_close (fd[0]);
660 #ifndef subprocesses
661 /* If Emacs has been built with asynchronous subprocess support,
662 we don't need to do this, I think because it will then have
663 the facilities for handling SIGCHLD. */
664 wait_without_blocking ();
665 #endif /* subprocesses */
666 return Qnil;
669 /* Enable sending signal if user quits below. */
670 call_process_exited = 0;
672 #if defined(MSDOS) || defined(MAC_OS8)
673 /* MSDOS needs different cleanup information. */
674 record_unwind_protect (call_process_cleanup,
675 Fcons (make_number (fd[0]), build_string (tempfile)));
676 #else
677 record_unwind_protect (call_process_cleanup,
678 Fcons (make_number (fd[0]), make_number (pid)));
679 #endif /* not MSDOS and not MAC_OS8 */
682 if (BUFFERP (buffer))
683 Fset_buffer (buffer);
685 if (NILP (buffer))
687 /* If BUFFER is nil, we must read process output once and then
688 discard it, so setup coding system but with nil. */
689 setup_coding_system (Qnil, &process_coding);
691 else
693 Lisp_Object val, *args2;
695 val = Qnil;
696 if (!NILP (Vcoding_system_for_read))
697 val = Vcoding_system_for_read;
698 else
700 if (EQ (coding_systems, Qt))
702 int i;
704 args2 = (Lisp_Object *) alloca ((nargs + 1) * sizeof *args2);
705 args2[0] = Qcall_process;
706 for (i = 0; i < nargs; i++) args2[i + 1] = args[i];
707 coding_systems
708 = Ffind_operation_coding_system (nargs + 1, args2);
710 if (CONSP (coding_systems))
711 val = XCAR (coding_systems);
712 else if (CONSP (Vdefault_process_coding_system))
713 val = XCAR (Vdefault_process_coding_system);
714 else
715 val = Qnil;
717 setup_coding_system (Fcheck_coding_system (val), &process_coding);
718 /* In unibyte mode, character code conversion should not take
719 place but EOL conversion should. So, setup raw-text or one
720 of the subsidiary according to the information just setup. */
721 if (NILP (current_buffer->enable_multibyte_characters)
722 && !NILP (val))
723 setup_raw_text_coding_system (&process_coding);
725 process_coding.src_multibyte = 0;
726 process_coding.dst_multibyte
727 = (BUFFERP (buffer)
728 ? ! NILP (XBUFFER (buffer)->enable_multibyte_characters)
729 : ! NILP (current_buffer->enable_multibyte_characters));
731 immediate_quit = 1;
732 QUIT;
735 register int nread;
736 int first = 1;
737 int total_read = 0;
738 int carryover = 0;
739 int display_on_the_fly = !NILP (display) && INTERACTIVE;
740 struct coding_system saved_coding;
741 int pt_orig = PT, pt_byte_orig = PT_BYTE;
742 int inserted;
744 saved_coding = process_coding;
745 if (process_coding.composing != COMPOSITION_DISABLED)
746 coding_allocate_composition_data (&process_coding, PT);
747 while (1)
749 /* Repeatedly read until we've filled as much as possible
750 of the buffer size we have. But don't read
751 less than 1024--save that for the next bufferful. */
752 nread = carryover;
753 while (nread < bufsize - 1024)
755 int this_read = emacs_read (fd[0], bufptr + nread,
756 bufsize - nread);
758 if (this_read < 0)
759 goto give_up;
761 if (this_read == 0)
763 process_coding.mode |= CODING_MODE_LAST_BLOCK;
764 break;
767 nread += this_read;
768 total_read += this_read;
770 if (display_on_the_fly)
771 break;
774 /* Now NREAD is the total amount of data in the buffer. */
775 immediate_quit = 0;
777 if (!NILP (buffer))
779 if (! CODING_MAY_REQUIRE_DECODING (&process_coding))
780 insert_1_both (bufptr, nread, nread, 0, 1, 0);
781 else
782 { /* We have to decode the input. */
783 int size;
784 char *decoding_buf;
786 repeat_decoding:
787 size = decoding_buffer_size (&process_coding, nread);
788 decoding_buf = (char *) xmalloc (size);
790 if (process_coding.cmp_data)
791 process_coding.cmp_data->char_offset = PT;
793 decode_coding (&process_coding, bufptr, decoding_buf,
794 nread, size);
796 if (display_on_the_fly
797 && saved_coding.type == coding_type_undecided
798 && process_coding.type != coding_type_undecided)
800 /* We have detected some coding system. But,
801 there's a possibility that the detection was
802 done by insufficient data. So, we give up
803 displaying on the fly. */
804 xfree (decoding_buf);
805 display_on_the_fly = 0;
806 process_coding = saved_coding;
807 carryover = nread;
808 continue;
811 if (process_coding.produced > 0)
812 insert_1_both (decoding_buf, process_coding.produced_char,
813 process_coding.produced, 0, 1, 0);
814 xfree (decoding_buf);
816 if (process_coding.result == CODING_FINISH_INCONSISTENT_EOL)
818 Lisp_Object eol_type, coding;
820 if (process_coding.eol_type == CODING_EOL_CR)
822 /* CRs have been replaced with LFs. Undo
823 that in the text inserted above. */
824 unsigned char *p;
826 move_gap_both (PT, PT_BYTE);
828 p = BYTE_POS_ADDR (pt_byte_orig);
829 for (; p < GPT_ADDR; ++p)
830 if (*p == '\n')
831 *p = '\r';
833 else if (process_coding.eol_type == CODING_EOL_CRLF)
835 /* CR LFs have been replaced with LFs. Undo
836 that by inserting CRs in front of LFs in
837 the text inserted above. */
838 EMACS_INT bytepos, old_pt, old_pt_byte, nCR;
840 old_pt = PT;
841 old_pt_byte = PT_BYTE;
842 nCR = 0;
844 for (bytepos = PT_BYTE - 1;
845 bytepos >= pt_byte_orig;
846 --bytepos)
847 if (FETCH_BYTE (bytepos) == '\n')
849 EMACS_INT charpos = BYTE_TO_CHAR (bytepos);
850 TEMP_SET_PT_BOTH (charpos, bytepos);
851 insert_1_both ("\r", 1, 1, 0, 1, 0);
852 ++nCR;
855 TEMP_SET_PT_BOTH (old_pt + nCR, old_pt_byte + nCR);
858 /* Set the coding system symbol to that for
859 Unix-like EOL. */
860 eol_type = Fget (saved_coding.symbol, Qeol_type);
861 if (VECTORP (eol_type)
862 && ASIZE (eol_type) == 3
863 && SYMBOLP (AREF (eol_type, CODING_EOL_LF)))
864 coding = AREF (eol_type, CODING_EOL_LF);
865 else
866 coding = saved_coding.symbol;
868 process_coding.symbol = coding;
869 process_coding.eol_type = CODING_EOL_LF;
870 process_coding.mode
871 &= ~CODING_MODE_INHIBIT_INCONSISTENT_EOL;
874 nread -= process_coding.consumed;
875 carryover = nread;
876 if (carryover > 0)
877 /* As CARRYOVER should not be that large, we had
878 better avoid overhead of bcopy. */
879 BCOPY_SHORT (bufptr + process_coding.consumed, bufptr,
880 carryover);
881 if (process_coding.result == CODING_FINISH_INSUFFICIENT_CMP)
883 /* The decoding ended because of insufficient data
884 area to record information about composition.
885 We must try decoding with additional data area
886 before reading more output for the process. */
887 coding_allocate_composition_data (&process_coding, PT);
888 goto repeat_decoding;
893 if (process_coding.mode & CODING_MODE_LAST_BLOCK)
894 break;
896 /* Make the buffer bigger as we continue to read more data,
897 but not past 64k. */
898 if (bufsize < 64 * 1024 && total_read > 32 * bufsize)
900 char *tempptr;
901 bufsize *= 2;
903 tempptr = (char *) alloca (bufsize);
904 bcopy (bufptr, tempptr, bufsize / 2);
905 bufptr = tempptr;
908 if (!NILP (display) && INTERACTIVE)
910 if (first)
911 prepare_menu_bars ();
912 first = 0;
913 redisplay_preserve_echo_area (1);
915 immediate_quit = 1;
916 QUIT;
918 give_up: ;
920 if (!NILP (buffer)
921 && process_coding.cmp_data)
923 coding_restore_composition (&process_coding, Fcurrent_buffer ());
924 coding_free_composition_data (&process_coding);
928 int post_read_count = specpdl_ptr - specpdl;
930 record_unwind_protect (save_excursion_restore, save_excursion_save ());
931 inserted = PT - pt_orig;
932 TEMP_SET_PT_BOTH (pt_orig, pt_byte_orig);
933 if (SYMBOLP (process_coding.post_read_conversion)
934 && !NILP (Ffboundp (process_coding.post_read_conversion)))
935 call1 (process_coding.post_read_conversion, make_number (inserted));
937 Vlast_coding_system_used = process_coding.symbol;
939 /* If the caller required, let the buffer inherit the
940 coding-system used to decode the process output. */
941 if (inherit_process_coding_system)
942 call1 (intern ("after-insert-file-set-buffer-file-coding-system"),
943 make_number (total_read));
945 unbind_to (post_read_count, Qnil);
949 /* Wait for it to terminate, unless it already has. */
950 wait_for_termination (pid);
952 immediate_quit = 0;
954 set_buffer_internal (old);
956 /* Don't kill any children that the subprocess may have left behind
957 when exiting. */
958 call_process_exited = 1;
960 unbind_to (count, Qnil);
962 if (synch_process_death)
963 return code_convert_string_norecord (build_string (synch_process_death),
964 Vlocale_coding_system, 0);
965 return make_number (synch_process_retcode);
967 #endif
969 static Lisp_Object
970 delete_temp_file (name)
971 Lisp_Object name;
973 /* Use Fdelete_file (indirectly) because that runs a file name handler.
974 We did that when writing the file, so we should do so when deleting. */
975 internal_delete_file (name);
976 return Qnil;
979 DEFUN ("call-process-region", Fcall_process_region, Scall_process_region,
980 3, MANY, 0,
981 doc: /* Send text from START to END to a synchronous process running PROGRAM.
982 The remaining arguments are optional.
983 Delete the text if fourth arg DELETE is non-nil.
985 Insert output in BUFFER before point; t means current buffer;
986 nil for BUFFER means discard it; 0 means discard and don't wait.
987 BUFFER can also have the form (REAL-BUFFER STDERR-FILE); in that case,
988 REAL-BUFFER says what to do with standard output, as above,
989 while STDERR-FILE says what to do with standard error in the child.
990 STDERR-FILE may be nil (discard standard error output),
991 t (mix it with ordinary output), or a file name string.
993 Sixth arg DISPLAY non-nil means redisplay buffer as output is inserted.
994 Remaining args are passed to PROGRAM at startup as command args.
996 If BUFFER is nil, `call-process-region' returns immediately with value nil.
997 Otherwise it waits for PROGRAM to terminate
998 and returns a numeric exit status or a signal description string.
999 If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.
1001 usage: (call-process-region START END PROGRAM &optional DELETE BUFFER DISPLAY &rest ARGS) */)
1002 (nargs, args)
1003 int nargs;
1004 register Lisp_Object *args;
1006 struct gcpro gcpro1;
1007 Lisp_Object filename_string;
1008 register Lisp_Object start, end;
1009 int count = specpdl_ptr - specpdl;
1010 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
1011 Lisp_Object coding_systems;
1012 Lisp_Object val, *args2;
1013 int i;
1014 #ifdef DOS_NT
1015 char *tempfile;
1016 char *outf = '\0';
1018 if ((outf = egetenv ("TMPDIR"))
1019 || (outf = egetenv ("TMP"))
1020 || (outf = egetenv ("TEMP")))
1021 strcpy (tempfile = alloca (strlen (outf) + 20), outf);
1022 else
1024 tempfile = alloca (20);
1025 *tempfile = '\0';
1027 if (!IS_DIRECTORY_SEP (tempfile[strlen (tempfile) - 1]))
1028 strcat (tempfile, "/");
1029 if ('/' == DIRECTORY_SEP)
1030 dostounix_filename (tempfile);
1031 else
1032 unixtodos_filename (tempfile);
1033 #ifdef WINDOWSNT
1034 strcat (tempfile, "emXXXXXX");
1035 #else
1036 strcat (tempfile, "detmp.XXX");
1037 #endif
1038 #else /* not DOS_NT */
1039 char *tempfile = (char *) alloca (STRING_BYTES (XSTRING (Vtemp_file_name_pattern)) + 1);
1040 bcopy (XSTRING (Vtemp_file_name_pattern)->data, tempfile,
1041 STRING_BYTES (XSTRING (Vtemp_file_name_pattern)) + 1);
1042 #endif /* not DOS_NT */
1044 coding_systems = Qt;
1046 #ifdef HAVE_MKSTEMP
1048 int fd = mkstemp (tempfile);
1049 if (fd == -1)
1050 report_file_error ("Failed to open temporary file",
1051 Fcons (Vtemp_file_name_pattern, Qnil));
1052 else
1053 close (fd);
1055 #else
1056 mktemp (tempfile);
1057 #endif
1059 filename_string = build_string (tempfile);
1060 GCPRO1 (filename_string);
1061 start = args[0];
1062 end = args[1];
1063 /* Decide coding-system of the contents of the temporary file. */
1064 if (!NILP (Vcoding_system_for_write))
1065 val = Vcoding_system_for_write;
1066 else if (NILP (current_buffer->enable_multibyte_characters))
1067 val = Qnil;
1068 else
1070 args2 = (Lisp_Object *) alloca ((nargs + 1) * sizeof *args2);
1071 args2[0] = Qcall_process_region;
1072 for (i = 0; i < nargs; i++) args2[i + 1] = args[i];
1073 coding_systems = Ffind_operation_coding_system (nargs + 1, args2);
1074 if (CONSP (coding_systems))
1075 val = XCDR (coding_systems);
1076 else if (CONSP (Vdefault_process_coding_system))
1077 val = XCDR (Vdefault_process_coding_system);
1078 else
1079 val = Qnil;
1083 int count1 = specpdl_ptr - specpdl;
1085 specbind (intern ("coding-system-for-write"), val);
1086 Fwrite_region (start, end, filename_string, Qnil, Qlambda, Qnil, Qnil);
1088 unbind_to (count1, Qnil);
1091 /* Note that Fcall_process takes care of binding
1092 coding-system-for-read. */
1094 record_unwind_protect (delete_temp_file, filename_string);
1096 if (nargs > 3 && !NILP (args[3]))
1097 Fdelete_region (start, end);
1099 if (nargs > 3)
1101 args += 2;
1102 nargs -= 2;
1104 else
1106 args[0] = args[2];
1107 nargs = 2;
1109 args[1] = filename_string;
1111 RETURN_UNGCPRO (unbind_to (count, Fcall_process (nargs, args)));
1114 #ifndef VMS /* VMS version is in vmsproc.c. */
1116 static int relocate_fd ();
1118 /* This is the last thing run in a newly forked inferior
1119 either synchronous or asynchronous.
1120 Copy descriptors IN, OUT and ERR as descriptors 0, 1 and 2.
1121 Initialize inferior's priority, pgrp, connected dir and environment.
1122 then exec another program based on new_argv.
1124 This function may change environ for the superior process.
1125 Therefore, the superior process must save and restore the value
1126 of environ around the vfork and the call to this function.
1128 SET_PGRP is nonzero if we should put the subprocess into a separate
1129 process group.
1131 CURRENT_DIR is an elisp string giving the path of the current
1132 directory the subprocess should have. Since we can't really signal
1133 a decent error from within the child, this should be verified as an
1134 executable directory by the parent. */
1137 child_setup (in, out, err, new_argv, set_pgrp, current_dir)
1138 int in, out, err;
1139 register char **new_argv;
1140 int set_pgrp;
1141 Lisp_Object current_dir;
1143 char **env;
1144 char *pwd_var;
1145 #ifdef WINDOWSNT
1146 int cpid;
1147 HANDLE handles[3];
1148 #endif /* WINDOWSNT */
1150 int pid = getpid ();
1152 #ifdef SET_EMACS_PRIORITY
1154 extern EMACS_INT emacs_priority;
1156 if (emacs_priority < 0)
1157 nice (- emacs_priority);
1159 #endif
1161 #ifdef subprocesses
1162 /* Close Emacs's descriptors that this process should not have. */
1163 close_process_descs ();
1164 #endif
1165 /* DOS_NT isn't in a vfork, so if we are in the middle of load-file,
1166 we will lose if we call close_load_descs here. */
1167 #ifndef DOS_NT
1168 close_load_descs ();
1169 #endif
1171 /* Note that use of alloca is always safe here. It's obvious for systems
1172 that do not have true vfork or that have true (stack) alloca.
1173 If using vfork and C_ALLOCA it is safe because that changes
1174 the superior's static variables as if the superior had done alloca
1175 and will be cleaned up in the usual way. */
1177 register char *temp;
1178 register int i;
1180 i = STRING_BYTES (XSTRING (current_dir));
1181 #ifdef MSDOS
1182 /* MSDOS must have all environment variables malloc'ed, because
1183 low-level libc functions that launch subsidiary processes rely
1184 on that. */
1185 pwd_var = (char *) xmalloc (i + 6);
1186 #else
1187 pwd_var = (char *) alloca (i + 6);
1188 #endif
1189 temp = pwd_var + 4;
1190 bcopy ("PWD=", pwd_var, 4);
1191 bcopy (XSTRING (current_dir)->data, temp, i);
1192 if (!IS_DIRECTORY_SEP (temp[i - 1])) temp[i++] = DIRECTORY_SEP;
1193 temp[i] = 0;
1195 #ifndef DOS_NT
1196 /* We can't signal an Elisp error here; we're in a vfork. Since
1197 the callers check the current directory before forking, this
1198 should only return an error if the directory's permissions
1199 are changed between the check and this chdir, but we should
1200 at least check. */
1201 if (chdir (temp) < 0)
1202 _exit (errno);
1203 #endif
1205 #ifdef DOS_NT
1206 /* Get past the drive letter, so that d:/ is left alone. */
1207 if (i > 2 && IS_DEVICE_SEP (temp[1]) && IS_DIRECTORY_SEP (temp[2]))
1209 temp += 2;
1210 i -= 2;
1212 #endif
1214 /* Strip trailing slashes for PWD, but leave "/" and "//" alone. */
1215 while (i > 2 && IS_DIRECTORY_SEP (temp[i - 1]))
1216 temp[--i] = 0;
1219 /* Set `env' to a vector of the strings in Vprocess_environment. */
1221 register Lisp_Object tem;
1222 register char **new_env;
1223 register int new_length;
1225 new_length = 0;
1226 for (tem = Vprocess_environment;
1227 CONSP (tem) && STRINGP (XCAR (tem));
1228 tem = XCDR (tem))
1229 new_length++;
1231 /* new_length + 2 to include PWD and terminating 0. */
1232 env = new_env = (char **) alloca ((new_length + 2) * sizeof (char *));
1234 /* If we have a PWD envvar, pass one down,
1235 but with corrected value. */
1236 if (getenv ("PWD"))
1237 *new_env++ = pwd_var;
1239 /* Copy the Vprocess_environment strings into new_env. */
1240 for (tem = Vprocess_environment;
1241 CONSP (tem) && STRINGP (XCAR (tem));
1242 tem = XCDR (tem))
1244 char **ep = env;
1245 char *string = (char *) XSTRING (XCAR (tem))->data;
1246 /* See if this string duplicates any string already in the env.
1247 If so, don't put it in.
1248 When an env var has multiple definitions,
1249 we keep the definition that comes first in process-environment. */
1250 for (; ep != new_env; ep++)
1252 char *p = *ep, *q = string;
1253 while (1)
1255 if (*q == 0)
1256 /* The string is malformed; might as well drop it. */
1257 goto duplicate;
1258 if (*q != *p)
1259 break;
1260 if (*q == '=')
1261 goto duplicate;
1262 p++, q++;
1265 *new_env++ = string;
1266 duplicate: ;
1268 *new_env = 0;
1270 #ifdef WINDOWSNT
1271 prepare_standard_handles (in, out, err, handles);
1272 set_process_dir (XSTRING (current_dir)->data);
1273 #else /* not WINDOWSNT */
1274 /* Make sure that in, out, and err are not actually already in
1275 descriptors zero, one, or two; this could happen if Emacs is
1276 started with its standard in, out, or error closed, as might
1277 happen under X. */
1279 int oin = in, oout = out;
1281 /* We have to avoid relocating the same descriptor twice! */
1283 in = relocate_fd (in, 3);
1285 if (out == oin)
1286 out = in;
1287 else
1288 out = relocate_fd (out, 3);
1290 if (err == oin)
1291 err = in;
1292 else if (err == oout)
1293 err = out;
1294 else
1295 err = relocate_fd (err, 3);
1298 #ifndef MSDOS
1299 emacs_close (0);
1300 emacs_close (1);
1301 emacs_close (2);
1303 dup2 (in, 0);
1304 dup2 (out, 1);
1305 dup2 (err, 2);
1306 emacs_close (in);
1307 emacs_close (out);
1308 emacs_close (err);
1309 #endif /* not MSDOS */
1310 #endif /* not WINDOWSNT */
1312 #if defined(USG) && !defined(BSD_PGRPS)
1313 #ifndef SETPGRP_RELEASES_CTTY
1314 setpgrp (); /* No arguments but equivalent in this case */
1315 #endif
1316 #else
1317 setpgrp (pid, pid);
1318 #endif /* USG */
1319 /* setpgrp_of_tty is incorrect here; it uses input_fd. */
1320 EMACS_SET_TTY_PGRP (0, &pid);
1322 #ifdef MSDOS
1323 pid = run_msdos_command (new_argv, pwd_var + 4, in, out, err, env);
1324 xfree (pwd_var);
1325 if (pid == -1)
1326 /* An error occurred while trying to run the subprocess. */
1327 report_file_error ("Spawning child process", Qnil);
1328 return pid;
1329 #else /* not MSDOS */
1330 #ifdef WINDOWSNT
1331 /* Spawn the child. (See ntproc.c:Spawnve). */
1332 cpid = spawnve (_P_NOWAIT, new_argv[0], new_argv, env);
1333 reset_standard_handles (in, out, err, handles);
1334 if (cpid == -1)
1335 /* An error occurred while trying to spawn the process. */
1336 report_file_error ("Spawning child process", Qnil);
1337 return cpid;
1338 #else /* not WINDOWSNT */
1339 /* execvp does not accept an environment arg so the only way
1340 to pass this environment is to set environ. Our caller
1341 is responsible for restoring the ambient value of environ. */
1342 environ = env;
1343 execvp (new_argv[0], new_argv);
1345 emacs_write (1, "Can't exec program: ", 20);
1346 emacs_write (1, new_argv[0], strlen (new_argv[0]));
1347 emacs_write (1, "\n", 1);
1348 _exit (1);
1349 #endif /* not WINDOWSNT */
1350 #endif /* not MSDOS */
1353 /* Move the file descriptor FD so that its number is not less than MINFD.
1354 If the file descriptor is moved at all, the original is freed. */
1355 static int
1356 relocate_fd (fd, minfd)
1357 int fd, minfd;
1359 if (fd >= minfd)
1360 return fd;
1361 else
1363 int new = dup (fd);
1364 if (new == -1)
1366 char *message1 = "Error while setting up child: ";
1367 char *errmessage = strerror (errno);
1368 char *message2 = "\n";
1369 emacs_write (2, message1, strlen (message1));
1370 emacs_write (2, errmessage, strlen (errmessage));
1371 emacs_write (2, message2, strlen (message2));
1372 _exit (1);
1374 /* Note that we hold the original FD open while we recurse,
1375 to guarantee we'll get a new FD if we need it. */
1376 new = relocate_fd (new, minfd);
1377 emacs_close (fd);
1378 return new;
1382 static int
1383 getenv_internal (var, varlen, value, valuelen)
1384 char *var;
1385 int varlen;
1386 char **value;
1387 int *valuelen;
1389 Lisp_Object scan;
1391 for (scan = Vprocess_environment; CONSP (scan); scan = XCDR (scan))
1393 Lisp_Object entry;
1395 entry = XCAR (scan);
1396 if (STRINGP (entry)
1397 && STRING_BYTES (XSTRING (entry)) > varlen
1398 && XSTRING (entry)->data[varlen] == '='
1399 #ifdef WINDOWSNT
1400 /* NT environment variables are case insensitive. */
1401 && ! strnicmp (XSTRING (entry)->data, var, varlen)
1402 #else /* not WINDOWSNT */
1403 && ! bcmp (XSTRING (entry)->data, var, varlen)
1404 #endif /* not WINDOWSNT */
1407 *value = (char *) XSTRING (entry)->data + (varlen + 1);
1408 *valuelen = STRING_BYTES (XSTRING (entry)) - (varlen + 1);
1409 return 1;
1413 return 0;
1416 DEFUN ("getenv-internal", Fgetenv_internal, Sgetenv_internal, 1, 1, 0,
1417 doc: /* Return the value of environment variable VAR, as a string.
1418 VAR should be a string. Value is nil if VAR is undefined in the environment.
1419 This function consults the variable ``process-environment'' for its value. */)
1420 (var)
1421 Lisp_Object var;
1423 char *value;
1424 int valuelen;
1426 CHECK_STRING (var);
1427 if (getenv_internal (XSTRING (var)->data, STRING_BYTES (XSTRING (var)),
1428 &value, &valuelen))
1429 return make_string (value, valuelen);
1430 else
1431 return Qnil;
1434 /* A version of getenv that consults process_environment, easily
1435 callable from C. */
1436 char *
1437 egetenv (var)
1438 char *var;
1440 char *value;
1441 int valuelen;
1443 if (getenv_internal (var, strlen (var), &value, &valuelen))
1444 return value;
1445 else
1446 return 0;
1449 #endif /* not VMS */
1451 /* This is run before init_cmdargs. */
1453 void
1454 init_callproc_1 ()
1456 char *data_dir = egetenv ("EMACSDATA");
1457 char *doc_dir = egetenv ("EMACSDOC");
1459 Vdata_directory
1460 = Ffile_name_as_directory (build_string (data_dir ? data_dir
1461 : PATH_DATA));
1462 Vdoc_directory
1463 = Ffile_name_as_directory (build_string (doc_dir ? doc_dir
1464 : PATH_DOC));
1466 /* Check the EMACSPATH environment variable, defaulting to the
1467 PATH_EXEC path from epaths.h. */
1468 Vexec_path = decode_env_path ("EMACSPATH", PATH_EXEC);
1469 Vexec_directory = Ffile_name_as_directory (Fcar (Vexec_path));
1470 Vexec_path = nconc2 (decode_env_path ("PATH", ""), Vexec_path);
1473 /* This is run after init_cmdargs, when Vinstallation_directory is valid. */
1475 void
1476 init_callproc ()
1478 char *data_dir = egetenv ("EMACSDATA");
1480 register char * sh;
1481 Lisp_Object tempdir;
1483 if (!NILP (Vinstallation_directory))
1485 /* Add to the path the lib-src subdir of the installation dir. */
1486 Lisp_Object tem;
1487 tem = Fexpand_file_name (build_string ("lib-src"),
1488 Vinstallation_directory);
1489 #ifndef DOS_NT
1490 /* MSDOS uses wrapped binaries, so don't do this. */
1491 if (NILP (Fmember (tem, Vexec_path)))
1493 Vexec_path = decode_env_path ("EMACSPATH", PATH_EXEC);
1494 Vexec_path = Fcons (tem, Vexec_path);
1495 Vexec_path = nconc2 (decode_env_path ("PATH", ""), Vexec_path);
1498 Vexec_directory = Ffile_name_as_directory (tem);
1499 #endif /* not DOS_NT */
1501 /* Maybe use ../etc as well as ../lib-src. */
1502 if (data_dir == 0)
1504 tem = Fexpand_file_name (build_string ("etc"),
1505 Vinstallation_directory);
1506 Vdoc_directory = Ffile_name_as_directory (tem);
1510 /* Look for the files that should be in etc. We don't use
1511 Vinstallation_directory, because these files are never installed
1512 near the executable, and they are never in the build
1513 directory when that's different from the source directory.
1515 Instead, if these files are not in the nominal place, we try the
1516 source directory. */
1517 if (data_dir == 0)
1519 Lisp_Object tem, tem1, srcdir;
1521 srcdir = Fexpand_file_name (build_string ("../src/"),
1522 build_string (PATH_DUMPLOADSEARCH));
1523 tem = Fexpand_file_name (build_string ("GNU"), Vdata_directory);
1524 tem1 = Ffile_exists_p (tem);
1525 if (!NILP (Fequal (srcdir, Vinvocation_directory)) || NILP (tem1))
1527 Lisp_Object newdir;
1528 newdir = Fexpand_file_name (build_string ("../etc/"),
1529 build_string (PATH_DUMPLOADSEARCH));
1530 tem = Fexpand_file_name (build_string ("GNU"), newdir);
1531 tem1 = Ffile_exists_p (tem);
1532 if (!NILP (tem1))
1533 Vdata_directory = newdir;
1537 #ifndef CANNOT_DUMP
1538 if (initialized)
1539 #endif
1541 tempdir = Fdirectory_file_name (Vexec_directory);
1542 if (access (XSTRING (tempdir)->data, 0) < 0)
1543 dir_warning ("Warning: arch-dependent data dir (%s) does not exist.\n",
1544 Vexec_directory);
1547 tempdir = Fdirectory_file_name (Vdata_directory);
1548 if (access (XSTRING (tempdir)->data, 0) < 0)
1549 dir_warning ("Warning: arch-independent data dir (%s) does not exist.\n",
1550 Vdata_directory);
1552 #ifdef VMS
1553 Vshell_file_name = build_string ("*dcl*");
1554 #else
1555 sh = (char *) getenv ("SHELL");
1556 Vshell_file_name = build_string (sh ? sh : "/bin/sh");
1557 #endif
1559 #ifdef VMS
1560 Vtemp_file_name_pattern = build_string ("tmp:emacsXXXXXX.");
1561 #else
1562 if (getenv ("TMPDIR"))
1564 char *dir = getenv ("TMPDIR");
1565 Vtemp_file_name_pattern
1566 = Fexpand_file_name (build_string ("emacsXXXXXX"),
1567 build_string (dir));
1569 else
1570 Vtemp_file_name_pattern = build_string ("/tmp/emacsXXXXXX");
1571 #endif
1574 void
1575 set_process_environment ()
1577 register char **envp;
1579 Vprocess_environment = Qnil;
1580 #ifndef CANNOT_DUMP
1581 if (initialized)
1582 #endif
1583 for (envp = environ; *envp; envp++)
1584 Vprocess_environment = Fcons (build_string (*envp),
1585 Vprocess_environment);
1588 void
1589 syms_of_callproc ()
1591 #ifdef DOS_NT
1592 Qbuffer_file_type = intern ("buffer-file-type");
1593 staticpro (&Qbuffer_file_type);
1594 #endif /* DOS_NT */
1596 DEFVAR_LISP ("shell-file-name", &Vshell_file_name,
1597 doc: /* *File name to load inferior shells from.
1598 Initialized from the SHELL environment variable. */);
1600 DEFVAR_LISP ("exec-path", &Vexec_path,
1601 doc: /* *List of directories to search programs to run in subprocesses.
1602 Each element is a string (directory name) or nil (try default directory). */);
1604 DEFVAR_LISP ("exec-suffixes", &Vexec_suffixes,
1605 doc: /* *List of suffixes to try to find executable file names.
1606 Each element is a string. */);
1607 Vexec_suffixes = Qnil;
1609 DEFVAR_LISP ("exec-directory", &Vexec_directory,
1610 doc: /* Directory for executables for Emacs to invoke.
1611 More generally, this includes any architecture-dependent files
1612 that are built and installed from the Emacs distribution. */);
1614 DEFVAR_LISP ("data-directory", &Vdata_directory,
1615 doc: /* Directory of machine-independent files that come with GNU Emacs.
1616 These are files intended for Emacs to use while it runs. */);
1618 DEFVAR_LISP ("doc-directory", &Vdoc_directory,
1619 doc: /* Directory containing the DOC file that comes with GNU Emacs.
1620 This is usually the same as data-directory. */);
1622 DEFVAR_LISP ("configure-info-directory", &Vconfigure_info_directory,
1623 doc: /* For internal use by the build procedure only.
1624 This is the name of the directory in which the build procedure installed
1625 Emacs's info files; the default value for Info-default-directory-list
1626 includes this. */);
1627 Vconfigure_info_directory = build_string (PATH_INFO);
1629 DEFVAR_LISP ("shared-game-score-directory", &Vshared_game_score_directory,
1630 doc: /* Directory of score files for games which come with GNU Emacs.
1631 If this variable is nil, then Emacs is unable to use a shared directory. */);
1632 #ifdef HAVE_SHARED_GAME_DIR
1633 Vshared_game_score_directory = build_string(HAVE_SHARED_GAME_DIR);
1634 #else
1635 Vshared_game_score_directory = Qnil;
1636 #endif
1638 DEFVAR_LISP ("temp-file-name-pattern", &Vtemp_file_name_pattern,
1639 doc: /* Pattern for making names for temporary files.
1640 This is used by `call-process-region'. */);
1641 /* This variable is initialized in init_callproc. */
1643 DEFVAR_LISP ("process-environment", &Vprocess_environment,
1644 doc: /* List of environment variables for subprocesses to inherit.
1645 Each element should be a string of the form ENVVARNAME=VALUE.
1646 If multiple entries define the same variable, the first one always
1647 takes precedence.
1648 The environment which Emacs inherits is placed in this variable
1649 when Emacs starts. */);
1651 #ifndef VMS
1652 defsubr (&Scall_process);
1653 defsubr (&Sgetenv_internal);
1654 #endif
1655 defsubr (&Scall_process_region);