1 /* Synchronous subprocess invocation for GNU Emacs.
2 Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995, 1999, 2000, 2001,
3 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
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., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
32 /* Define SIGCHLD as an alias for SIGCLD. */
34 #if !defined (SIGCHLD) && defined (SIGCLD)
35 #define SIGCHLD SIGCLD
38 #include <sys/types.h>
46 #define INCLUDED_FCNTL
53 #include <stdlib.h> /* for proper declaration of environ */
56 #define _P_NOWAIT 1 /* from process.h */
59 #ifdef MSDOS /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
60 #define INCLUDED_FCNTL
63 #include <sys/param.h>
81 #include "composite.h"
84 #include "syssignal.h"
86 #include "blockinput.h"
88 #include "termhooks.h"
95 extern noshare
char **environ
;
98 extern char **environ
;
103 #if !defined (USG) || defined (BSD_PGRPS)
105 #define setpgrp setpgid
109 Lisp_Object Vexec_path
, Vexec_directory
, Vexec_suffixes
;
110 Lisp_Object Vdata_directory
, Vdoc_directory
;
111 Lisp_Object Vconfigure_info_directory
, Vshared_game_score_directory
;
112 Lisp_Object Vtemp_file_name_pattern
;
114 Lisp_Object Vshell_file_name
;
116 Lisp_Object Vprocess_environment
, Vinitial_environment
;
119 Lisp_Object Qbuffer_file_type
;
122 /* True if we are about to fork off a synchronous process or if we
123 are waiting for it. */
124 int synch_process_alive
;
126 /* Nonzero => this is a string explaining death of synchronous subprocess. */
127 char *synch_process_death
;
129 /* Nonzero => this is the signal number that terminated the subprocess. */
130 int synch_process_termsig
;
132 /* If synch_process_death is zero,
133 this is exit code of synchronous subprocess. */
134 int synch_process_retcode
;
137 /* Clean up when exiting Fcall_process.
138 On MSDOS, delete the temporary file on any kind of termination.
139 On Unix, kill the process and any children on termination by signal. */
141 /* Nonzero if this is termination due to exit. */
142 static int call_process_exited
;
144 #ifndef VMS /* VMS version is in vmsproc.c. */
147 call_process_kill (fdpid
)
150 emacs_close (XFASTINT (Fcar (fdpid
)));
151 EMACS_KILLPG (XFASTINT (Fcdr (fdpid
)), SIGKILL
);
152 synch_process_alive
= 0;
157 call_process_cleanup (fdpid
)
160 #if defined (MSDOS) || defined (MAC_OS8)
161 /* for MSDOS fdpid is really (fd . tempfile) */
162 register Lisp_Object file
;
164 emacs_close (XFASTINT (Fcar (fdpid
)));
165 if (strcmp (SDATA (file
), NULL_DEVICE
) != 0)
166 unlink (SDATA (file
));
167 #else /* not MSDOS and not MAC_OS8 */
168 register int pid
= XFASTINT (Fcdr (fdpid
));
170 if (call_process_exited
)
172 emacs_close (XFASTINT (Fcar (fdpid
)));
176 if (EMACS_KILLPG (pid
, SIGINT
) == 0)
178 int count
= SPECPDL_INDEX ();
179 record_unwind_protect (call_process_kill
, fdpid
);
180 message1 ("Waiting for process to die...(type C-g again to kill it instantly)");
183 wait_for_termination (pid
);
185 specpdl_ptr
= specpdl
+ count
; /* Discard the unwind protect. */
186 message1 ("Waiting for process to die...done");
188 synch_process_alive
= 0;
189 emacs_close (XFASTINT (Fcar (fdpid
)));
190 #endif /* not MSDOS */
194 DEFUN ("call-process", Fcall_process
, Scall_process
, 1, MANY
, 0,
195 doc
: /* Call PROGRAM synchronously in separate process.
196 The remaining arguments are optional.
197 The program's input comes from file INFILE (nil means `/dev/null').
198 Insert output in BUFFER before point; t means current buffer;
199 nil for BUFFER means discard it; 0 means discard and don't wait.
200 BUFFER can also have the form (REAL-BUFFER STDERR-FILE); in that case,
201 REAL-BUFFER says what to do with standard output, as above,
202 while STDERR-FILE says what to do with standard error in the child.
203 STDERR-FILE may be nil (discard standard error output),
204 t (mix it with ordinary output), or a file name string.
206 Fourth arg DISPLAY non-nil means redisplay buffer as output is inserted.
207 Remaining arguments are strings passed as command arguments to PROGRAM.
209 If executable PROGRAM can't be found as an executable, `call-process'
210 signals a Lisp error. `call-process' reports errors in execution of
211 the program only through its return and output.
213 If BUFFER is 0, `call-process' returns immediately with value nil.
214 Otherwise it waits for PROGRAM to terminate
215 and returns a numeric exit status or a signal description string.
216 If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.
218 usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS) */)
221 register Lisp_Object
*args
;
223 Lisp_Object infile
, buffer
, current_dir
, path
;
228 #define CALLPROC_BUFFER_SIZE_MIN (16 * 1024)
229 #define CALLPROC_BUFFER_SIZE_MAX (4 * CALLPROC_BUFFER_SIZE_MIN)
230 char buf
[CALLPROC_BUFFER_SIZE_MAX
];
231 int bufsize
= CALLPROC_BUFFER_SIZE_MIN
;
232 int count
= SPECPDL_INDEX ();
234 register const unsigned char **new_argv
235 = (const unsigned char **) alloca ((max (2, nargs
- 2)) * sizeof (char *));
236 struct buffer
*old
= current_buffer
;
237 /* File to use for stderr in the child.
238 t means use same as standard output. */
239 Lisp_Object error_file
;
240 #ifdef MSDOS /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
241 char *outf
, *tempfile
;
251 struct coding_system process_coding
; /* coding-system of process output */
252 struct coding_system argument_coding
; /* coding-system of arguments */
253 /* Set to the return value of Ffind_operation_coding_system. */
254 Lisp_Object coding_systems
;
256 /* Qt denotes that Ffind_operation_coding_system is not yet called. */
259 CHECK_STRING (args
[0]);
264 /* Without asynchronous processes we cannot have BUFFER == 0. */
266 && (INTEGERP (CONSP (args
[2]) ? XCAR (args
[2]) : args
[2])))
267 error ("Operating system cannot handle asynchronous subprocesses");
268 #endif /* subprocesses */
270 /* Decide the coding-system for giving arguments. */
272 Lisp_Object val
, *args2
;
275 /* If arguments are supplied, we may have to encode them. */
280 for (i
= 4; i
< nargs
; i
++)
281 CHECK_STRING (args
[i
]);
283 for (i
= 4; i
< nargs
; i
++)
284 if (STRING_MULTIBYTE (args
[i
]))
287 if (!NILP (Vcoding_system_for_write
))
288 val
= Vcoding_system_for_write
;
289 else if (! must_encode
)
293 args2
= (Lisp_Object
*) alloca ((nargs
+ 1) * sizeof *args2
);
294 args2
[0] = Qcall_process
;
295 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
296 coding_systems
= Ffind_operation_coding_system (nargs
+ 1, args2
);
297 if (CONSP (coding_systems
))
298 val
= XCDR (coding_systems
);
299 else if (CONSP (Vdefault_process_coding_system
))
300 val
= XCDR (Vdefault_process_coding_system
);
304 setup_coding_system (Fcheck_coding_system (val
), &argument_coding
);
305 if (argument_coding
.common_flags
& CODING_ASCII_INCOMPATIBLE_MASK
)
306 setup_coding_system (Qraw_text
, &argument_coding
);
307 if (argument_coding
.eol_type
== CODING_EOL_UNDECIDED
)
308 argument_coding
.eol_type
= system_eol_type
;
312 if (nargs
>= 2 && ! NILP (args
[1]))
314 infile
= Fexpand_file_name (args
[1], current_buffer
->directory
);
315 CHECK_STRING (infile
);
318 infile
= build_string (NULL_DEVICE
);
324 /* If BUFFER is a list, its meaning is
325 (BUFFER-FOR-STDOUT FILE-FOR-STDERR). */
328 if (CONSP (XCDR (buffer
)))
330 Lisp_Object stderr_file
;
331 stderr_file
= XCAR (XCDR (buffer
));
333 if (NILP (stderr_file
) || EQ (Qt
, stderr_file
))
334 error_file
= stderr_file
;
336 error_file
= Fexpand_file_name (stderr_file
, Qnil
);
339 buffer
= XCAR (buffer
);
342 if (!(EQ (buffer
, Qnil
)
344 || INTEGERP (buffer
)))
346 Lisp_Object spec_buffer
;
347 spec_buffer
= buffer
;
348 buffer
= Fget_buffer_create (buffer
);
349 /* Mention the buffer name for a better error message. */
351 CHECK_BUFFER (spec_buffer
);
352 CHECK_BUFFER (buffer
);
358 /* Make sure that the child will be able to chdir to the current
359 buffer's current directory, or its unhandled equivalent. We
360 can't just have the child check for an error when it does the
361 chdir, since it's in a vfork.
363 We have to GCPRO around this because Fexpand_file_name,
364 Funhandled_file_name_directory, and Ffile_accessible_directory_p
365 might call a file name handling function. The argument list is
366 protected by the caller, so all we really have to worry about is
369 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
371 current_dir
= current_buffer
->directory
;
373 GCPRO4 (infile
, buffer
, current_dir
, error_file
);
376 = expand_and_dir_to_file (Funhandled_file_name_directory (current_dir
),
378 if (NILP (Ffile_accessible_directory_p (current_dir
)))
379 report_file_error ("Setting current directory",
380 Fcons (current_buffer
->directory
, Qnil
));
382 if (STRING_MULTIBYTE (infile
))
383 infile
= ENCODE_FILE (infile
);
384 if (STRING_MULTIBYTE (current_dir
))
385 current_dir
= ENCODE_FILE (current_dir
);
386 if (STRINGP (error_file
) && STRING_MULTIBYTE (error_file
))
387 error_file
= ENCODE_FILE (error_file
);
391 display_p
= INTERACTIVE
&& nargs
>= 4 && !NILP (args
[3]);
393 filefd
= emacs_open (SDATA (infile
), O_RDONLY
, 0);
396 infile
= DECODE_FILE (infile
);
397 report_file_error ("Opening process input file", Fcons (infile
, Qnil
));
399 /* Search for program; barf if not found. */
403 GCPRO1 (current_dir
);
404 openp (Vexec_path
, args
[0], Vexec_suffixes
, &path
, make_number (X_OK
));
409 emacs_close (filefd
);
410 report_file_error ("Searching for program", Fcons (args
[0], Qnil
));
413 /* If program file name starts with /: for quoting a magic name,
415 if (SBYTES (path
) > 2 && SREF (path
, 0) == '/'
416 && SREF (path
, 1) == ':')
417 path
= Fsubstring (path
, make_number (2), Qnil
);
419 new_argv
[0] = SDATA (path
);
423 struct gcpro gcpro1
, gcpro2
, gcpro3
;
425 GCPRO3 (infile
, buffer
, current_dir
);
426 argument_coding
.dst_multibyte
= 0;
427 for (i
= 4; i
< nargs
; i
++)
429 argument_coding
.src_multibyte
= STRING_MULTIBYTE (args
[i
]);
430 if (CODING_REQUIRE_ENCODING (&argument_coding
))
432 /* We must encode this argument. */
433 args
[i
] = encode_coding_string (args
[i
], &argument_coding
, 1);
434 if (argument_coding
.type
== coding_type_ccl
)
435 setup_ccl_program (&(argument_coding
.spec
.ccl
.encoder
), Qnil
);
437 new_argv
[i
- 3] = SDATA (args
[i
]);
440 new_argv
[nargs
- 3] = 0;
445 #ifdef MSDOS /* MW, July 1993 */
446 if ((outf
= egetenv ("TMPDIR")))
447 strcpy (tempfile
= alloca (strlen (outf
) + 20), outf
);
450 tempfile
= alloca (20);
453 dostounix_filename (tempfile
);
454 if (*tempfile
== '\0' || tempfile
[strlen (tempfile
) - 1] != '/')
455 strcat (tempfile
, "/");
456 strcat (tempfile
, "detmp.XXX");
459 outfilefd
= creat (tempfile
, S_IREAD
| S_IWRITE
);
462 emacs_close (filefd
);
463 report_file_error ("Opening process output file",
464 Fcons (build_string (tempfile
), Qnil
));
471 /* Since we don't have pipes on the Mac, create a temporary file to
472 hold the output of the subprocess. */
473 tempfile
= (char *) alloca (SBYTES (Vtemp_file_name_pattern
) + 1);
474 bcopy (SDATA (Vtemp_file_name_pattern
), tempfile
,
475 SBYTES (Vtemp_file_name_pattern
) + 1);
479 outfilefd
= creat (tempfile
, S_IREAD
| S_IWRITE
);
483 report_file_error ("Opening process output file",
484 Fcons (build_string (tempfile
), Qnil
));
490 if (INTEGERP (buffer
))
491 fd
[1] = emacs_open (NULL_DEVICE
, O_WRONLY
, 0), fd
[0] = -1;
499 emacs_close (filefd
);
500 report_file_error ("Creating process pipe", Qnil
);
505 /* Replaced by close_process_descs */
506 set_exclusive_use (fd
[0]);
511 /* child_setup must clobber environ in systems with true vfork.
512 Protect it from permanent change. */
513 register char **save_environ
= environ
;
514 register int fd1
= fd
[1];
517 #if 0 /* Some systems don't have sigblock. */
518 mask
= sigblock (sigmask (SIGCHLD
));
521 /* Record that we're about to create a synchronous process. */
522 synch_process_alive
= 1;
524 /* These vars record information from process termination.
525 Clear them now before process can possibly terminate,
526 to avoid timing error if process terminates soon. */
527 synch_process_death
= 0;
528 synch_process_retcode
= 0;
529 synch_process_termsig
= 0;
531 if (NILP (error_file
))
532 fd_error
= emacs_open (NULL_DEVICE
, O_WRONLY
, 0);
533 else if (STRINGP (error_file
))
536 fd_error
= emacs_open (SDATA (error_file
),
537 O_WRONLY
| O_TRUNC
| O_CREAT
| O_TEXT
,
539 #else /* not DOS_NT */
540 fd_error
= creat (SDATA (error_file
), 0666);
541 #endif /* not DOS_NT */
546 emacs_close (filefd
);
554 if (NILP (error_file
))
555 error_file
= build_string (NULL_DEVICE
);
556 else if (STRINGP (error_file
))
557 error_file
= DECODE_FILE (error_file
);
558 report_file_error ("Cannot redirect stderr", Fcons (error_file
, Qnil
));
563 /* Call run_mac_command in sysdep.c here directly instead of doing
564 a child_setup as for MSDOS and other platforms. Note that this
565 code does not handle passing the environment to the synchronous
567 char *infn
, *outfn
, *errfn
, *currdn
;
569 /* close these files so subprocess can write to them */
571 if (fd_error
!= outfilefd
)
573 fd1
= -1; /* No harm in closing that one! */
575 infn
= SDATA (infile
);
577 if (NILP (error_file
))
579 else if (EQ (Qt
, error_file
))
582 errfn
= SDATA (error_file
);
583 currdn
= SDATA (current_dir
);
584 pid
= run_mac_command (new_argv
, currdn
, infn
, outfn
, errfn
);
586 /* Record that the synchronous process exited and note its
587 termination status. */
588 synch_process_alive
= 0;
589 synch_process_retcode
= pid
;
590 if (synch_process_retcode
< 0) /* means it couldn't be exec'ed */
592 synchronize_system_messages_locale ();
593 synch_process_death
= strerror (errno
);
596 /* Since CRLF is converted to LF within `decode_coding', we can
597 always open a file with binary mode. */
598 fd
[0] = open (tempfile
, O_BINARY
);
603 report_file_error ("Cannot re-open temporary file", Qnil
);
606 #else /* not MAC_OS8 */
607 #ifdef MSDOS /* MW, July 1993 */
608 /* Note that on MSDOS `child_setup' actually returns the child process
609 exit status, not its PID, so we assign it to `synch_process_retcode'
611 pid
= child_setup (filefd
, outfilefd
, fd_error
, (char **) new_argv
,
614 /* Record that the synchronous process exited and note its
615 termination status. */
616 synch_process_alive
= 0;
617 synch_process_retcode
= pid
;
618 if (synch_process_retcode
< 0) /* means it couldn't be exec'ed */
620 synchronize_system_messages_locale ();
621 synch_process_death
= strerror (errno
);
624 emacs_close (outfilefd
);
625 if (fd_error
!= outfilefd
)
626 emacs_close (fd_error
);
627 fd1
= -1; /* No harm in closing that one! */
628 /* Since CRLF is converted to LF within `decode_coding', we can
629 always open a file with binary mode. */
630 fd
[0] = emacs_open (tempfile
, O_RDONLY
| O_BINARY
, 0);
634 emacs_close (filefd
);
635 report_file_error ("Cannot re-open temporary file", Qnil
);
637 #else /* not MSDOS */
639 pid
= child_setup (filefd
, fd1
, fd_error
, (char **) new_argv
,
641 #else /* not WINDOWSNT */
653 #if defined (USG) && !defined (BSD_PGRPS)
658 child_setup (filefd
, fd1
, fd_error
, (char **) new_argv
,
663 #endif /* not WINDOWSNT */
665 /* The MSDOS case did this already. */
667 emacs_close (fd_error
);
668 #endif /* not MSDOS */
669 #endif /* not MAC_OS8 */
671 environ
= save_environ
;
673 /* Close most of our fd's, but not fd[0]
674 since we will use that to read input from. */
675 emacs_close (filefd
);
676 if (fd1
>= 0 && fd1
!= fd_error
)
684 report_file_error ("Doing vfork", Qnil
);
687 if (INTEGERP (buffer
))
692 /* If Emacs has been built with asynchronous subprocess support,
693 we don't need to do this, I think because it will then have
694 the facilities for handling SIGCHLD. */
695 wait_without_blocking ();
696 #endif /* subprocesses */
700 /* Enable sending signal if user quits below. */
701 call_process_exited
= 0;
703 #if defined(MSDOS) || defined(MAC_OS8)
704 /* MSDOS needs different cleanup information. */
705 record_unwind_protect (call_process_cleanup
,
706 Fcons (make_number (fd
[0]), build_string (tempfile
)));
708 record_unwind_protect (call_process_cleanup
,
709 Fcons (make_number (fd
[0]), make_number (pid
)));
710 #endif /* not MSDOS and not MAC_OS8 */
713 if (BUFFERP (buffer
))
714 Fset_buffer (buffer
);
718 /* If BUFFER is nil, we must read process output once and then
719 discard it, so setup coding system but with nil. */
720 setup_coding_system (Qnil
, &process_coding
);
724 Lisp_Object val
, *args2
;
727 if (!NILP (Vcoding_system_for_read
))
728 val
= Vcoding_system_for_read
;
731 if (EQ (coding_systems
, Qt
))
735 args2
= (Lisp_Object
*) alloca ((nargs
+ 1) * sizeof *args2
);
736 args2
[0] = Qcall_process
;
737 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
739 = Ffind_operation_coding_system (nargs
+ 1, args2
);
741 if (CONSP (coding_systems
))
742 val
= XCAR (coding_systems
);
743 else if (CONSP (Vdefault_process_coding_system
))
744 val
= XCAR (Vdefault_process_coding_system
);
748 setup_coding_system (Fcheck_coding_system (val
), &process_coding
);
749 /* In unibyte mode, character code conversion should not take
750 place but EOL conversion should. So, setup raw-text or one
751 of the subsidiary according to the information just setup. */
752 if (NILP (current_buffer
->enable_multibyte_characters
)
754 setup_raw_text_coding_system (&process_coding
);
756 process_coding
.src_multibyte
= 0;
757 process_coding
.dst_multibyte
759 ? ! NILP (XBUFFER (buffer
)->enable_multibyte_characters
)
760 : ! NILP (current_buffer
->enable_multibyte_characters
));
770 int display_on_the_fly
= display_p
;
771 struct coding_system saved_coding
;
772 int pt_orig
= PT
, pt_byte_orig
= PT_BYTE
;
775 saved_coding
= process_coding
;
776 if (process_coding
.composing
!= COMPOSITION_DISABLED
)
777 coding_allocate_composition_data (&process_coding
, PT
);
780 /* Repeatedly read until we've filled as much as possible
781 of the buffer size we have. But don't read
782 less than 1024--save that for the next bufferful. */
784 while (nread
< bufsize
- 1024)
786 int this_read
= emacs_read (fd
[0], buf
+ nread
,
794 process_coding
.mode
|= CODING_MODE_LAST_BLOCK
;
799 total_read
+= this_read
;
801 if (display_on_the_fly
)
805 /* Now NREAD is the total amount of data in the buffer. */
810 if (! CODING_MAY_REQUIRE_DECODING (&process_coding
))
811 insert_1_both (buf
, nread
, nread
, 0, 1, 0);
813 { /* We have to decode the input. */
818 size
= decoding_buffer_size (&process_coding
, nread
);
819 decoding_buf
= (char *) xmalloc (size
);
821 /* We can't use the macro CODING_REQUIRE_DETECTION
822 because it always returns nonzero if the coding
823 system requires EOL detection. Here, we have to
824 check only whether or not the coding system
825 requires text-encoding detection. */
826 if (process_coding
.type
== coding_type_undecided
)
828 detect_coding (&process_coding
, buf
, nread
);
829 if (process_coding
.composing
!= COMPOSITION_DISABLED
)
830 /* We have not yet allocated the composition
831 data because the coding type was undecided. */
832 coding_allocate_composition_data (&process_coding
, PT
);
834 if (process_coding
.cmp_data
)
835 process_coding
.cmp_data
->char_offset
= PT
;
837 decode_coding (&process_coding
, buf
, decoding_buf
,
840 if (display_on_the_fly
841 && saved_coding
.type
== coding_type_undecided
842 && process_coding
.type
!= coding_type_undecided
)
844 /* We have detected some coding system. But,
845 there's a possibility that the detection was
846 done by insufficient data. So, we try the code
847 detection again with more data. */
848 xfree (decoding_buf
);
849 display_on_the_fly
= 0;
850 process_coding
= saved_coding
;
852 /* This is to make the above condition always
853 fails in the future. */
854 saved_coding
.type
= coding_type_no_conversion
;
858 if (process_coding
.produced
> 0)
859 insert_1_both (decoding_buf
, process_coding
.produced_char
,
860 process_coding
.produced
, 0, 1, 0);
861 xfree (decoding_buf
);
863 if (process_coding
.result
== CODING_FINISH_INCONSISTENT_EOL
)
865 Lisp_Object eol_type
, coding
;
867 if (process_coding
.eol_type
== CODING_EOL_CR
)
869 /* CRs have been replaced with LFs. Undo
870 that in the text inserted above. */
873 move_gap_both (PT
, PT_BYTE
);
875 p
= BYTE_POS_ADDR (pt_byte_orig
);
876 for (; p
< GPT_ADDR
; ++p
)
880 else if (process_coding
.eol_type
== CODING_EOL_CRLF
)
882 /* CR LFs have been replaced with LFs. Undo
883 that by inserting CRs in front of LFs in
884 the text inserted above. */
885 EMACS_INT bytepos
, old_pt
, old_pt_byte
, nCR
;
888 old_pt_byte
= PT_BYTE
;
891 for (bytepos
= PT_BYTE
- 1;
892 bytepos
>= pt_byte_orig
;
894 if (FETCH_BYTE (bytepos
) == '\n')
896 EMACS_INT charpos
= BYTE_TO_CHAR (bytepos
);
897 TEMP_SET_PT_BOTH (charpos
, bytepos
);
898 insert_1_both ("\r", 1, 1, 0, 1, 0);
902 TEMP_SET_PT_BOTH (old_pt
+ nCR
, old_pt_byte
+ nCR
);
905 /* Set the coding system symbol to that for
907 eol_type
= Fget (saved_coding
.symbol
, Qeol_type
);
908 if (VECTORP (eol_type
)
909 && ASIZE (eol_type
) == 3
910 && SYMBOLP (AREF (eol_type
, CODING_EOL_LF
)))
911 coding
= AREF (eol_type
, CODING_EOL_LF
);
913 coding
= saved_coding
.symbol
;
915 process_coding
.symbol
= coding
;
916 process_coding
.eol_type
= CODING_EOL_LF
;
918 &= ~CODING_MODE_INHIBIT_INCONSISTENT_EOL
;
921 nread
-= process_coding
.consumed
;
924 /* As CARRYOVER should not be that large, we had
925 better avoid overhead of bcopy. */
926 BCOPY_SHORT (buf
+ process_coding
.consumed
, buf
,
928 if (process_coding
.result
== CODING_FINISH_INSUFFICIENT_CMP
)
930 /* The decoding ended because of insufficient data
931 area to record information about composition.
932 We must try decoding with additional data area
933 before reading more output for the process. */
934 coding_allocate_composition_data (&process_coding
, PT
);
935 goto repeat_decoding
;
940 if (process_coding
.mode
& CODING_MODE_LAST_BLOCK
)
943 #if (CALLPROC_BUFFER_SIZE_MIN != CALLPROC_BUFFER_SIZE_MAX)
944 /* Make the buffer bigger as we continue to read more data,
945 but not past CALLPROC_BUFFER_SIZE_MAX. */
946 if (bufsize
< CALLPROC_BUFFER_SIZE_MAX
&& total_read
> 32 * bufsize
)
947 if ((bufsize
*= 2) > CALLPROC_BUFFER_SIZE_MAX
)
948 bufsize
= CALLPROC_BUFFER_SIZE_MAX
;
954 prepare_menu_bars ();
956 redisplay_preserve_echo_area (1);
957 /* This variable might have been set to 0 for code
958 detection. In that case, we set it back to 1 because
959 we should have already detected a coding system. */
960 display_on_the_fly
= 1;
968 && process_coding
.cmp_data
)
970 coding_restore_composition (&process_coding
, Fcurrent_buffer ());
971 coding_free_composition_data (&process_coding
);
975 int post_read_count
= SPECPDL_INDEX ();
977 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
978 inserted
= PT
- pt_orig
;
979 TEMP_SET_PT_BOTH (pt_orig
, pt_byte_orig
);
980 if (SYMBOLP (process_coding
.post_read_conversion
)
981 && !NILP (Ffboundp (process_coding
.post_read_conversion
)))
982 call1 (process_coding
.post_read_conversion
, make_number (inserted
));
984 Vlast_coding_system_used
= process_coding
.symbol
;
986 /* If the caller required, let the buffer inherit the
987 coding-system used to decode the process output. */
988 if (inherit_process_coding_system
)
989 call1 (intern ("after-insert-file-set-buffer-file-coding-system"),
990 make_number (total_read
));
992 unbind_to (post_read_count
, Qnil
);
996 /* Wait for it to terminate, unless it already has. */
997 wait_for_termination (pid
);
1001 set_buffer_internal (old
);
1003 /* Don't kill any children that the subprocess may have left behind
1005 call_process_exited
= 1;
1007 unbind_to (count
, Qnil
);
1009 if (synch_process_termsig
)
1013 synchronize_system_messages_locale ();
1014 signame
= strsignal (synch_process_termsig
);
1017 signame
= "unknown";
1019 synch_process_death
= signame
;
1022 if (synch_process_death
)
1023 return code_convert_string_norecord (build_string (synch_process_death
),
1024 Vlocale_coding_system
, 0);
1025 return make_number (synch_process_retcode
);
1030 delete_temp_file (name
)
1033 /* Suppress jka-compr handling, etc. */
1034 int count
= SPECPDL_INDEX ();
1035 specbind (intern ("file-name-handler-alist"), Qnil
);
1036 internal_delete_file (name
);
1037 unbind_to (count
, Qnil
);
1041 DEFUN ("call-process-region", Fcall_process_region
, Scall_process_region
,
1043 doc
: /* Send text from START to END to a synchronous process running PROGRAM.
1044 The remaining arguments are optional.
1045 Delete the text if fourth arg DELETE is non-nil.
1047 Insert output in BUFFER before point; t means current buffer;
1048 nil for BUFFER means discard it; 0 means discard and don't wait.
1049 BUFFER can also have the form (REAL-BUFFER STDERR-FILE); in that case,
1050 REAL-BUFFER says what to do with standard output, as above,
1051 while STDERR-FILE says what to do with standard error in the child.
1052 STDERR-FILE may be nil (discard standard error output),
1053 t (mix it with ordinary output), or a file name string.
1055 Sixth arg DISPLAY non-nil means redisplay buffer as output is inserted.
1056 Remaining args are passed to PROGRAM at startup as command args.
1058 If BUFFER is 0, `call-process-region' returns immediately with value nil.
1059 Otherwise it waits for PROGRAM to terminate
1060 and returns a numeric exit status or a signal description string.
1061 If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.
1063 usage: (call-process-region START END PROGRAM &optional DELETE BUFFER DISPLAY &rest ARGS) */)
1066 register Lisp_Object
*args
;
1068 struct gcpro gcpro1
;
1069 Lisp_Object filename_string
;
1070 register Lisp_Object start
, end
;
1071 int count
= SPECPDL_INDEX ();
1072 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
1073 Lisp_Object coding_systems
;
1074 Lisp_Object val
, *args2
;
1080 if ((outf
= egetenv ("TMPDIR"))
1081 || (outf
= egetenv ("TMP"))
1082 || (outf
= egetenv ("TEMP")))
1083 strcpy (tempfile
= alloca (strlen (outf
) + 20), outf
);
1086 tempfile
= alloca (20);
1089 if (!IS_DIRECTORY_SEP (tempfile
[strlen (tempfile
) - 1]))
1090 strcat (tempfile
, "/");
1091 if ('/' == DIRECTORY_SEP
)
1092 dostounix_filename (tempfile
);
1094 unixtodos_filename (tempfile
);
1096 strcat (tempfile
, "emXXXXXX");
1098 strcat (tempfile
, "detmp.XXX");
1100 #else /* not DOS_NT */
1101 char *tempfile
= (char *) alloca (SBYTES (Vtemp_file_name_pattern
) + 1);
1102 bcopy (SDATA (Vtemp_file_name_pattern
), tempfile
,
1103 SBYTES (Vtemp_file_name_pattern
) + 1);
1104 #endif /* not DOS_NT */
1106 coding_systems
= Qt
;
1113 fd
= mkstemp (tempfile
);
1116 report_file_error ("Failed to open temporary file",
1117 Fcons (Vtemp_file_name_pattern
, Qnil
));
1125 filename_string
= build_string (tempfile
);
1126 GCPRO1 (filename_string
);
1129 /* Decide coding-system of the contents of the temporary file. */
1130 if (!NILP (Vcoding_system_for_write
))
1131 val
= Vcoding_system_for_write
;
1132 else if (NILP (current_buffer
->enable_multibyte_characters
))
1136 args2
= (Lisp_Object
*) alloca ((nargs
+ 1) * sizeof *args2
);
1137 args2
[0] = Qcall_process_region
;
1138 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
1139 coding_systems
= Ffind_operation_coding_system (nargs
+ 1, args2
);
1140 if (CONSP (coding_systems
))
1141 val
= XCDR (coding_systems
);
1142 else if (CONSP (Vdefault_process_coding_system
))
1143 val
= XCDR (Vdefault_process_coding_system
);
1149 int count1
= SPECPDL_INDEX ();
1151 specbind (intern ("coding-system-for-write"), val
);
1152 /* POSIX lets mk[s]temp use "."; don't invoke jka-compr if we
1153 happen to get a ".Z" suffix. */
1154 specbind (intern ("file-name-handler-alist"), Qnil
);
1155 Fwrite_region (start
, end
, filename_string
, Qnil
, Qlambda
, Qnil
, Qnil
);
1157 unbind_to (count1
, Qnil
);
1160 /* Note that Fcall_process takes care of binding
1161 coding-system-for-read. */
1163 record_unwind_protect (delete_temp_file
, filename_string
);
1165 if (nargs
> 3 && !NILP (args
[3]))
1166 Fdelete_region (start
, end
);
1178 args
[1] = filename_string
;
1180 RETURN_UNGCPRO (unbind_to (count
, Fcall_process (nargs
, args
)));
1183 #ifndef VMS /* VMS version is in vmsproc.c. */
1185 static int relocate_fd ();
1188 add_env (char **env
, char **new_env
, char *string
)
1195 /* See if this string duplicates any string already in the env.
1196 If so, don't put it in.
1197 When an env var has multiple definitions,
1198 we keep the definition that comes first in process-environment. */
1199 for (ep
= env
; ok
&& ep
!= new_env
; ep
++)
1201 char *p
= *ep
, *q
= string
;
1207 /* The string is a lone variable name; keep it for now, we
1208 will remove it later. It is a placeholder for a
1209 variable that is not to be included in the environment. */
1217 *new_env
++ = string
;
1221 /* This is the last thing run in a newly forked inferior
1222 either synchronous or asynchronous.
1223 Copy descriptors IN, OUT and ERR as descriptors 0, 1 and 2.
1224 Initialize inferior's priority, pgrp, connected dir and environment.
1225 then exec another program based on new_argv.
1227 This function may change environ for the superior process.
1228 Therefore, the superior process must save and restore the value
1229 of environ around the vfork and the call to this function.
1231 SET_PGRP is nonzero if we should put the subprocess into a separate
1234 CURRENT_DIR is an elisp string giving the path of the current
1235 directory the subprocess should have. Since we can't really signal
1236 a decent error from within the child, this should be verified as an
1237 executable directory by the parent. */
1240 child_setup (in
, out
, err
, new_argv
, set_pgrp
, current_dir
)
1242 register char **new_argv
;
1244 Lisp_Object current_dir
;
1251 #endif /* WINDOWSNT */
1253 int pid
= getpid ();
1255 #ifdef SET_EMACS_PRIORITY
1257 extern EMACS_INT emacs_priority
;
1259 if (emacs_priority
< 0)
1260 nice (- emacs_priority
);
1265 /* Close Emacs's descriptors that this process should not have. */
1266 close_process_descs ();
1268 /* DOS_NT isn't in a vfork, so if we are in the middle of load-file,
1269 we will lose if we call close_load_descs here. */
1271 close_load_descs ();
1274 /* Note that use of alloca is always safe here. It's obvious for systems
1275 that do not have true vfork or that have true (stack) alloca.
1276 If using vfork and C_ALLOCA (when Emacs used to include
1277 src/alloca.c) it is safe because that changes the superior's
1278 static variables as if the superior had done alloca and will be
1279 cleaned up in the usual way. */
1281 register char *temp
;
1284 i
= SBYTES (current_dir
);
1286 /* MSDOS must have all environment variables malloc'ed, because
1287 low-level libc functions that launch subsidiary processes rely
1289 pwd_var
= (char *) xmalloc (i
+ 6);
1291 pwd_var
= (char *) alloca (i
+ 6);
1294 bcopy ("PWD=", pwd_var
, 4);
1295 bcopy (SDATA (current_dir
), temp
, i
);
1296 if (!IS_DIRECTORY_SEP (temp
[i
- 1])) temp
[i
++] = DIRECTORY_SEP
;
1300 /* We can't signal an Elisp error here; we're in a vfork. Since
1301 the callers check the current directory before forking, this
1302 should only return an error if the directory's permissions
1303 are changed between the check and this chdir, but we should
1305 if (chdir (temp
) < 0)
1310 /* Get past the drive letter, so that d:/ is left alone. */
1311 if (i
> 2 && IS_DEVICE_SEP (temp
[1]) && IS_DIRECTORY_SEP (temp
[2]))
1318 /* Strip trailing slashes for PWD, but leave "/" and "//" alone. */
1319 while (i
> 2 && IS_DIRECTORY_SEP (temp
[i
- 1]))
1323 /* Set `env' to a vector of the strings in the environment. */
1325 register Lisp_Object tem
;
1326 register char **new_env
;
1328 register int new_length
;
1329 Lisp_Object local
= selected_frame
; /* get_frame_param (XFRAME (Fframe_with_environment (selected_frame)), */
1330 /* Qenvironment); */
1332 Lisp_Object display
;
1336 for (tem
= Vprocess_environment
;
1337 CONSP (tem
) && STRINGP (XCAR (tem
));
1343 CONSP (tem
) && STRINGP (XCAR (tem
));
1348 /* Add DISPLAY from the frame local values. */
1349 display
= get_frame_param (XFRAME (local
), Qdisplay_environment_variable
);
1350 if (! NILP (display
))
1353 /* new_length + 2 to include PWD and terminating 0. */
1354 env
= new_env
= (char **) alloca ((new_length
+ 2) * sizeof (char *));
1355 /* If we have a PWD envvar, pass one down,
1356 but with corrected value. */
1357 if (egetenv ("PWD"))
1358 *new_env
++ = pwd_var
;
1360 if (STRINGP (display
))
1362 int vlen
= strlen ("DISPLAY=") + strlen (SDATA (display
)) + 1;
1363 char *vdata
= (char *) alloca (vlen
);
1364 strcpy (vdata
, "DISPLAY=");
1365 strcat (vdata
, SDATA (display
));
1366 new_env
= add_env (env
, new_env
, vdata
);
1370 for (tem
= Vprocess_environment
;
1371 CONSP (tem
) && STRINGP (XCAR (tem
));
1374 if (strcmp (SDATA (XCAR (tem
)), "DISPLAY") != 0)
1375 new_env
= add_env (env
, new_env
, SDATA (XCAR (tem
)));
1380 /* Local part of environment. */
1382 CONSP (tem
) && STRINGP (XCAR (tem
));
1384 new_env
= add_env (env
, new_env
, SDATA (XCAR (tem
)));
1389 /* Remove variable names without values. */
1393 while (*q
!= 0 && strchr (*q
, '=') == NULL
)
1403 prepare_standard_handles (in
, out
, err
, handles
);
1404 set_process_dir (SDATA (current_dir
));
1405 #else /* not WINDOWSNT */
1406 /* Make sure that in, out, and err are not actually already in
1407 descriptors zero, one, or two; this could happen if Emacs is
1408 started with its standard in, out, or error closed, as might
1411 int oin
= in
, oout
= out
;
1413 /* We have to avoid relocating the same descriptor twice! */
1415 in
= relocate_fd (in
, 3);
1420 out
= relocate_fd (out
, 3);
1424 else if (err
== oout
)
1427 err
= relocate_fd (err
, 3);
1441 #endif /* not MSDOS */
1442 #endif /* not WINDOWSNT */
1444 #if defined(USG) && !defined(BSD_PGRPS)
1445 #ifndef SETPGRP_RELEASES_CTTY
1446 setpgrp (); /* No arguments but equivalent in this case */
1451 /* setpgrp_of_tty is incorrect here; it uses input_fd. */
1452 EMACS_SET_TTY_PGRP (0, &pid
);
1455 pid
= run_msdos_command (new_argv
, pwd_var
+ 4, in
, out
, err
, env
);
1458 /* An error occurred while trying to run the subprocess. */
1459 report_file_error ("Spawning child process", Qnil
);
1461 #else /* not MSDOS */
1463 /* Spawn the child. (See ntproc.c:Spawnve). */
1464 cpid
= spawnve (_P_NOWAIT
, new_argv
[0], new_argv
, env
);
1465 reset_standard_handles (in
, out
, err
, handles
);
1467 /* An error occurred while trying to spawn the process. */
1468 report_file_error ("Spawning child process", Qnil
);
1470 #else /* not WINDOWSNT */
1471 /* execvp does not accept an environment arg so the only way
1472 to pass this environment is to set environ. Our caller
1473 is responsible for restoring the ambient value of environ. */
1475 execvp (new_argv
[0], new_argv
);
1477 emacs_write (1, "Can't exec program: ", 20);
1478 emacs_write (1, new_argv
[0], strlen (new_argv
[0]));
1479 emacs_write (1, "\n", 1);
1481 #endif /* not WINDOWSNT */
1482 #endif /* not MSDOS */
1485 /* Move the file descriptor FD so that its number is not less than MINFD.
1486 If the file descriptor is moved at all, the original is freed. */
1488 relocate_fd (fd
, minfd
)
1498 char *message1
= "Error while setting up child: ";
1499 char *errmessage
= strerror (errno
);
1500 char *message2
= "\n";
1501 emacs_write (2, message1
, strlen (message1
));
1502 emacs_write (2, errmessage
, strlen (errmessage
));
1503 emacs_write (2, message2
, strlen (message2
));
1506 /* Note that we hold the original FD open while we recurse,
1507 to guarantee we'll get a new FD if we need it. */
1508 new = relocate_fd (new, minfd
);
1515 getenv_internal (var
, varlen
, value
, valuelen
, frame
)
1523 Lisp_Object display
;
1525 /* FIXME: Code duplication. */
1529 /* Try to find VAR in Vprocess_environment first. */
1530 for (scan
= Vprocess_environment
; CONSP (scan
); scan
= XCDR (scan
))
1532 Lisp_Object entry
= XCAR (scan
);
1534 && SBYTES (entry
) >= varlen
1536 /* NT environment variables are case insensitive. */
1537 && ! strnicmp (SDATA (entry
), var
, varlen
)
1538 #else /* not WINDOWSNT */
1539 && ! bcmp (SDATA (entry
), var
, varlen
)
1540 #endif /* not WINDOWSNT */
1543 if (SBYTES (entry
) > varlen
&& SREF (entry
, varlen
) == '=')
1545 *value
= (char *) SDATA (entry
) + (varlen
+ 1);
1546 *valuelen
= SBYTES (entry
) - (varlen
+ 1);
1549 else if (SBYTES (entry
) == varlen
)
1551 /* Lone variable names in Vprocess_environment mean that
1552 variable should be removed from the environment. */
1557 frame
= selected_frame
;
1560 /* For DISPLAY first try to get the values from the frame. */
1561 display
= get_frame_param (XFRAME (frame
), Qdisplay_environment_variable
);
1562 if (strcmp (var
, "DISPLAY") == 0)
1563 if (! NILP (display
))
1565 *value
= (char *) SDATA (display
);
1566 *valuelen
= SBYTES (display
);
1571 /* Try to find VAR in Vprocess_environment. */
1572 for (scan
= Vprocess_environment
; CONSP (scan
); scan
= XCDR (scan
))
1574 Lisp_Object entry
= XCAR (scan
);
1576 && SBYTES (entry
) >= varlen
1578 /* NT environment variables are case insensitive. */
1579 && ! strnicmp (SDATA (entry
), var
, varlen
)
1580 #else /* not WINDOWSNT */
1581 && ! bcmp (SDATA (entry
), var
, varlen
)
1582 #endif /* not WINDOWSNT */
1585 if (SBYTES (entry
) > varlen
&& SREF (entry
, varlen
) == '=')
1587 *value
= (char *) SDATA (entry
) + (varlen
+ 1);
1588 *valuelen
= SBYTES (entry
) - (varlen
+ 1);
1591 else if (SBYTES (entry
) == varlen
)
1593 /* Lone variable names in Vprocess_environment mean that
1594 variable should be removed from the environment. */
1602 /* Find the environment in which to search the variable. */
1603 CHECK_FRAME (frame
);
1604 frame
= Fframe_with_environment (frame
);
1606 for (scan
= get_frame_param (XFRAME (frame
), Qenvironment
);
1612 entry
= XCAR (scan
);
1614 && SBYTES (entry
) > varlen
1615 && SREF (entry
, varlen
) == '='
1617 /* NT environment variables are case insensitive. */
1618 && ! strnicmp (SDATA (entry
), var
, varlen
)
1619 #else /* not WINDOWSNT */
1620 && ! bcmp (SDATA (entry
), var
, varlen
)
1621 #endif /* not WINDOWSNT */
1624 *value
= (char *) SDATA (entry
) + (varlen
+ 1);
1625 *valuelen
= SBYTES (entry
) - (varlen
+ 1);
1633 DEFUN ("getenv-internal", Fgetenv_internal
, Sgetenv_internal
, 1, 2, 0,
1634 doc
: /* Get the value of environment variable VARIABLE.
1635 VARIABLE should be a string. Value is nil if VARIABLE is undefined in
1636 the environment. Otherwise, value is a string.
1638 This function searches `process-environment' for VARIABLE. If it is
1639 not found there, then it continues the search in the environment list
1640 of the selected frame.
1642 If optional parameter FRAME is non-nil, then this function will ignore
1643 `process-environment' and will simply look up the variable in that
1644 frame's environment. */)
1646 Lisp_Object variable
, frame
;
1651 CHECK_STRING (variable
);
1652 if (getenv_internal (SDATA (variable
), SBYTES (variable
),
1653 &value
, &valuelen
, frame
))
1654 return make_string (value
, valuelen
);
1659 /* A version of getenv that consults the Lisp environment lists,
1660 easily callable from C. */
1668 if (getenv_internal (var
, strlen (var
), &value
, &valuelen
, Qnil
))
1674 #endif /* not VMS */
1676 /* This is run before init_cmdargs. */
1681 char *data_dir
= egetenv ("EMACSDATA");
1682 char *doc_dir
= egetenv ("EMACSDOC");
1685 = Ffile_name_as_directory (build_string (data_dir
? data_dir
1688 = Ffile_name_as_directory (build_string (doc_dir
? doc_dir
1691 /* Check the EMACSPATH environment variable, defaulting to the
1692 PATH_EXEC path from epaths.h. */
1693 Vexec_path
= decode_env_path ("EMACSPATH", PATH_EXEC
);
1694 Vexec_directory
= Ffile_name_as_directory (Fcar (Vexec_path
));
1695 Vexec_path
= nconc2 (decode_env_path ("PATH", ""), Vexec_path
);
1698 /* This is run after init_cmdargs, when Vinstallation_directory is valid. */
1703 char *data_dir
= egetenv ("EMACSDATA");
1706 Lisp_Object tempdir
;
1708 if (!NILP (Vinstallation_directory
))
1710 /* Add to the path the lib-src subdir of the installation dir. */
1712 tem
= Fexpand_file_name (build_string ("lib-src"),
1713 Vinstallation_directory
);
1715 /* MSDOS uses wrapped binaries, so don't do this. */
1716 if (NILP (Fmember (tem
, Vexec_path
)))
1718 Vexec_path
= decode_env_path ("EMACSPATH", PATH_EXEC
);
1719 Vexec_path
= Fcons (tem
, Vexec_path
);
1720 Vexec_path
= nconc2 (decode_env_path ("PATH", ""), Vexec_path
);
1723 Vexec_directory
= Ffile_name_as_directory (tem
);
1724 #endif /* not DOS_NT */
1726 /* Maybe use ../etc as well as ../lib-src. */
1729 tem
= Fexpand_file_name (build_string ("etc"),
1730 Vinstallation_directory
);
1731 Vdoc_directory
= Ffile_name_as_directory (tem
);
1735 /* Look for the files that should be in etc. We don't use
1736 Vinstallation_directory, because these files are never installed
1737 near the executable, and they are never in the build
1738 directory when that's different from the source directory.
1740 Instead, if these files are not in the nominal place, we try the
1741 source directory. */
1744 Lisp_Object tem
, tem1
, srcdir
;
1746 srcdir
= Fexpand_file_name (build_string ("../src/"),
1747 build_string (PATH_DUMPLOADSEARCH
));
1748 tem
= Fexpand_file_name (build_string ("GNU"), Vdata_directory
);
1749 tem1
= Ffile_exists_p (tem
);
1750 if (!NILP (Fequal (srcdir
, Vinvocation_directory
)) || NILP (tem1
))
1753 newdir
= Fexpand_file_name (build_string ("../etc/"),
1754 build_string (PATH_DUMPLOADSEARCH
));
1755 tem
= Fexpand_file_name (build_string ("GNU"), newdir
);
1756 tem1
= Ffile_exists_p (tem
);
1758 Vdata_directory
= newdir
;
1766 tempdir
= Fdirectory_file_name (Vexec_directory
);
1767 if (access (SDATA (tempdir
), 0) < 0)
1768 dir_warning ("Warning: arch-dependent data dir (%s) does not exist.\n",
1772 tempdir
= Fdirectory_file_name (Vdata_directory
);
1773 if (access (SDATA (tempdir
), 0) < 0)
1774 dir_warning ("Warning: arch-independent data dir (%s) does not exist.\n",
1778 Vshell_file_name
= build_string ("*dcl*");
1780 sh
= (char *) getenv ("SHELL");
1781 Vshell_file_name
= build_string (sh
? sh
: "/bin/sh");
1785 Vtemp_file_name_pattern
= build_string ("tmp:emacsXXXXXX.");
1787 if (getenv ("TMPDIR"))
1789 char *dir
= getenv ("TMPDIR");
1790 Vtemp_file_name_pattern
1791 = Fexpand_file_name (build_string ("emacsXXXXXX"),
1792 build_string (dir
));
1795 Vtemp_file_name_pattern
= build_string ("/tmp/emacsXXXXXX");
1799 Vshared_game_score_directory
= Qnil
;
1801 Vshared_game_score_directory
= build_string (PATH_GAME
);
1802 if (NILP (Ffile_directory_p (Vshared_game_score_directory
)))
1803 Vshared_game_score_directory
= Qnil
;
1808 set_initial_environment ()
1810 register char **envp
;
1815 for (envp
= environ
; *envp
; envp
++)
1816 Vprocess_environment
= Fcons (build_string (*envp
),
1817 Vprocess_environment
);
1818 store_frame_param (SELECTED_FRAME(), Qenvironment
, Vprocess_environment
);
1819 /* Ideally, the `copy' shouldn't be necessary, but it seems it's frequent
1820 to use `delete' and friends on process-environment. */
1821 Vinitial_environment
= Fcopy_sequence (Vprocess_environment
);
1829 Qbuffer_file_type
= intern ("buffer-file-type");
1830 staticpro (&Qbuffer_file_type
);
1833 DEFVAR_LISP ("shell-file-name", &Vshell_file_name
,
1834 doc
: /* *File name to load inferior shells from.
1835 Initialized from the SHELL environment variable, or to a system-dependent
1836 default if SHELL is not set. */);
1838 DEFVAR_LISP ("exec-path", &Vexec_path
,
1839 doc
: /* *List of directories to search programs to run in subprocesses.
1840 Each element is a string (directory name) or nil (try default directory). */);
1842 DEFVAR_LISP ("exec-suffixes", &Vexec_suffixes
,
1843 doc
: /* *List of suffixes to try to find executable file names.
1844 Each element is a string. */);
1845 Vexec_suffixes
= Qnil
;
1847 DEFVAR_LISP ("exec-directory", &Vexec_directory
,
1848 doc
: /* Directory for executables for Emacs to invoke.
1849 More generally, this includes any architecture-dependent files
1850 that are built and installed from the Emacs distribution. */);
1852 DEFVAR_LISP ("data-directory", &Vdata_directory
,
1853 doc
: /* Directory of machine-independent files that come with GNU Emacs.
1854 These are files intended for Emacs to use while it runs. */);
1856 DEFVAR_LISP ("doc-directory", &Vdoc_directory
,
1857 doc
: /* Directory containing the DOC file that comes with GNU Emacs.
1858 This is usually the same as `data-directory'. */);
1860 DEFVAR_LISP ("configure-info-directory", &Vconfigure_info_directory
,
1861 doc
: /* For internal use by the build procedure only.
1862 This is the name of the directory in which the build procedure installed
1863 Emacs's info files; the default value for `Info-default-directory-list'
1865 Vconfigure_info_directory
= build_string (PATH_INFO
);
1867 DEFVAR_LISP ("shared-game-score-directory", &Vshared_game_score_directory
,
1868 doc
: /* Directory of score files for games which come with GNU Emacs.
1869 If this variable is nil, then Emacs is unable to use a shared directory. */);
1871 Vshared_game_score_directory
= Qnil
;
1873 Vshared_game_score_directory
= build_string (PATH_GAME
);
1876 DEFVAR_LISP ("temp-file-name-pattern", &Vtemp_file_name_pattern
,
1877 doc
: /* Pattern for making names for temporary files.
1878 This is used by `call-process-region'. */);
1879 /* This variable is initialized in init_callproc. */
1881 DEFVAR_LISP ("initial-environment", &Vinitial_environment
,
1882 doc
: /* List of environment variables inherited from the parent process.
1883 Each element should be a string of the form ENVVARNAME=VALUE.
1884 The elements must normally be decoded (using `locale-coding-system') for use. */);
1885 Vinitial_environment
= Qnil
;
1887 DEFVAR_LISP ("process-environment", &Vprocess_environment
,
1888 doc
: /* List of overridden environment variables for subprocesses to inherit.
1889 Each element should be a string of the form ENVVARNAME=VALUE.
1891 Entries in this list take precedence to those in the frame-local
1892 environments. Therefore, let-binding `process-environment' is an easy
1893 way to temporarily change the value of an environment variable,
1894 irrespective of where it comes from. To use `process-environment' to
1895 remove an environment variable, include only its name in the list,
1898 This variable is set to nil when Emacs starts.
1900 If multiple entries define the same variable, the first one always
1903 Non-ASCII characters are encoded according to the initial value of
1904 `locale-coding-system', i.e. the elements must normally be decoded for
1907 See `setenv' and `getenv'. */);
1908 Vprocess_environment
= Qnil
;
1911 defsubr (&Scall_process
);
1912 defsubr (&Sgetenv_internal
);
1914 defsubr (&Scall_process_region
);
1917 /* arch-tag: 769b8045-1df7-4d2b-8968-e3fb49017f95
1918 (do not change this comment) */