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, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
28 /* Define SIGCHLD as an alias for SIGCLD. */
30 #if !defined (SIGCHLD) && defined (SIGCLD)
31 #define SIGCHLD SIGCLD
34 #include <sys/types.h>
48 #include <stdlib.h> /* for proper declaration of environ */
51 #define _P_NOWAIT 1 /* from process.h */
54 #ifdef MSDOS /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
57 #include <sys/param.h>
71 #include "character.h"
74 #include "composite.h"
77 #include "syssignal.h"
79 #include "blockinput.h"
81 #include "termhooks.h"
88 extern char **environ
;
94 #define setpgrp setpgid
98 Lisp_Object Vexec_path
, Vexec_directory
, Vexec_suffixes
;
99 Lisp_Object Vdata_directory
, Vdoc_directory
;
100 Lisp_Object Vconfigure_info_directory
, Vshared_game_score_directory
;
102 /* Pattern used by call-process-region to make temp files. */
103 static Lisp_Object Vtemp_file_name_pattern
;
105 Lisp_Object Vshell_file_name
;
107 Lisp_Object Vprocess_environment
, Vinitial_environment
;
110 Lisp_Object Qbuffer_file_type
;
113 /* True if we are about to fork off a synchronous process or if we
114 are waiting for it. */
115 int synch_process_alive
;
117 /* Nonzero => this is a string explaining death of synchronous subprocess. */
118 const char *synch_process_death
;
120 /* Nonzero => this is the signal number that terminated the subprocess. */
121 int synch_process_termsig
;
123 /* If synch_process_death is zero,
124 this is exit code of synchronous subprocess. */
125 int synch_process_retcode
;
128 /* Clean up when exiting Fcall_process.
129 On MSDOS, delete the temporary file on any kind of termination.
130 On Unix, kill the process and any children on termination by signal. */
132 /* Nonzero if this is termination due to exit. */
133 static int call_process_exited
;
135 EXFUN (Fgetenv_internal
, 2);
138 call_process_kill (Lisp_Object fdpid
)
140 emacs_close (XFASTINT (Fcar (fdpid
)));
141 EMACS_KILLPG (XFASTINT (Fcdr (fdpid
)), SIGKILL
);
142 synch_process_alive
= 0;
147 call_process_cleanup (Lisp_Object arg
)
149 Lisp_Object fdpid
= Fcdr (arg
);
156 Fset_buffer (Fcar (arg
));
159 /* for MSDOS fdpid is really (fd . tempfile) */
161 emacs_close (XFASTINT (Fcar (fdpid
)));
162 if (strcmp (SDATA (file
), NULL_DEVICE
) != 0)
163 unlink (SDATA (file
));
164 #else /* not MSDOS */
165 pid
= XFASTINT (Fcdr (fdpid
));
167 if (call_process_exited
)
169 emacs_close (XFASTINT (Fcar (fdpid
)));
173 if (EMACS_KILLPG (pid
, SIGINT
) == 0)
175 int count
= SPECPDL_INDEX ();
176 record_unwind_protect (call_process_kill
, fdpid
);
177 message1 ("Waiting for process to die...(type C-g again to kill it instantly)");
180 wait_for_termination (pid
);
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 */
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 executable PROGRAM can't be found as an executable, `call-process'
207 signals a Lisp error. `call-process' reports errors in execution of
208 the program only through its return and output.
210 If BUFFER is 0, `call-process' returns immediately with value nil.
211 Otherwise it waits for PROGRAM to terminate
212 and returns a numeric exit status or a signal description string.
213 If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.
215 usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS) */)
216 (int nargs
, register Lisp_Object
*args
)
218 Lisp_Object infile
, buffer
, current_dir
, path
;
223 #define CALLPROC_BUFFER_SIZE_MIN (16 * 1024)
224 #define CALLPROC_BUFFER_SIZE_MAX (4 * CALLPROC_BUFFER_SIZE_MIN)
225 char buf
[CALLPROC_BUFFER_SIZE_MAX
];
226 int bufsize
= CALLPROC_BUFFER_SIZE_MIN
;
227 int count
= SPECPDL_INDEX ();
229 register const unsigned char **new_argv
;
230 /* File to use for stderr in the child.
231 t means use same as standard output. */
232 Lisp_Object error_file
;
233 #ifdef MSDOS /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
234 char *outf
, *tempfile
;
237 struct coding_system process_coding
; /* coding-system of process output */
238 struct coding_system argument_coding
; /* coding-system of arguments */
239 /* Set to the return value of Ffind_operation_coding_system. */
240 Lisp_Object coding_systems
;
242 /* Qt denotes that Ffind_operation_coding_system is not yet called. */
245 CHECK_STRING (args
[0]);
250 /* Without asynchronous processes we cannot have BUFFER == 0. */
252 && (INTEGERP (CONSP (args
[2]) ? XCAR (args
[2]) : args
[2])))
253 error ("Operating system cannot handle asynchronous subprocesses");
254 #endif /* subprocesses */
256 /* Decide the coding-system for giving arguments. */
258 Lisp_Object val
, *args2
;
261 /* If arguments are supplied, we may have to encode them. */
265 Lisp_Object coding_attrs
;
267 for (i
= 4; i
< nargs
; i
++)
268 CHECK_STRING (args
[i
]);
270 for (i
= 4; i
< nargs
; i
++)
271 if (STRING_MULTIBYTE (args
[i
]))
274 if (!NILP (Vcoding_system_for_write
))
275 val
= Vcoding_system_for_write
;
276 else if (! must_encode
)
280 args2
= (Lisp_Object
*) alloca ((nargs
+ 1) * sizeof *args2
);
281 args2
[0] = Qcall_process
;
282 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
283 coding_systems
= Ffind_operation_coding_system (nargs
+ 1, args2
);
284 if (CONSP (coding_systems
))
285 val
= XCDR (coding_systems
);
286 else if (CONSP (Vdefault_process_coding_system
))
287 val
= XCDR (Vdefault_process_coding_system
);
291 val
= coding_inherit_eol_type (val
, Qnil
);
292 setup_coding_system (Fcheck_coding_system (val
), &argument_coding
);
293 coding_attrs
= CODING_ID_ATTRS (argument_coding
.id
);
294 if (NILP (CODING_ATTR_ASCII_COMPAT (coding_attrs
)))
296 /* We should not use an ASCII incompatible coding system. */
297 val
= raw_text_coding_system (val
);
298 setup_coding_system (val
, &argument_coding
);
303 if (nargs
>= 2 && ! NILP (args
[1]))
305 infile
= Fexpand_file_name (args
[1], current_buffer
->directory
);
306 CHECK_STRING (infile
);
309 infile
= build_string (NULL_DEVICE
);
315 /* If BUFFER is a list, its meaning is
316 (BUFFER-FOR-STDOUT FILE-FOR-STDERR). */
319 if (CONSP (XCDR (buffer
)))
321 Lisp_Object stderr_file
;
322 stderr_file
= XCAR (XCDR (buffer
));
324 if (NILP (stderr_file
) || EQ (Qt
, stderr_file
))
325 error_file
= stderr_file
;
327 error_file
= Fexpand_file_name (stderr_file
, Qnil
);
330 buffer
= XCAR (buffer
);
333 if (!(EQ (buffer
, Qnil
)
335 || INTEGERP (buffer
)))
337 Lisp_Object spec_buffer
;
338 spec_buffer
= buffer
;
339 buffer
= Fget_buffer_create (buffer
);
340 /* Mention the buffer name for a better error message. */
342 CHECK_BUFFER (spec_buffer
);
343 CHECK_BUFFER (buffer
);
349 /* Make sure that the child will be able to chdir to the current
350 buffer's current directory, or its unhandled equivalent. We
351 can't just have the child check for an error when it does the
352 chdir, since it's in a vfork.
354 We have to GCPRO around this because Fexpand_file_name,
355 Funhandled_file_name_directory, and Ffile_accessible_directory_p
356 might call a file name handling function. The argument list is
357 protected by the caller, so all we really have to worry about is
360 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
362 current_dir
= current_buffer
->directory
;
364 GCPRO4 (infile
, buffer
, current_dir
, error_file
);
366 current_dir
= Funhandled_file_name_directory (current_dir
);
367 if (NILP (current_dir
))
368 /* If the file name handler says that current_dir is unreachable, use
369 a sensible default. */
370 current_dir
= build_string ("~/");
371 current_dir
= expand_and_dir_to_file (current_dir
, Qnil
);
372 current_dir
= Ffile_name_as_directory (current_dir
);
374 if (NILP (Ffile_accessible_directory_p (current_dir
)))
375 report_file_error ("Setting current directory",
376 Fcons (current_buffer
->directory
, Qnil
));
378 if (STRING_MULTIBYTE (infile
))
379 infile
= ENCODE_FILE (infile
);
380 if (STRING_MULTIBYTE (current_dir
))
381 current_dir
= ENCODE_FILE (current_dir
);
382 if (STRINGP (error_file
) && STRING_MULTIBYTE (error_file
))
383 error_file
= ENCODE_FILE (error_file
);
387 display_p
= INTERACTIVE
&& nargs
>= 4 && !NILP (args
[3]);
389 filefd
= emacs_open (SDATA (infile
), O_RDONLY
, 0);
392 infile
= DECODE_FILE (infile
);
393 report_file_error ("Opening process input file", Fcons (infile
, Qnil
));
395 /* Search for program; barf if not found. */
397 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
399 GCPRO4 (infile
, buffer
, current_dir
, error_file
);
400 openp (Vexec_path
, args
[0], Vexec_suffixes
, &path
, make_number (X_OK
));
405 emacs_close (filefd
);
406 report_file_error ("Searching for program", Fcons (args
[0], Qnil
));
409 /* If program file name starts with /: for quoting a magic name,
411 if (SBYTES (path
) > 2 && SREF (path
, 0) == '/'
412 && SREF (path
, 1) == ':')
413 path
= Fsubstring (path
, make_number (2), Qnil
);
415 new_argv
= (const unsigned char **)
416 alloca (max (2, nargs
- 2) * sizeof (char *));
420 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
422 GCPRO5 (infile
, buffer
, current_dir
, path
, error_file
);
423 argument_coding
.dst_multibyte
= 0;
424 for (i
= 4; i
< nargs
; i
++)
426 argument_coding
.src_multibyte
= STRING_MULTIBYTE (args
[i
]);
427 if (CODING_REQUIRE_ENCODING (&argument_coding
))
428 /* We must encode this argument. */
429 args
[i
] = encode_coding_string (&argument_coding
, args
[i
], 1);
432 for (i
= 4; i
< nargs
; i
++)
433 new_argv
[i
- 3] = SDATA (args
[i
]);
438 new_argv
[0] = SDATA (path
);
440 #ifdef MSDOS /* MW, July 1993 */
441 if ((outf
= egetenv ("TMPDIR")))
442 strcpy (tempfile
= alloca (strlen (outf
) + 20), outf
);
445 tempfile
= alloca (20);
448 dostounix_filename (tempfile
);
449 if (*tempfile
== '\0' || tempfile
[strlen (tempfile
) - 1] != '/')
450 strcat (tempfile
, "/");
451 strcat (tempfile
, "detmp.XXX");
454 outfilefd
= creat (tempfile
, S_IREAD
| S_IWRITE
);
457 emacs_close (filefd
);
458 report_file_error ("Opening process output file",
459 Fcons (build_string (tempfile
), Qnil
));
465 if (INTEGERP (buffer
))
466 fd
[1] = emacs_open (NULL_DEVICE
, O_WRONLY
, 0), fd
[0] = -1;
473 emacs_close (filefd
);
474 report_file_error ("Creating process pipe", Qnil
);
480 /* child_setup must clobber environ in systems with true vfork.
481 Protect it from permanent change. */
482 register char **save_environ
= environ
;
483 register int fd1
= fd
[1];
486 #if 0 /* Some systems don't have sigblock. */
487 mask
= sigblock (sigmask (SIGCHLD
));
490 /* Record that we're about to create a synchronous process. */
491 synch_process_alive
= 1;
493 /* These vars record information from process termination.
494 Clear them now before process can possibly terminate,
495 to avoid timing error if process terminates soon. */
496 synch_process_death
= 0;
497 synch_process_retcode
= 0;
498 synch_process_termsig
= 0;
500 if (NILP (error_file
))
501 fd_error
= emacs_open (NULL_DEVICE
, O_WRONLY
, 0);
502 else if (STRINGP (error_file
))
505 fd_error
= emacs_open (SDATA (error_file
),
506 O_WRONLY
| O_TRUNC
| O_CREAT
| O_TEXT
,
508 #else /* not DOS_NT */
509 fd_error
= creat (SDATA (error_file
), 0666);
510 #endif /* not DOS_NT */
515 emacs_close (filefd
);
523 if (NILP (error_file
))
524 error_file
= build_string (NULL_DEVICE
);
525 else if (STRINGP (error_file
))
526 error_file
= DECODE_FILE (error_file
);
527 report_file_error ("Cannot redirect stderr", Fcons (error_file
, Qnil
));
530 #ifdef MSDOS /* MW, July 1993 */
531 /* Note that on MSDOS `child_setup' actually returns the child process
532 exit status, not its PID, so we assign it to `synch_process_retcode'
534 pid
= child_setup (filefd
, outfilefd
, fd_error
, (char **) new_argv
,
537 /* Record that the synchronous process exited and note its
538 termination status. */
539 synch_process_alive
= 0;
540 synch_process_retcode
= pid
;
541 if (synch_process_retcode
< 0) /* means it couldn't be exec'ed */
543 synchronize_system_messages_locale ();
544 synch_process_death
= strerror (errno
);
547 emacs_close (outfilefd
);
548 if (fd_error
!= outfilefd
)
549 emacs_close (fd_error
);
550 fd1
= -1; /* No harm in closing that one! */
551 /* Since CRLF is converted to LF within `decode_coding', we can
552 always open a file with binary mode. */
553 fd
[0] = emacs_open (tempfile
, O_RDONLY
| O_BINARY
, 0);
557 emacs_close (filefd
);
558 report_file_error ("Cannot re-open temporary file", Qnil
);
560 #else /* not MSDOS */
562 pid
= child_setup (filefd
, fd1
, fd_error
, (char **) new_argv
,
564 #else /* not WINDOWSNT */
581 child_setup (filefd
, fd1
, fd_error
, (char **) new_argv
,
586 #endif /* not WINDOWSNT */
588 /* The MSDOS case did this already. */
590 emacs_close (fd_error
);
591 #endif /* not MSDOS */
593 environ
= save_environ
;
595 /* Close most of our fd's, but not fd[0]
596 since we will use that to read input from. */
597 emacs_close (filefd
);
598 if (fd1
>= 0 && fd1
!= fd_error
)
606 report_file_error ("Doing vfork", Qnil
);
609 if (INTEGERP (buffer
))
616 /* Enable sending signal if user quits below. */
617 call_process_exited
= 0;
620 /* MSDOS needs different cleanup information. */
621 record_unwind_protect (call_process_cleanup
,
622 Fcons (Fcurrent_buffer (),
623 Fcons (make_number (fd
[0]),
624 build_string (tempfile
))));
626 record_unwind_protect (call_process_cleanup
,
627 Fcons (Fcurrent_buffer (),
628 Fcons (make_number (fd
[0]), make_number (pid
))));
629 #endif /* not MSDOS */
632 if (BUFFERP (buffer
))
633 Fset_buffer (buffer
);
637 /* If BUFFER is nil, we must read process output once and then
638 discard it, so setup coding system but with nil. */
639 setup_coding_system (Qnil
, &process_coding
);
643 Lisp_Object val
, *args2
;
646 if (!NILP (Vcoding_system_for_read
))
647 val
= Vcoding_system_for_read
;
650 if (EQ (coding_systems
, Qt
))
654 args2
= (Lisp_Object
*) alloca ((nargs
+ 1) * sizeof *args2
);
655 args2
[0] = Qcall_process
;
656 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
658 = Ffind_operation_coding_system (nargs
+ 1, args2
);
660 if (CONSP (coding_systems
))
661 val
= XCAR (coding_systems
);
662 else if (CONSP (Vdefault_process_coding_system
))
663 val
= XCAR (Vdefault_process_coding_system
);
667 Fcheck_coding_system (val
);
668 /* In unibyte mode, character code conversion should not take
669 place but EOL conversion should. So, setup raw-text or one
670 of the subsidiary according to the information just setup. */
671 if (NILP (current_buffer
->enable_multibyte_characters
)
673 val
= raw_text_coding_system (val
);
674 setup_coding_system (val
, &process_coding
);
685 int display_on_the_fly
= display_p
;
686 struct coding_system saved_coding
;
688 saved_coding
= process_coding
;
691 /* Repeatedly read until we've filled as much as possible
692 of the buffer size we have. But don't read
693 less than 1024--save that for the next bufferful. */
695 while (nread
< bufsize
- 1024)
697 int this_read
= emacs_read (fd
[0], buf
+ nread
,
705 process_coding
.mode
|= CODING_MODE_LAST_BLOCK
;
710 total_read
+= this_read
;
712 if (display_on_the_fly
)
716 /* Now NREAD is the total amount of data in the buffer. */
721 if (NILP (current_buffer
->enable_multibyte_characters
)
722 && ! CODING_MAY_REQUIRE_DECODING (&process_coding
))
723 insert_1_both (buf
, nread
, nread
, 0, 1, 0);
725 { /* We have to decode the input. */
727 int count1
= SPECPDL_INDEX ();
729 XSETBUFFER (curbuf
, current_buffer
);
730 /* We cannot allow after-change-functions be run
731 during decoding, because that might modify the
732 buffer, while we rely on process_coding.produced to
733 faithfully reflect inserted text until we
734 TEMP_SET_PT_BOTH below. */
735 specbind (Qinhibit_modification_hooks
, Qt
);
736 decode_coding_c_string (&process_coding
, buf
, nread
,
738 unbind_to (count1
, Qnil
);
739 if (display_on_the_fly
740 && CODING_REQUIRE_DETECTION (&saved_coding
)
741 && ! CODING_REQUIRE_DETECTION (&process_coding
))
743 /* We have detected some coding system. But,
744 there's a possibility that the detection was
745 done by insufficient data. So, we give up
746 displaying on the fly. */
747 if (process_coding
.produced
> 0)
748 del_range_2 (process_coding
.dst_pos
,
749 process_coding
.dst_pos_byte
,
750 process_coding
.dst_pos
751 + process_coding
.produced_char
,
752 process_coding
.dst_pos_byte
753 + process_coding
.produced
, 0);
754 display_on_the_fly
= 0;
755 process_coding
= saved_coding
;
757 /* This is to make the above condition always
758 fails in the future. */
759 saved_coding
.common_flags
760 &= ~CODING_REQUIRE_DETECTION_MASK
;
764 TEMP_SET_PT_BOTH (PT
+ process_coding
.produced_char
,
765 PT_BYTE
+ process_coding
.produced
);
766 carryover
= process_coding
.carryover_bytes
;
768 memcpy (buf
, process_coding
.carryover
,
769 process_coding
.carryover_bytes
);
773 if (process_coding
.mode
& CODING_MODE_LAST_BLOCK
)
776 /* Make the buffer bigger as we continue to read more data,
777 but not past CALLPROC_BUFFER_SIZE_MAX. */
778 if (bufsize
< CALLPROC_BUFFER_SIZE_MAX
&& total_read
> 32 * bufsize
)
779 if ((bufsize
*= 2) > CALLPROC_BUFFER_SIZE_MAX
)
780 bufsize
= CALLPROC_BUFFER_SIZE_MAX
;
785 prepare_menu_bars ();
787 redisplay_preserve_echo_area (1);
788 /* This variable might have been set to 0 for code
789 detection. In that case, we set it back to 1 because
790 we should have already detected a coding system. */
791 display_on_the_fly
= 1;
798 Vlast_coding_system_used
= CODING_ID_NAME (process_coding
.id
);
799 /* If the caller required, let the buffer inherit the
800 coding-system used to decode the process output. */
801 if (inherit_process_coding_system
)
802 call1 (intern ("after-insert-file-set-buffer-file-coding-system"),
803 make_number (total_read
));
807 /* Wait for it to terminate, unless it already has. */
808 wait_for_termination (pid
);
813 /* Don't kill any children that the subprocess may have left behind
815 call_process_exited
= 1;
817 unbind_to (count
, Qnil
);
819 if (synch_process_termsig
)
823 synchronize_system_messages_locale ();
824 signame
= strsignal (synch_process_termsig
);
829 synch_process_death
= signame
;
832 if (synch_process_death
)
833 return code_convert_string_norecord (build_string (synch_process_death
),
834 Vlocale_coding_system
, 0);
835 return make_number (synch_process_retcode
);
839 delete_temp_file (Lisp_Object name
)
841 /* Suppress jka-compr handling, etc. */
842 int count
= SPECPDL_INDEX ();
843 specbind (intern ("file-name-handler-alist"), Qnil
);
844 internal_delete_file (name
);
845 unbind_to (count
, Qnil
);
849 DEFUN ("call-process-region", Fcall_process_region
, Scall_process_region
,
851 doc
: /* Send text from START to END to a synchronous process running PROGRAM.
852 The remaining arguments are optional.
853 Delete the text if fourth arg DELETE is non-nil.
855 Insert output in BUFFER before point; t means current buffer;
856 nil for BUFFER means discard it; 0 means discard and don't wait.
857 BUFFER can also have the form (REAL-BUFFER STDERR-FILE); in that case,
858 REAL-BUFFER says what to do with standard output, as above,
859 while STDERR-FILE says what to do with standard error in the child.
860 STDERR-FILE may be nil (discard standard error output),
861 t (mix it with ordinary output), or a file name string.
863 Sixth arg DISPLAY non-nil means redisplay buffer as output is inserted.
864 Remaining args are passed to PROGRAM at startup as command args.
866 If BUFFER is 0, `call-process-region' returns immediately with value nil.
867 Otherwise it waits for PROGRAM to terminate
868 and returns a numeric exit status or a signal description string.
869 If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.
871 usage: (call-process-region START END PROGRAM &optional DELETE BUFFER DISPLAY &rest ARGS) */)
872 (int nargs
, register Lisp_Object
*args
)
875 Lisp_Object filename_string
;
876 register Lisp_Object start
, end
;
877 int count
= SPECPDL_INDEX ();
878 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
879 Lisp_Object coding_systems
;
880 Lisp_Object val
, *args2
;
883 Lisp_Object tmpdir
, pattern
;
885 if (STRINGP (Vtemporary_file_directory
))
886 tmpdir
= Vtemporary_file_directory
;
890 if (getenv ("TMPDIR"))
891 tmpdir
= build_string (getenv ("TMPDIR"));
893 tmpdir
= build_string ("/tmp/");
896 if ((outf
= egetenv ("TMPDIR"))
897 || (outf
= egetenv ("TMP"))
898 || (outf
= egetenv ("TEMP")))
899 tmpdir
= build_string (outf
);
901 tmpdir
= Ffile_name_as_directory (build_string ("c:/temp"));
905 pattern
= Fexpand_file_name (Vtemp_file_name_pattern
, tmpdir
);
906 tempfile
= (char *) alloca (SBYTES (pattern
) + 1);
907 memcpy (tempfile
, SDATA (pattern
), SBYTES (pattern
) + 1);
915 fd
= mkstemp (tempfile
);
918 report_file_error ("Failed to open temporary file",
919 Fcons (Vtemp_file_name_pattern
, Qnil
));
927 filename_string
= build_string (tempfile
);
928 GCPRO1 (filename_string
);
931 /* Decide coding-system of the contents of the temporary file. */
932 if (!NILP (Vcoding_system_for_write
))
933 val
= Vcoding_system_for_write
;
934 else if (NILP (current_buffer
->enable_multibyte_characters
))
938 args2
= (Lisp_Object
*) alloca ((nargs
+ 1) * sizeof *args2
);
939 args2
[0] = Qcall_process_region
;
940 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
941 coding_systems
= Ffind_operation_coding_system (nargs
+ 1, args2
);
942 if (CONSP (coding_systems
))
943 val
= XCDR (coding_systems
);
944 else if (CONSP (Vdefault_process_coding_system
))
945 val
= XCDR (Vdefault_process_coding_system
);
951 int count1
= SPECPDL_INDEX ();
953 specbind (intern ("coding-system-for-write"), val
);
954 /* POSIX lets mk[s]temp use "."; don't invoke jka-compr if we
955 happen to get a ".Z" suffix. */
956 specbind (intern ("file-name-handler-alist"), Qnil
);
957 Fwrite_region (start
, end
, filename_string
, Qnil
, Qlambda
, Qnil
, Qnil
);
959 unbind_to (count1
, Qnil
);
962 /* Note that Fcall_process takes care of binding
963 coding-system-for-read. */
965 record_unwind_protect (delete_temp_file
, filename_string
);
967 if (nargs
> 3 && !NILP (args
[3]))
968 Fdelete_region (start
, end
);
980 args
[1] = filename_string
;
982 RETURN_UNGCPRO (unbind_to (count
, Fcall_process (nargs
, args
)));
986 static int relocate_fd (int fd
, int minfd
);
990 add_env (char **env
, char **new_env
, char *string
)
997 /* See if this string duplicates any string already in the env.
998 If so, don't put it in.
999 When an env var has multiple definitions,
1000 we keep the definition that comes first in process-environment. */
1001 for (ep
= env
; ok
&& ep
!= new_env
; ep
++)
1003 char *p
= *ep
, *q
= string
;
1009 /* The string is a lone variable name; keep it for now, we
1010 will remove it later. It is a placeholder for a
1011 variable that is not to be included in the environment. */
1019 *new_env
++ = string
;
1023 /* This is the last thing run in a newly forked inferior
1024 either synchronous or asynchronous.
1025 Copy descriptors IN, OUT and ERR as descriptors 0, 1 and 2.
1026 Initialize inferior's priority, pgrp, connected dir and environment.
1027 then exec another program based on new_argv.
1029 This function may change environ for the superior process.
1030 Therefore, the superior process must save and restore the value
1031 of environ around the vfork and the call to this function.
1033 SET_PGRP is nonzero if we should put the subprocess into a separate
1036 CURRENT_DIR is an elisp string giving the path of the current
1037 directory the subprocess should have. Since we can't really signal
1038 a decent error from within the child, this should be verified as an
1039 executable directory by the parent. */
1042 child_setup (int in
, int out
, int err
, register char **new_argv
, int set_pgrp
, Lisp_Object current_dir
)
1049 #endif /* WINDOWSNT */
1051 int pid
= getpid ();
1053 /* Close Emacs's descriptors that this process should not have. */
1054 close_process_descs ();
1056 /* DOS_NT isn't in a vfork, so if we are in the middle of load-file,
1057 we will lose if we call close_load_descs here. */
1059 close_load_descs ();
1062 /* Note that use of alloca is always safe here. It's obvious for systems
1063 that do not have true vfork or that have true (stack) alloca.
1064 If using vfork and C_ALLOCA (when Emacs used to include
1065 src/alloca.c) it is safe because that changes the superior's
1066 static variables as if the superior had done alloca and will be
1067 cleaned up in the usual way. */
1069 register char *temp
;
1072 i
= SBYTES (current_dir
);
1074 /* MSDOS must have all environment variables malloc'ed, because
1075 low-level libc functions that launch subsidiary processes rely
1077 pwd_var
= (char *) xmalloc (i
+ 6);
1079 pwd_var
= (char *) alloca (i
+ 6);
1082 memcpy (pwd_var
, "PWD=", 4);
1083 memcpy (temp
, SDATA (current_dir
), i
);
1084 if (!IS_DIRECTORY_SEP (temp
[i
- 1])) temp
[i
++] = DIRECTORY_SEP
;
1088 /* We can't signal an Elisp error here; we're in a vfork. Since
1089 the callers check the current directory before forking, this
1090 should only return an error if the directory's permissions
1091 are changed between the check and this chdir, but we should
1093 if (chdir (temp
) < 0)
1096 /* Get past the drive letter, so that d:/ is left alone. */
1097 if (i
> 2 && IS_DEVICE_SEP (temp
[1]) && IS_DIRECTORY_SEP (temp
[2]))
1104 /* Strip trailing slashes for PWD, but leave "/" and "//" alone. */
1105 while (i
> 2 && IS_DIRECTORY_SEP (temp
[i
- 1]))
1109 /* Set `env' to a vector of the strings in the environment. */
1111 register Lisp_Object tem
;
1112 register char **new_env
;
1114 register int new_length
;
1115 Lisp_Object display
= Qnil
;
1119 for (tem
= Vprocess_environment
;
1120 CONSP (tem
) && STRINGP (XCAR (tem
));
1123 if (strncmp (SDATA (XCAR (tem
)), "DISPLAY", 7) == 0
1124 && (SDATA (XCAR (tem
)) [7] == '\0'
1125 || SDATA (XCAR (tem
)) [7] == '='))
1126 /* DISPLAY is specified in process-environment. */
1131 /* If not provided yet, use the frame's DISPLAY. */
1134 Lisp_Object tmp
= Fframe_parameter (selected_frame
, Qdisplay
);
1135 if (!STRINGP (tmp
) && CONSP (Vinitial_environment
))
1136 /* If still not found, Look for DISPLAY in Vinitial_environment. */
1137 tmp
= Fgetenv_internal (build_string ("DISPLAY"),
1138 Vinitial_environment
);
1146 /* new_length + 2 to include PWD and terminating 0. */
1147 env
= new_env
= (char **) alloca ((new_length
+ 2) * sizeof (char *));
1148 /* If we have a PWD envvar, pass one down,
1149 but with corrected value. */
1150 if (egetenv ("PWD"))
1151 *new_env
++ = pwd_var
;
1153 if (STRINGP (display
))
1155 int vlen
= strlen ("DISPLAY=") + strlen (SDATA (display
)) + 1;
1156 char *vdata
= (char *) alloca (vlen
);
1157 strcpy (vdata
, "DISPLAY=");
1158 strcat (vdata
, SDATA (display
));
1159 new_env
= add_env (env
, new_env
, vdata
);
1163 for (tem
= Vprocess_environment
;
1164 CONSP (tem
) && STRINGP (XCAR (tem
));
1166 new_env
= add_env (env
, new_env
, SDATA (XCAR (tem
)));
1170 /* Remove variable names without values. */
1174 while (*q
!= 0 && strchr (*q
, '=') == NULL
)
1184 prepare_standard_handles (in
, out
, err
, handles
);
1185 set_process_dir (SDATA (current_dir
));
1186 #else /* not WINDOWSNT */
1187 /* Make sure that in, out, and err are not actually already in
1188 descriptors zero, one, or two; this could happen if Emacs is
1189 started with its standard in, out, or error closed, as might
1192 int oin
= in
, oout
= out
;
1194 /* We have to avoid relocating the same descriptor twice! */
1196 in
= relocate_fd (in
, 3);
1201 out
= relocate_fd (out
, 3);
1205 else if (err
== oout
)
1208 err
= relocate_fd (err
, 3);
1222 if (err
!= in
&& err
!= out
)
1224 #endif /* not MSDOS */
1225 #endif /* not WINDOWSNT */
1228 #ifndef SETPGRP_RELEASES_CTTY
1229 setpgrp (); /* No arguments but equivalent in this case */
1236 pid
= run_msdos_command (new_argv
, pwd_var
+ 4, in
, out
, err
, env
);
1239 /* An error occurred while trying to run the subprocess. */
1240 report_file_error ("Spawning child process", Qnil
);
1242 #else /* not MSDOS */
1244 /* Spawn the child. (See ntproc.c:Spawnve). */
1245 cpid
= spawnve (_P_NOWAIT
, new_argv
[0], new_argv
, env
);
1246 reset_standard_handles (in
, out
, err
, handles
);
1248 /* An error occurred while trying to spawn the process. */
1249 report_file_error ("Spawning child process", Qnil
);
1251 #else /* not WINDOWSNT */
1252 /* setpgrp_of_tty is incorrect here; it uses input_fd. */
1253 EMACS_SET_TTY_PGRP (0, &pid
);
1255 /* execvp does not accept an environment arg so the only way
1256 to pass this environment is to set environ. Our caller
1257 is responsible for restoring the ambient value of environ. */
1259 execvp (new_argv
[0], new_argv
);
1261 emacs_write (1, "Can't exec program: ", 20);
1262 emacs_write (1, new_argv
[0], strlen (new_argv
[0]));
1263 emacs_write (1, "\n", 1);
1265 #endif /* not WINDOWSNT */
1266 #endif /* not MSDOS */
1270 /* Move the file descriptor FD so that its number is not less than MINFD.
1271 If the file descriptor is moved at all, the original is freed. */
1273 relocate_fd (int fd
, int minfd
)
1281 new = fcntl (fd
, F_DUPFD
, minfd
);
1285 /* Note that we hold the original FD open while we recurse,
1286 to guarantee we'll get a new FD if we need it. */
1287 new = relocate_fd (new, minfd
);
1291 const char *message1
= "Error while setting up child: ";
1292 const char *errmessage
= strerror (errno
);
1293 const char *message2
= "\n";
1294 emacs_write (2, message1
, strlen (message1
));
1295 emacs_write (2, errmessage
, strlen (errmessage
));
1296 emacs_write (2, message2
, strlen (message2
));
1303 #endif /* not WINDOWSNT */
1306 getenv_internal_1 (const char *var
, int varlen
, char **value
, int *valuelen
,
1309 for (; CONSP (env
); env
= XCDR (env
))
1311 Lisp_Object entry
= XCAR (env
);
1313 && SBYTES (entry
) >= varlen
1315 /* NT environment variables are case insensitive. */
1316 && ! strnicmp (SDATA (entry
), var
, varlen
)
1317 #else /* not WINDOWSNT */
1318 && ! memcmp (SDATA (entry
), var
, varlen
)
1319 #endif /* not WINDOWSNT */
1322 if (SBYTES (entry
) > varlen
&& SREF (entry
, varlen
) == '=')
1324 *value
= (char *) SDATA (entry
) + (varlen
+ 1);
1325 *valuelen
= SBYTES (entry
) - (varlen
+ 1);
1328 else if (SBYTES (entry
) == varlen
)
1330 /* Lone variable names in Vprocess_environment mean that
1331 variable should be removed from the environment. */
1341 getenv_internal (const char *var
, int varlen
, char **value
, int *valuelen
,
1344 /* Try to find VAR in Vprocess_environment first. */
1345 if (getenv_internal_1 (var
, varlen
, value
, valuelen
,
1346 Vprocess_environment
))
1347 return *value
? 1 : 0;
1349 /* For DISPLAY try to get the values from the frame or the initial env. */
1350 if (strcmp (var
, "DISPLAY") == 0)
1353 = Fframe_parameter (NILP (frame
) ? selected_frame
: frame
, Qdisplay
);
1354 if (STRINGP (display
))
1356 *value
= (char *) SDATA (display
);
1357 *valuelen
= SBYTES (display
);
1360 /* If still not found, Look for DISPLAY in Vinitial_environment. */
1361 if (getenv_internal_1 (var
, varlen
, value
, valuelen
,
1362 Vinitial_environment
))
1363 return *value
? 1 : 0;
1369 DEFUN ("getenv-internal", Fgetenv_internal
, Sgetenv_internal
, 1, 2, 0,
1370 doc
: /* Get the value of environment variable VARIABLE.
1371 VARIABLE should be a string. Value is nil if VARIABLE is undefined in
1372 the environment. Otherwise, value is a string.
1374 This function searches `process-environment' for VARIABLE.
1376 If optional parameter ENV is a list, then search this list instead of
1377 `process-environment', and return t when encountering a negative entry
1378 \(an entry for a variable with no value). */)
1379 (Lisp_Object variable
, Lisp_Object env
)
1384 CHECK_STRING (variable
);
1387 if (getenv_internal_1 (SDATA (variable
), SBYTES (variable
),
1388 &value
, &valuelen
, env
))
1389 return value
? make_string (value
, valuelen
) : Qt
;
1393 else if (getenv_internal (SDATA (variable
), SBYTES (variable
),
1394 &value
, &valuelen
, env
))
1395 return make_string (value
, valuelen
);
1400 /* A version of getenv that consults the Lisp environment lists,
1401 easily callable from C. */
1403 egetenv (const char *var
)
1408 if (getenv_internal (var
, strlen (var
), &value
, &valuelen
, Qnil
))
1415 /* This is run before init_cmdargs. */
1418 init_callproc_1 (void)
1420 char *data_dir
= egetenv ("EMACSDATA");
1421 char *doc_dir
= egetenv ("EMACSDOC");
1424 = Ffile_name_as_directory (build_string (data_dir
? data_dir
1427 = Ffile_name_as_directory (build_string (doc_dir
? doc_dir
1430 /* Check the EMACSPATH environment variable, defaulting to the
1431 PATH_EXEC path from epaths.h. */
1432 Vexec_path
= decode_env_path ("EMACSPATH", PATH_EXEC
);
1433 Vexec_directory
= Ffile_name_as_directory (Fcar (Vexec_path
));
1434 Vexec_path
= nconc2 (decode_env_path ("PATH", ""), Vexec_path
);
1437 /* This is run after init_cmdargs, when Vinstallation_directory is valid. */
1440 init_callproc (void)
1442 char *data_dir
= egetenv ("EMACSDATA");
1445 Lisp_Object tempdir
;
1447 if (!NILP (Vinstallation_directory
))
1449 /* Add to the path the lib-src subdir of the installation dir. */
1451 tem
= Fexpand_file_name (build_string ("lib-src"),
1452 Vinstallation_directory
);
1454 /* MSDOS uses wrapped binaries, so don't do this. */
1455 if (NILP (Fmember (tem
, Vexec_path
)))
1457 Vexec_path
= decode_env_path ("EMACSPATH", PATH_EXEC
);
1458 Vexec_path
= Fcons (tem
, Vexec_path
);
1459 Vexec_path
= nconc2 (decode_env_path ("PATH", ""), Vexec_path
);
1462 Vexec_directory
= Ffile_name_as_directory (tem
);
1463 #endif /* not DOS_NT */
1465 /* Maybe use ../etc as well as ../lib-src. */
1468 tem
= Fexpand_file_name (build_string ("etc"),
1469 Vinstallation_directory
);
1470 Vdoc_directory
= Ffile_name_as_directory (tem
);
1474 /* Look for the files that should be in etc. We don't use
1475 Vinstallation_directory, because these files are never installed
1476 near the executable, and they are never in the build
1477 directory when that's different from the source directory.
1479 Instead, if these files are not in the nominal place, we try the
1480 source directory. */
1483 Lisp_Object tem
, tem1
, srcdir
;
1485 srcdir
= Fexpand_file_name (build_string ("../src/"),
1486 build_string (PATH_DUMPLOADSEARCH
));
1487 tem
= Fexpand_file_name (build_string ("GNU"), Vdata_directory
);
1488 tem1
= Ffile_exists_p (tem
);
1489 if (!NILP (Fequal (srcdir
, Vinvocation_directory
)) || NILP (tem1
))
1492 newdir
= Fexpand_file_name (build_string ("../etc/"),
1493 build_string (PATH_DUMPLOADSEARCH
));
1494 tem
= Fexpand_file_name (build_string ("GNU"), newdir
);
1495 tem1
= Ffile_exists_p (tem
);
1497 Vdata_directory
= newdir
;
1505 tempdir
= Fdirectory_file_name (Vexec_directory
);
1506 if (access (SDATA (tempdir
), 0) < 0)
1507 dir_warning ("Warning: arch-dependent data dir (%s) does not exist.\n",
1511 tempdir
= Fdirectory_file_name (Vdata_directory
);
1512 if (access (SDATA (tempdir
), 0) < 0)
1513 dir_warning ("Warning: arch-independent data dir (%s) does not exist.\n",
1516 sh
= (char *) getenv ("SHELL");
1517 Vshell_file_name
= build_string (sh
? sh
: "/bin/sh");
1520 Vshared_game_score_directory
= Qnil
;
1522 Vshared_game_score_directory
= build_string (PATH_GAME
);
1523 if (NILP (Ffile_directory_p (Vshared_game_score_directory
)))
1524 Vshared_game_score_directory
= Qnil
;
1529 set_initial_environment (void)
1531 register char **envp
;
1533 Vprocess_environment
= Qnil
;
1538 for (envp
= environ
; *envp
; envp
++)
1539 Vprocess_environment
= Fcons (build_string (*envp
),
1540 Vprocess_environment
);
1541 /* Ideally, the `copy' shouldn't be necessary, but it seems it's frequent
1542 to use `delete' and friends on process-environment. */
1543 Vinitial_environment
= Fcopy_sequence (Vprocess_environment
);
1548 syms_of_callproc (void)
1551 Qbuffer_file_type
= intern ("buffer-file-type");
1552 staticpro (&Qbuffer_file_type
);
1556 Vtemp_file_name_pattern
= build_string ("emacsXXXXXX");
1557 #elif defined (WINDOWSNT)
1558 Vtemp_file_name_pattern
= build_string ("emXXXXXX");
1560 Vtemp_file_name_pattern
= build_string ("detmp.XXX");
1562 staticpro (&Vtemp_file_name_pattern
);
1564 DEFVAR_LISP ("shell-file-name", &Vshell_file_name
,
1565 doc
: /* *File name to load inferior shells from.
1566 Initialized from the SHELL environment variable, or to a system-dependent
1567 default if SHELL is not set. */);
1569 DEFVAR_LISP ("exec-path", &Vexec_path
,
1570 doc
: /* *List of directories to search programs to run in subprocesses.
1571 Each element is a string (directory name) or nil (try default directory). */);
1573 DEFVAR_LISP ("exec-suffixes", &Vexec_suffixes
,
1574 doc
: /* *List of suffixes to try to find executable file names.
1575 Each element is a string. */);
1576 Vexec_suffixes
= Qnil
;
1578 DEFVAR_LISP ("exec-directory", &Vexec_directory
,
1579 doc
: /* Directory for executables for Emacs to invoke.
1580 More generally, this includes any architecture-dependent files
1581 that are built and installed from the Emacs distribution. */);
1583 DEFVAR_LISP ("data-directory", &Vdata_directory
,
1584 doc
: /* Directory of machine-independent files that come with GNU Emacs.
1585 These are files intended for Emacs to use while it runs. */);
1587 DEFVAR_LISP ("doc-directory", &Vdoc_directory
,
1588 doc
: /* Directory containing the DOC file that comes with GNU Emacs.
1589 This is usually the same as `data-directory'. */);
1591 DEFVAR_LISP ("configure-info-directory", &Vconfigure_info_directory
,
1592 doc
: /* For internal use by the build procedure only.
1593 This is the name of the directory in which the build procedure installed
1594 Emacs's info files; the default value for `Info-default-directory-list'
1596 Vconfigure_info_directory
= build_string (PATH_INFO
);
1598 DEFVAR_LISP ("shared-game-score-directory", &Vshared_game_score_directory
,
1599 doc
: /* Directory of score files for games which come with GNU Emacs.
1600 If this variable is nil, then Emacs is unable to use a shared directory. */);
1602 Vshared_game_score_directory
= Qnil
;
1604 Vshared_game_score_directory
= build_string (PATH_GAME
);
1607 DEFVAR_LISP ("initial-environment", &Vinitial_environment
,
1608 doc
: /* List of environment variables inherited from the parent process.
1609 Each element should be a string of the form ENVVARNAME=VALUE.
1610 The elements must normally be decoded (using `locale-coding-system') for use. */);
1611 Vinitial_environment
= Qnil
;
1613 DEFVAR_LISP ("process-environment", &Vprocess_environment
,
1614 doc
: /* List of overridden environment variables for subprocesses to inherit.
1615 Each element should be a string of the form ENVVARNAME=VALUE.
1617 Entries in this list take precedence to those in the frame-local
1618 environments. Therefore, let-binding `process-environment' is an easy
1619 way to temporarily change the value of an environment variable,
1620 irrespective of where it comes from. To use `process-environment' to
1621 remove an environment variable, include only its name in the list,
1624 This variable is set to nil when Emacs starts.
1626 If multiple entries define the same variable, the first one always
1629 Non-ASCII characters are encoded according to the initial value of
1630 `locale-coding-system', i.e. the elements must normally be decoded for
1633 See `setenv' and `getenv'. */);
1634 Vprocess_environment
= Qnil
;
1636 defsubr (&Scall_process
);
1637 defsubr (&Sgetenv_internal
);
1638 defsubr (&Scall_process_region
);
1641 /* arch-tag: 769b8045-1df7-4d2b-8968-e3fb49017f95
1642 (do not change this comment) */