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
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/>. */
31 /* Define SIGCHLD as an alias for SIGCLD. */
33 #if !defined (SIGCHLD) && defined (SIGCLD)
34 #define SIGCHLD SIGCLD
37 #include <sys/types.h>
45 #define INCLUDED_FCNTL
52 #include <stdlib.h> /* for proper declaration of environ */
55 #define _P_NOWAIT 1 /* from process.h */
58 #ifdef MSDOS /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
59 #define INCLUDED_FCNTL
62 #include <sys/param.h>
77 #include "character.h"
80 #include "composite.h"
83 #include "syssignal.h"
85 #include "blockinput.h"
87 #include "termhooks.h"
94 extern char **environ
;
98 #if !defined (USG) || defined (BSD_PGRPS)
100 #define setpgrp setpgid
104 Lisp_Object Vexec_path
, Vexec_directory
, Vexec_suffixes
;
105 Lisp_Object Vdata_directory
, Vdoc_directory
;
106 Lisp_Object Vconfigure_info_directory
, Vshared_game_score_directory
;
108 /* Pattern used by call-process-region to make temp files. */
109 static Lisp_Object Vtemp_file_name_pattern
;
111 extern Lisp_Object Vtemporary_file_directory
;
113 Lisp_Object Vshell_file_name
;
115 Lisp_Object Vprocess_environment
, Vinitial_environment
;
118 Lisp_Object Qbuffer_file_type
;
121 /* True if we are about to fork off a synchronous process or if we
122 are waiting for it. */
123 int synch_process_alive
;
125 /* Nonzero => this is a string explaining death of synchronous subprocess. */
126 char *synch_process_death
;
128 /* Nonzero => this is the signal number that terminated the subprocess. */
129 int synch_process_termsig
;
131 /* If synch_process_death is zero,
132 this is exit code of synchronous subprocess. */
133 int synch_process_retcode
;
136 /* Clean up when exiting Fcall_process.
137 On MSDOS, delete the temporary file on any kind of termination.
138 On Unix, kill the process and any children on termination by signal. */
140 /* Nonzero if this is termination due to exit. */
141 static int call_process_exited
;
143 EXFUN (Fgetenv_internal
, 2);
146 call_process_kill (fdpid
)
149 emacs_close (XFASTINT (Fcar (fdpid
)));
150 EMACS_KILLPG (XFASTINT (Fcdr (fdpid
)), SIGKILL
);
151 synch_process_alive
= 0;
156 call_process_cleanup (arg
)
159 Lisp_Object fdpid
= Fcdr (arg
);
166 Fset_buffer (Fcar (arg
));
169 /* for MSDOS fdpid is really (fd . tempfile) */
171 emacs_close (XFASTINT (Fcar (fdpid
)));
172 if (strcmp (SDATA (file
), NULL_DEVICE
) != 0)
173 unlink (SDATA (file
));
174 #else /* not MSDOS */
175 pid
= XFASTINT (Fcdr (fdpid
));
177 if (call_process_exited
)
179 emacs_close (XFASTINT (Fcar (fdpid
)));
183 if (EMACS_KILLPG (pid
, SIGINT
) == 0)
185 int count
= SPECPDL_INDEX ();
186 record_unwind_protect (call_process_kill
, fdpid
);
187 message1 ("Waiting for process to die...(type C-g again to kill it instantly)");
190 wait_for_termination (pid
);
192 specpdl_ptr
= specpdl
+ count
; /* Discard the unwind protect. */
193 message1 ("Waiting for process to die...done");
195 synch_process_alive
= 0;
196 emacs_close (XFASTINT (Fcar (fdpid
)));
197 #endif /* not MSDOS */
201 DEFUN ("call-process", Fcall_process
, Scall_process
, 1, MANY
, 0,
202 doc
: /* Call PROGRAM synchronously in separate process.
203 The remaining arguments are optional.
204 The program's input comes from file INFILE (nil means `/dev/null').
205 Insert output in BUFFER before point; t means current buffer;
206 nil for BUFFER means discard it; 0 means discard and don't wait.
207 BUFFER can also have the form (REAL-BUFFER STDERR-FILE); in that case,
208 REAL-BUFFER says what to do with standard output, as above,
209 while STDERR-FILE says what to do with standard error in the child.
210 STDERR-FILE may be nil (discard standard error output),
211 t (mix it with ordinary output), or a file name string.
213 Fourth arg DISPLAY non-nil means redisplay buffer as output is inserted.
214 Remaining arguments are strings passed as command arguments to PROGRAM.
216 If executable PROGRAM can't be found as an executable, `call-process'
217 signals a Lisp error. `call-process' reports errors in execution of
218 the program only through its return and output.
220 If BUFFER is 0, `call-process' returns immediately with value nil.
221 Otherwise it waits for PROGRAM to terminate
222 and returns a numeric exit status or a signal description string.
223 If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.
225 usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS) */)
228 register Lisp_Object
*args
;
230 Lisp_Object infile
, buffer
, current_dir
, path
;
235 #define CALLPROC_BUFFER_SIZE_MIN (16 * 1024)
236 #define CALLPROC_BUFFER_SIZE_MAX (4 * CALLPROC_BUFFER_SIZE_MIN)
237 char buf
[CALLPROC_BUFFER_SIZE_MAX
];
238 int bufsize
= CALLPROC_BUFFER_SIZE_MIN
;
239 int count
= SPECPDL_INDEX ();
241 register const unsigned char **new_argv
;
242 /* File to use for stderr in the child.
243 t means use same as standard output. */
244 Lisp_Object error_file
;
245 #ifdef MSDOS /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
246 char *outf
, *tempfile
;
249 struct coding_system process_coding
; /* coding-system of process output */
250 struct coding_system argument_coding
; /* coding-system of arguments */
251 /* Set to the return value of Ffind_operation_coding_system. */
252 Lisp_Object coding_systems
;
254 /* Qt denotes that Ffind_operation_coding_system is not yet called. */
257 CHECK_STRING (args
[0]);
262 /* Without asynchronous processes we cannot have BUFFER == 0. */
264 && (INTEGERP (CONSP (args
[2]) ? XCAR (args
[2]) : args
[2])))
265 error ("Operating system cannot handle asynchronous subprocesses");
266 #endif /* subprocesses */
268 /* Decide the coding-system for giving arguments. */
270 Lisp_Object val
, *args2
;
273 /* If arguments are supplied, we may have to encode them. */
277 Lisp_Object coding_attrs
;
279 for (i
= 4; i
< nargs
; i
++)
280 CHECK_STRING (args
[i
]);
282 for (i
= 4; i
< nargs
; i
++)
283 if (STRING_MULTIBYTE (args
[i
]))
286 if (!NILP (Vcoding_system_for_write
))
287 val
= Vcoding_system_for_write
;
288 else if (! must_encode
)
292 args2
= (Lisp_Object
*) alloca ((nargs
+ 1) * sizeof *args2
);
293 args2
[0] = Qcall_process
;
294 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
295 coding_systems
= Ffind_operation_coding_system (nargs
+ 1, args2
);
296 if (CONSP (coding_systems
))
297 val
= XCDR (coding_systems
);
298 else if (CONSP (Vdefault_process_coding_system
))
299 val
= XCDR (Vdefault_process_coding_system
);
303 val
= coding_inherit_eol_type (val
, Qnil
);
304 setup_coding_system (Fcheck_coding_system (val
), &argument_coding
);
305 coding_attrs
= CODING_ID_ATTRS (argument_coding
.id
);
306 if (NILP (CODING_ATTR_ASCII_COMPAT (coding_attrs
)))
308 /* We should not use an ASCII incompatible coding system. */
309 val
= raw_text_coding_system (val
);
310 setup_coding_system (val
, &argument_coding
);
315 if (nargs
>= 2 && ! NILP (args
[1]))
317 infile
= Fexpand_file_name (args
[1], current_buffer
->directory
);
318 CHECK_STRING (infile
);
321 infile
= build_string (NULL_DEVICE
);
327 /* If BUFFER is a list, its meaning is
328 (BUFFER-FOR-STDOUT FILE-FOR-STDERR). */
331 if (CONSP (XCDR (buffer
)))
333 Lisp_Object stderr_file
;
334 stderr_file
= XCAR (XCDR (buffer
));
336 if (NILP (stderr_file
) || EQ (Qt
, stderr_file
))
337 error_file
= stderr_file
;
339 error_file
= Fexpand_file_name (stderr_file
, Qnil
);
342 buffer
= XCAR (buffer
);
345 if (!(EQ (buffer
, Qnil
)
347 || INTEGERP (buffer
)))
349 Lisp_Object spec_buffer
;
350 spec_buffer
= buffer
;
351 buffer
= Fget_buffer_create (buffer
);
352 /* Mention the buffer name for a better error message. */
354 CHECK_BUFFER (spec_buffer
);
355 CHECK_BUFFER (buffer
);
361 /* Make sure that the child will be able to chdir to the current
362 buffer's current directory, or its unhandled equivalent. We
363 can't just have the child check for an error when it does the
364 chdir, since it's in a vfork.
366 We have to GCPRO around this because Fexpand_file_name,
367 Funhandled_file_name_directory, and Ffile_accessible_directory_p
368 might call a file name handling function. The argument list is
369 protected by the caller, so all we really have to worry about is
372 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
374 current_dir
= current_buffer
->directory
;
376 GCPRO4 (infile
, buffer
, current_dir
, error_file
);
378 current_dir
= Funhandled_file_name_directory (current_dir
);
379 if (NILP (current_dir
))
380 /* If the file name handler says that current_dir is unreachable, use
381 a sensible default. */
382 current_dir
= build_string ("~/");
383 current_dir
= expand_and_dir_to_file (current_dir
, Qnil
);
384 current_dir
= Ffile_name_as_directory (current_dir
);
386 if (NILP (Ffile_accessible_directory_p (current_dir
)))
387 report_file_error ("Setting current directory",
388 Fcons (current_buffer
->directory
, Qnil
));
390 if (STRING_MULTIBYTE (infile
))
391 infile
= ENCODE_FILE (infile
);
392 if (STRING_MULTIBYTE (current_dir
))
393 current_dir
= ENCODE_FILE (current_dir
);
394 if (STRINGP (error_file
) && STRING_MULTIBYTE (error_file
))
395 error_file
= ENCODE_FILE (error_file
);
399 display_p
= INTERACTIVE
&& nargs
>= 4 && !NILP (args
[3]);
401 filefd
= emacs_open (SDATA (infile
), O_RDONLY
, 0);
404 infile
= DECODE_FILE (infile
);
405 report_file_error ("Opening process input file", Fcons (infile
, Qnil
));
407 /* Search for program; barf if not found. */
409 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
411 GCPRO4 (infile
, buffer
, current_dir
, error_file
);
412 openp (Vexec_path
, args
[0], Vexec_suffixes
, &path
, make_number (X_OK
));
417 emacs_close (filefd
);
418 report_file_error ("Searching for program", Fcons (args
[0], Qnil
));
421 /* If program file name starts with /: for quoting a magic name,
423 if (SBYTES (path
) > 2 && SREF (path
, 0) == '/'
424 && SREF (path
, 1) == ':')
425 path
= Fsubstring (path
, make_number (2), Qnil
);
427 new_argv
= (const unsigned char **)
428 alloca (max (2, nargs
- 2) * sizeof (char *));
432 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
434 GCPRO5 (infile
, buffer
, current_dir
, path
, error_file
);
435 argument_coding
.dst_multibyte
= 0;
436 for (i
= 4; i
< nargs
; i
++)
438 argument_coding
.src_multibyte
= STRING_MULTIBYTE (args
[i
]);
439 if (CODING_REQUIRE_ENCODING (&argument_coding
))
440 /* We must encode this argument. */
441 args
[i
] = encode_coding_string (&argument_coding
, args
[i
], 1);
444 for (i
= 4; i
< nargs
; i
++)
445 new_argv
[i
- 3] = SDATA (args
[i
]);
450 new_argv
[0] = SDATA (path
);
452 #ifdef MSDOS /* MW, July 1993 */
453 if ((outf
= egetenv ("TMPDIR")))
454 strcpy (tempfile
= alloca (strlen (outf
) + 20), outf
);
457 tempfile
= alloca (20);
460 dostounix_filename (tempfile
);
461 if (*tempfile
== '\0' || tempfile
[strlen (tempfile
) - 1] != '/')
462 strcat (tempfile
, "/");
463 strcat (tempfile
, "detmp.XXX");
466 outfilefd
= creat (tempfile
, S_IREAD
| S_IWRITE
);
469 emacs_close (filefd
);
470 report_file_error ("Opening process output file",
471 Fcons (build_string (tempfile
), Qnil
));
477 if (INTEGERP (buffer
))
478 fd
[1] = emacs_open (NULL_DEVICE
, O_WRONLY
, 0), fd
[0] = -1;
485 emacs_close (filefd
);
486 report_file_error ("Creating process pipe", Qnil
);
492 /* child_setup must clobber environ in systems with true vfork.
493 Protect it from permanent change. */
494 register char **save_environ
= environ
;
495 register int fd1
= fd
[1];
498 #if 0 /* Some systems don't have sigblock. */
499 mask
= sigblock (sigmask (SIGCHLD
));
502 /* Record that we're about to create a synchronous process. */
503 synch_process_alive
= 1;
505 /* These vars record information from process termination.
506 Clear them now before process can possibly terminate,
507 to avoid timing error if process terminates soon. */
508 synch_process_death
= 0;
509 synch_process_retcode
= 0;
510 synch_process_termsig
= 0;
512 if (NILP (error_file
))
513 fd_error
= emacs_open (NULL_DEVICE
, O_WRONLY
, 0);
514 else if (STRINGP (error_file
))
517 fd_error
= emacs_open (SDATA (error_file
),
518 O_WRONLY
| O_TRUNC
| O_CREAT
| O_TEXT
,
520 #else /* not DOS_NT */
521 fd_error
= creat (SDATA (error_file
), 0666);
522 #endif /* not DOS_NT */
527 emacs_close (filefd
);
535 if (NILP (error_file
))
536 error_file
= build_string (NULL_DEVICE
);
537 else if (STRINGP (error_file
))
538 error_file
= DECODE_FILE (error_file
);
539 report_file_error ("Cannot redirect stderr", Fcons (error_file
, Qnil
));
542 #ifdef MSDOS /* MW, July 1993 */
543 /* Note that on MSDOS `child_setup' actually returns the child process
544 exit status, not its PID, so we assign it to `synch_process_retcode'
546 pid
= child_setup (filefd
, outfilefd
, fd_error
, (char **) new_argv
,
549 /* Record that the synchronous process exited and note its
550 termination status. */
551 synch_process_alive
= 0;
552 synch_process_retcode
= pid
;
553 if (synch_process_retcode
< 0) /* means it couldn't be exec'ed */
555 synchronize_system_messages_locale ();
556 synch_process_death
= strerror (errno
);
559 emacs_close (outfilefd
);
560 if (fd_error
!= outfilefd
)
561 emacs_close (fd_error
);
562 fd1
= -1; /* No harm in closing that one! */
563 /* Since CRLF is converted to LF within `decode_coding', we can
564 always open a file with binary mode. */
565 fd
[0] = emacs_open (tempfile
, O_RDONLY
| O_BINARY
, 0);
569 emacs_close (filefd
);
570 report_file_error ("Cannot re-open temporary file", Qnil
);
572 #else /* not MSDOS */
574 pid
= child_setup (filefd
, fd1
, fd_error
, (char **) new_argv
,
576 #else /* not WINDOWSNT */
588 #if defined (USG) && !defined (BSD_PGRPS)
593 child_setup (filefd
, fd1
, fd_error
, (char **) new_argv
,
598 #endif /* not WINDOWSNT */
600 /* The MSDOS case did this already. */
602 emacs_close (fd_error
);
603 #endif /* not MSDOS */
605 environ
= save_environ
;
607 /* Close most of our fd's, but not fd[0]
608 since we will use that to read input from. */
609 emacs_close (filefd
);
610 if (fd1
>= 0 && fd1
!= fd_error
)
618 report_file_error ("Doing vfork", Qnil
);
621 if (INTEGERP (buffer
))
626 /* If Emacs has been built with asynchronous subprocess support,
627 we don't need to do this, I think because it will then have
628 the facilities for handling SIGCHLD. */
629 wait_without_blocking ();
630 #endif /* subprocesses */
634 /* Enable sending signal if user quits below. */
635 call_process_exited
= 0;
638 /* MSDOS needs different cleanup information. */
639 record_unwind_protect (call_process_cleanup
,
640 Fcons (Fcurrent_buffer (),
641 Fcons (make_number (fd
[0]),
642 build_string (tempfile
))));
644 record_unwind_protect (call_process_cleanup
,
645 Fcons (Fcurrent_buffer (),
646 Fcons (make_number (fd
[0]), make_number (pid
))));
647 #endif /* not MSDOS */
650 if (BUFFERP (buffer
))
651 Fset_buffer (buffer
);
655 /* If BUFFER is nil, we must read process output once and then
656 discard it, so setup coding system but with nil. */
657 setup_coding_system (Qnil
, &process_coding
);
661 Lisp_Object val
, *args2
;
664 if (!NILP (Vcoding_system_for_read
))
665 val
= Vcoding_system_for_read
;
668 if (EQ (coding_systems
, Qt
))
672 args2
= (Lisp_Object
*) alloca ((nargs
+ 1) * sizeof *args2
);
673 args2
[0] = Qcall_process
;
674 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
676 = Ffind_operation_coding_system (nargs
+ 1, args2
);
678 if (CONSP (coding_systems
))
679 val
= XCAR (coding_systems
);
680 else if (CONSP (Vdefault_process_coding_system
))
681 val
= XCAR (Vdefault_process_coding_system
);
685 Fcheck_coding_system (val
);
686 /* In unibyte mode, character code conversion should not take
687 place but EOL conversion should. So, setup raw-text or one
688 of the subsidiary according to the information just setup. */
689 if (NILP (current_buffer
->enable_multibyte_characters
)
691 val
= raw_text_coding_system (val
);
692 setup_coding_system (val
, &process_coding
);
703 int display_on_the_fly
= display_p
;
704 struct coding_system saved_coding
;
706 saved_coding
= process_coding
;
709 /* Repeatedly read until we've filled as much as possible
710 of the buffer size we have. But don't read
711 less than 1024--save that for the next bufferful. */
713 while (nread
< bufsize
- 1024)
715 int this_read
= emacs_read (fd
[0], buf
+ nread
,
723 process_coding
.mode
|= CODING_MODE_LAST_BLOCK
;
728 total_read
+= this_read
;
730 if (display_on_the_fly
)
734 /* Now NREAD is the total amount of data in the buffer. */
739 if (NILP (current_buffer
->enable_multibyte_characters
)
740 && ! CODING_MAY_REQUIRE_DECODING (&process_coding
))
741 insert_1_both (buf
, nread
, nread
, 0, 1, 0);
743 { /* We have to decode the input. */
745 int count1
= SPECPDL_INDEX ();
747 XSETBUFFER (curbuf
, current_buffer
);
748 /* We cannot allow after-change-functions be run
749 during decoding, because that might modify the
750 buffer, while we rely on process_coding.produced to
751 faithfully reflect inserted text until we
752 TEMP_SET_PT_BOTH below. */
753 specbind (Qinhibit_modification_hooks
, Qt
);
754 decode_coding_c_string (&process_coding
, buf
, nread
,
756 unbind_to (count1
, Qnil
);
757 if (display_on_the_fly
758 && CODING_REQUIRE_DETECTION (&saved_coding
)
759 && ! CODING_REQUIRE_DETECTION (&process_coding
))
761 /* We have detected some coding system. But,
762 there's a possibility that the detection was
763 done by insufficient data. So, we give up
764 displaying on the fly. */
765 if (process_coding
.produced
> 0)
766 del_range_2 (process_coding
.dst_pos
,
767 process_coding
.dst_pos_byte
,
768 process_coding
.dst_pos
769 + process_coding
.produced_char
,
770 process_coding
.dst_pos_byte
771 + process_coding
.produced
, 0);
772 display_on_the_fly
= 0;
773 process_coding
= saved_coding
;
775 /* This is to make the above condition always
776 fails in the future. */
777 saved_coding
.common_flags
778 &= ~CODING_REQUIRE_DETECTION_MASK
;
782 TEMP_SET_PT_BOTH (PT
+ process_coding
.produced_char
,
783 PT_BYTE
+ process_coding
.produced
);
784 carryover
= process_coding
.carryover_bytes
;
786 /* As CARRYOVER should not be that large, we had
787 better avoid overhead of bcopy. */
788 BCOPY_SHORT (process_coding
.carryover
, buf
,
789 process_coding
.carryover_bytes
);
793 if (process_coding
.mode
& CODING_MODE_LAST_BLOCK
)
796 /* Make the buffer bigger as we continue to read more data,
797 but not past CALLPROC_BUFFER_SIZE_MAX. */
798 if (bufsize
< CALLPROC_BUFFER_SIZE_MAX
&& total_read
> 32 * bufsize
)
799 if ((bufsize
*= 2) > CALLPROC_BUFFER_SIZE_MAX
)
800 bufsize
= CALLPROC_BUFFER_SIZE_MAX
;
805 prepare_menu_bars ();
807 redisplay_preserve_echo_area (1);
808 /* This variable might have been set to 0 for code
809 detection. In that case, we set it back to 1 because
810 we should have already detected a coding system. */
811 display_on_the_fly
= 1;
818 Vlast_coding_system_used
= CODING_ID_NAME (process_coding
.id
);
819 /* If the caller required, let the buffer inherit the
820 coding-system used to decode the process output. */
821 if (inherit_process_coding_system
)
822 call1 (intern ("after-insert-file-set-buffer-file-coding-system"),
823 make_number (total_read
));
826 /* Wait for it to terminate, unless it already has. */
827 wait_for_termination (pid
);
831 /* Don't kill any children that the subprocess may have left behind
833 call_process_exited
= 1;
835 unbind_to (count
, Qnil
);
837 if (synch_process_termsig
)
841 synchronize_system_messages_locale ();
842 signame
= strsignal (synch_process_termsig
);
847 synch_process_death
= signame
;
850 if (synch_process_death
)
851 return code_convert_string_norecord (build_string (synch_process_death
),
852 Vlocale_coding_system
, 0);
853 return make_number (synch_process_retcode
);
857 delete_temp_file (name
)
860 /* Suppress jka-compr handling, etc. */
861 int count
= SPECPDL_INDEX ();
862 specbind (intern ("file-name-handler-alist"), Qnil
);
863 internal_delete_file (name
);
864 unbind_to (count
, Qnil
);
868 DEFUN ("call-process-region", Fcall_process_region
, Scall_process_region
,
870 doc
: /* Send text from START to END to a synchronous process running PROGRAM.
871 The remaining arguments are optional.
872 Delete the text if fourth arg DELETE is non-nil.
874 Insert output in BUFFER before point; t means current buffer;
875 nil for BUFFER means discard it; 0 means discard and don't wait.
876 BUFFER can also have the form (REAL-BUFFER STDERR-FILE); in that case,
877 REAL-BUFFER says what to do with standard output, as above,
878 while STDERR-FILE says what to do with standard error in the child.
879 STDERR-FILE may be nil (discard standard error output),
880 t (mix it with ordinary output), or a file name string.
882 Sixth arg DISPLAY non-nil means redisplay buffer as output is inserted.
883 Remaining args are passed to PROGRAM at startup as command args.
885 If BUFFER is 0, `call-process-region' returns immediately with value nil.
886 Otherwise it waits for PROGRAM to terminate
887 and returns a numeric exit status or a signal description string.
888 If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.
890 usage: (call-process-region START END PROGRAM &optional DELETE BUFFER DISPLAY &rest ARGS) */)
893 register Lisp_Object
*args
;
896 Lisp_Object filename_string
;
897 register Lisp_Object start
, end
;
898 int count
= SPECPDL_INDEX ();
899 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
900 Lisp_Object coding_systems
;
901 Lisp_Object val
, *args2
;
904 Lisp_Object tmpdir
, pattern
;
906 if (STRINGP (Vtemporary_file_directory
))
907 tmpdir
= Vtemporary_file_directory
;
911 if (getenv ("TMPDIR"))
912 tmpdir
= build_string (getenv ("TMPDIR"));
914 tmpdir
= build_string ("/tmp/");
917 if ((outf
= egetenv ("TMPDIR"))
918 || (outf
= egetenv ("TMP"))
919 || (outf
= egetenv ("TEMP")))
920 tmpdir
= build_string (outf
);
922 tmpdir
= Ffile_name_as_directory (build_string ("c:/temp"));
926 pattern
= Fexpand_file_name (Vtemp_file_name_pattern
, tmpdir
);
927 tempfile
= (char *) alloca (SBYTES (pattern
) + 1);
928 bcopy (SDATA (pattern
), tempfile
, SBYTES (pattern
) + 1);
936 fd
= mkstemp (tempfile
);
939 report_file_error ("Failed to open temporary file",
940 Fcons (Vtemp_file_name_pattern
, Qnil
));
948 filename_string
= build_string (tempfile
);
949 GCPRO1 (filename_string
);
952 /* Decide coding-system of the contents of the temporary file. */
953 if (!NILP (Vcoding_system_for_write
))
954 val
= Vcoding_system_for_write
;
955 else if (NILP (current_buffer
->enable_multibyte_characters
))
959 args2
= (Lisp_Object
*) alloca ((nargs
+ 1) * sizeof *args2
);
960 args2
[0] = Qcall_process_region
;
961 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
962 coding_systems
= Ffind_operation_coding_system (nargs
+ 1, args2
);
963 if (CONSP (coding_systems
))
964 val
= XCDR (coding_systems
);
965 else if (CONSP (Vdefault_process_coding_system
))
966 val
= XCDR (Vdefault_process_coding_system
);
972 int count1
= SPECPDL_INDEX ();
974 specbind (intern ("coding-system-for-write"), val
);
975 /* POSIX lets mk[s]temp use "."; don't invoke jka-compr if we
976 happen to get a ".Z" suffix. */
977 specbind (intern ("file-name-handler-alist"), Qnil
);
978 Fwrite_region (start
, end
, filename_string
, Qnil
, Qlambda
, Qnil
, Qnil
);
980 unbind_to (count1
, Qnil
);
983 /* Note that Fcall_process takes care of binding
984 coding-system-for-read. */
986 record_unwind_protect (delete_temp_file
, filename_string
);
988 if (nargs
> 3 && !NILP (args
[3]))
989 Fdelete_region (start
, end
);
1001 args
[1] = filename_string
;
1003 RETURN_UNGCPRO (unbind_to (count
, Fcall_process (nargs
, args
)));
1006 static int relocate_fd ();
1009 add_env (char **env
, char **new_env
, char *string
)
1016 /* See if this string duplicates any string already in the env.
1017 If so, don't put it in.
1018 When an env var has multiple definitions,
1019 we keep the definition that comes first in process-environment. */
1020 for (ep
= env
; ok
&& ep
!= new_env
; ep
++)
1022 char *p
= *ep
, *q
= string
;
1028 /* The string is a lone variable name; keep it for now, we
1029 will remove it later. It is a placeholder for a
1030 variable that is not to be included in the environment. */
1038 *new_env
++ = string
;
1042 /* This is the last thing run in a newly forked inferior
1043 either synchronous or asynchronous.
1044 Copy descriptors IN, OUT and ERR as descriptors 0, 1 and 2.
1045 Initialize inferior's priority, pgrp, connected dir and environment.
1046 then exec another program based on new_argv.
1048 This function may change environ for the superior process.
1049 Therefore, the superior process must save and restore the value
1050 of environ around the vfork and the call to this function.
1052 SET_PGRP is nonzero if we should put the subprocess into a separate
1055 CURRENT_DIR is an elisp string giving the path of the current
1056 directory the subprocess should have. Since we can't really signal
1057 a decent error from within the child, this should be verified as an
1058 executable directory by the parent. */
1061 child_setup (in
, out
, err
, new_argv
, set_pgrp
, current_dir
)
1063 register char **new_argv
;
1065 Lisp_Object current_dir
;
1072 #endif /* WINDOWSNT */
1074 int pid
= getpid ();
1076 #ifdef SET_EMACS_PRIORITY
1078 extern EMACS_INT emacs_priority
;
1080 if (emacs_priority
< 0)
1081 nice (- emacs_priority
);
1086 /* Close Emacs's descriptors that this process should not have. */
1087 close_process_descs ();
1089 /* DOS_NT isn't in a vfork, so if we are in the middle of load-file,
1090 we will lose if we call close_load_descs here. */
1092 close_load_descs ();
1095 /* Note that use of alloca is always safe here. It's obvious for systems
1096 that do not have true vfork or that have true (stack) alloca.
1097 If using vfork and C_ALLOCA (when Emacs used to include
1098 src/alloca.c) it is safe because that changes the superior's
1099 static variables as if the superior had done alloca and will be
1100 cleaned up in the usual way. */
1102 register char *temp
;
1105 i
= SBYTES (current_dir
);
1107 /* MSDOS must have all environment variables malloc'ed, because
1108 low-level libc functions that launch subsidiary processes rely
1110 pwd_var
= (char *) xmalloc (i
+ 6);
1112 pwd_var
= (char *) alloca (i
+ 6);
1115 bcopy ("PWD=", pwd_var
, 4);
1116 bcopy (SDATA (current_dir
), temp
, i
);
1117 if (!IS_DIRECTORY_SEP (temp
[i
- 1])) temp
[i
++] = DIRECTORY_SEP
;
1121 /* We can't signal an Elisp error here; we're in a vfork. Since
1122 the callers check the current directory before forking, this
1123 should only return an error if the directory's permissions
1124 are changed between the check and this chdir, but we should
1126 if (chdir (temp
) < 0)
1129 /* Get past the drive letter, so that d:/ is left alone. */
1130 if (i
> 2 && IS_DEVICE_SEP (temp
[1]) && IS_DIRECTORY_SEP (temp
[2]))
1137 /* Strip trailing slashes for PWD, but leave "/" and "//" alone. */
1138 while (i
> 2 && IS_DIRECTORY_SEP (temp
[i
- 1]))
1142 /* Set `env' to a vector of the strings in the environment. */
1144 register Lisp_Object tem
;
1145 register char **new_env
;
1147 register int new_length
;
1148 Lisp_Object display
= Qnil
;
1152 for (tem
= Vprocess_environment
;
1153 CONSP (tem
) && STRINGP (XCAR (tem
));
1156 if (strncmp (SDATA (XCAR (tem
)), "DISPLAY", 7) == 0
1157 && (SDATA (XCAR (tem
)) [7] == '\0'
1158 || SDATA (XCAR (tem
)) [7] == '='))
1159 /* DISPLAY is specified in process-environment. */
1164 /* If not provided yet, use the frame's DISPLAY. */
1167 Lisp_Object tmp
= Fframe_parameter (selected_frame
, Qdisplay
);
1168 if (!STRINGP (tmp
) && CONSP (Vinitial_environment
))
1169 /* If still not found, Look for DISPLAY in Vinitial_environment. */
1170 tmp
= Fgetenv_internal (build_string ("DISPLAY"),
1171 Vinitial_environment
);
1179 /* new_length + 2 to include PWD and terminating 0. */
1180 env
= new_env
= (char **) alloca ((new_length
+ 2) * sizeof (char *));
1181 /* If we have a PWD envvar, pass one down,
1182 but with corrected value. */
1183 if (egetenv ("PWD"))
1184 *new_env
++ = pwd_var
;
1186 if (STRINGP (display
))
1188 int vlen
= strlen ("DISPLAY=") + strlen (SDATA (display
)) + 1;
1189 char *vdata
= (char *) alloca (vlen
);
1190 strcpy (vdata
, "DISPLAY=");
1191 strcat (vdata
, SDATA (display
));
1192 new_env
= add_env (env
, new_env
, vdata
);
1196 for (tem
= Vprocess_environment
;
1197 CONSP (tem
) && STRINGP (XCAR (tem
));
1199 new_env
= add_env (env
, new_env
, SDATA (XCAR (tem
)));
1203 /* Remove variable names without values. */
1207 while (*q
!= 0 && strchr (*q
, '=') == NULL
)
1217 prepare_standard_handles (in
, out
, err
, handles
);
1218 set_process_dir (SDATA (current_dir
));
1219 #else /* not WINDOWSNT */
1220 /* Make sure that in, out, and err are not actually already in
1221 descriptors zero, one, or two; this could happen if Emacs is
1222 started with its standard in, out, or error closed, as might
1225 int oin
= in
, oout
= out
;
1227 /* We have to avoid relocating the same descriptor twice! */
1229 in
= relocate_fd (in
, 3);
1234 out
= relocate_fd (out
, 3);
1238 else if (err
== oout
)
1241 err
= relocate_fd (err
, 3);
1255 #endif /* not MSDOS */
1256 #endif /* not WINDOWSNT */
1258 #if defined(USG) && !defined(BSD_PGRPS)
1259 #ifndef SETPGRP_RELEASES_CTTY
1260 setpgrp (); /* No arguments but equivalent in this case */
1265 /* setpgrp_of_tty is incorrect here; it uses input_fd. */
1266 EMACS_SET_TTY_PGRP (0, &pid
);
1269 pid
= run_msdos_command (new_argv
, pwd_var
+ 4, in
, out
, err
, env
);
1272 /* An error occurred while trying to run the subprocess. */
1273 report_file_error ("Spawning child process", Qnil
);
1275 #else /* not MSDOS */
1277 /* Spawn the child. (See ntproc.c:Spawnve). */
1278 cpid
= spawnve (_P_NOWAIT
, new_argv
[0], new_argv
, env
);
1279 reset_standard_handles (in
, out
, err
, handles
);
1281 /* An error occurred while trying to spawn the process. */
1282 report_file_error ("Spawning child process", Qnil
);
1284 #else /* not WINDOWSNT */
1285 /* execvp does not accept an environment arg so the only way
1286 to pass this environment is to set environ. Our caller
1287 is responsible for restoring the ambient value of environ. */
1289 execvp (new_argv
[0], new_argv
);
1291 emacs_write (1, "Can't exec program: ", 20);
1292 emacs_write (1, new_argv
[0], strlen (new_argv
[0]));
1293 emacs_write (1, "\n", 1);
1295 #endif /* not WINDOWSNT */
1296 #endif /* not MSDOS */
1299 /* Move the file descriptor FD so that its number is not less than MINFD.
1300 If the file descriptor is moved at all, the original is freed. */
1302 relocate_fd (fd
, minfd
)
1312 char *message1
= "Error while setting up child: ";
1313 char *errmessage
= strerror (errno
);
1314 char *message2
= "\n";
1315 emacs_write (2, message1
, strlen (message1
));
1316 emacs_write (2, errmessage
, strlen (errmessage
));
1317 emacs_write (2, message2
, strlen (message2
));
1320 /* Note that we hold the original FD open while we recurse,
1321 to guarantee we'll get a new FD if we need it. */
1322 new = relocate_fd (new, minfd
);
1329 getenv_internal_1 (var
, varlen
, value
, valuelen
, env
)
1336 for (; CONSP (env
); env
= XCDR (env
))
1338 Lisp_Object entry
= XCAR (env
);
1340 && SBYTES (entry
) >= varlen
1342 /* NT environment variables are case insensitive. */
1343 && ! strnicmp (SDATA (entry
), var
, varlen
)
1344 #else /* not WINDOWSNT */
1345 && ! bcmp (SDATA (entry
), var
, varlen
)
1346 #endif /* not WINDOWSNT */
1349 if (SBYTES (entry
) > varlen
&& SREF (entry
, varlen
) == '=')
1351 *value
= (char *) SDATA (entry
) + (varlen
+ 1);
1352 *valuelen
= SBYTES (entry
) - (varlen
+ 1);
1355 else if (SBYTES (entry
) == varlen
)
1357 /* Lone variable names in Vprocess_environment mean that
1358 variable should be removed from the environment. */
1368 getenv_internal (var
, varlen
, value
, valuelen
, frame
)
1375 /* Try to find VAR in Vprocess_environment first. */
1376 if (getenv_internal_1 (var
, varlen
, value
, valuelen
,
1377 Vprocess_environment
))
1378 return *value
? 1 : 0;
1380 /* For DISPLAY try to get the values from the frame or the initial env. */
1381 if (strcmp (var
, "DISPLAY") == 0)
1384 = Fframe_parameter (NILP (frame
) ? selected_frame
: frame
, Qdisplay
);
1385 if (STRINGP (display
))
1387 *value
= (char *) SDATA (display
);
1388 *valuelen
= SBYTES (display
);
1391 /* If still not found, Look for DISPLAY in Vinitial_environment. */
1392 if (getenv_internal_1 (var
, varlen
, value
, valuelen
,
1393 Vinitial_environment
))
1394 return *value
? 1 : 0;
1400 DEFUN ("getenv-internal", Fgetenv_internal
, Sgetenv_internal
, 1, 2, 0,
1401 doc
: /* Get the value of environment variable VARIABLE.
1402 VARIABLE should be a string. Value is nil if VARIABLE is undefined in
1403 the environment. Otherwise, value is a string.
1405 This function searches `process-environment' for VARIABLE.
1407 If optional parameter ENV is a list, then search this list instead of
1408 `process-environment', and return t when encountering a negative entry
1409 \(an entry for a variable with no value). */)
1411 Lisp_Object variable
, env
;
1416 CHECK_STRING (variable
);
1419 if (getenv_internal_1 (SDATA (variable
), SBYTES (variable
),
1420 &value
, &valuelen
, env
))
1421 return value
? make_string (value
, valuelen
) : Qt
;
1425 else if (getenv_internal (SDATA (variable
), SBYTES (variable
),
1426 &value
, &valuelen
, env
))
1427 return make_string (value
, valuelen
);
1432 /* A version of getenv that consults the Lisp environment lists,
1433 easily callable from C. */
1441 if (getenv_internal (var
, strlen (var
), &value
, &valuelen
, Qnil
))
1448 /* This is run before init_cmdargs. */
1453 char *data_dir
= egetenv ("EMACSDATA");
1454 char *doc_dir
= egetenv ("EMACSDOC");
1457 = Ffile_name_as_directory (build_string (data_dir
? data_dir
1460 = Ffile_name_as_directory (build_string (doc_dir
? doc_dir
1463 /* Check the EMACSPATH environment variable, defaulting to the
1464 PATH_EXEC path from epaths.h. */
1465 Vexec_path
= decode_env_path ("EMACSPATH", PATH_EXEC
);
1466 Vexec_directory
= Ffile_name_as_directory (Fcar (Vexec_path
));
1467 Vexec_path
= nconc2 (decode_env_path ("PATH", ""), Vexec_path
);
1470 /* This is run after init_cmdargs, when Vinstallation_directory is valid. */
1475 char *data_dir
= egetenv ("EMACSDATA");
1478 Lisp_Object tempdir
;
1480 if (!NILP (Vinstallation_directory
))
1482 /* Add to the path the lib-src subdir of the installation dir. */
1484 tem
= Fexpand_file_name (build_string ("lib-src"),
1485 Vinstallation_directory
);
1487 /* MSDOS uses wrapped binaries, so don't do this. */
1488 if (NILP (Fmember (tem
, Vexec_path
)))
1490 Vexec_path
= decode_env_path ("EMACSPATH", PATH_EXEC
);
1491 Vexec_path
= Fcons (tem
, Vexec_path
);
1492 Vexec_path
= nconc2 (decode_env_path ("PATH", ""), Vexec_path
);
1495 Vexec_directory
= Ffile_name_as_directory (tem
);
1496 #endif /* not DOS_NT */
1498 /* Maybe use ../etc as well as ../lib-src. */
1501 tem
= Fexpand_file_name (build_string ("etc"),
1502 Vinstallation_directory
);
1503 Vdoc_directory
= Ffile_name_as_directory (tem
);
1507 /* Look for the files that should be in etc. We don't use
1508 Vinstallation_directory, because these files are never installed
1509 near the executable, and they are never in the build
1510 directory when that's different from the source directory.
1512 Instead, if these files are not in the nominal place, we try the
1513 source directory. */
1516 Lisp_Object tem
, tem1
, srcdir
;
1518 srcdir
= Fexpand_file_name (build_string ("../src/"),
1519 build_string (PATH_DUMPLOADSEARCH
));
1520 tem
= Fexpand_file_name (build_string ("GNU"), Vdata_directory
);
1521 tem1
= Ffile_exists_p (tem
);
1522 if (!NILP (Fequal (srcdir
, Vinvocation_directory
)) || NILP (tem1
))
1525 newdir
= Fexpand_file_name (build_string ("../etc/"),
1526 build_string (PATH_DUMPLOADSEARCH
));
1527 tem
= Fexpand_file_name (build_string ("GNU"), newdir
);
1528 tem1
= Ffile_exists_p (tem
);
1530 Vdata_directory
= newdir
;
1538 tempdir
= Fdirectory_file_name (Vexec_directory
);
1539 if (access (SDATA (tempdir
), 0) < 0)
1540 dir_warning ("Warning: arch-dependent data dir (%s) does not exist.\n",
1544 tempdir
= Fdirectory_file_name (Vdata_directory
);
1545 if (access (SDATA (tempdir
), 0) < 0)
1546 dir_warning ("Warning: arch-independent data dir (%s) does not exist.\n",
1549 sh
= (char *) getenv ("SHELL");
1550 Vshell_file_name
= build_string (sh
? sh
: "/bin/sh");
1553 Vshared_game_score_directory
= Qnil
;
1555 Vshared_game_score_directory
= build_string (PATH_GAME
);
1556 if (NILP (Ffile_directory_p (Vshared_game_score_directory
)))
1557 Vshared_game_score_directory
= Qnil
;
1562 set_initial_environment ()
1564 register char **envp
;
1570 Vprocess_environment
= Qnil
;
1572 for (envp
= environ
; *envp
; envp
++)
1573 Vprocess_environment
= Fcons (build_string (*envp
),
1574 Vprocess_environment
);
1575 /* Ideally, the `copy' shouldn't be necessary, but it seems it's frequent
1576 to use `delete' and friends on process-environment. */
1577 Vinitial_environment
= Fcopy_sequence (Vprocess_environment
);
1585 Qbuffer_file_type
= intern ("buffer-file-type");
1586 staticpro (&Qbuffer_file_type
);
1590 Vtemp_file_name_pattern
= build_string ("emacsXXXXXX");
1591 #elif defined (WINDOWSNT)
1592 Vtemp_file_name_pattern
= build_string ("emXXXXXX");
1594 Vtemp_file_name_pattern
= build_string ("detmp.XXX");
1596 staticpro (&Vtemp_file_name_pattern
);
1598 DEFVAR_LISP ("shell-file-name", &Vshell_file_name
,
1599 doc
: /* *File name to load inferior shells from.
1600 Initialized from the SHELL environment variable, or to a system-dependent
1601 default if SHELL is not set. */);
1603 DEFVAR_LISP ("exec-path", &Vexec_path
,
1604 doc
: /* *List of directories to search programs to run in subprocesses.
1605 Each element is a string (directory name) or nil (try default directory). */);
1607 DEFVAR_LISP ("exec-suffixes", &Vexec_suffixes
,
1608 doc
: /* *List of suffixes to try to find executable file names.
1609 Each element is a string. */);
1610 Vexec_suffixes
= Qnil
;
1612 DEFVAR_LISP ("exec-directory", &Vexec_directory
,
1613 doc
: /* Directory for executables for Emacs to invoke.
1614 More generally, this includes any architecture-dependent files
1615 that are built and installed from the Emacs distribution. */);
1617 DEFVAR_LISP ("data-directory", &Vdata_directory
,
1618 doc
: /* Directory of machine-independent files that come with GNU Emacs.
1619 These are files intended for Emacs to use while it runs. */);
1621 DEFVAR_LISP ("doc-directory", &Vdoc_directory
,
1622 doc
: /* Directory containing the DOC file that comes with GNU Emacs.
1623 This is usually the same as `data-directory'. */);
1625 DEFVAR_LISP ("configure-info-directory", &Vconfigure_info_directory
,
1626 doc
: /* For internal use by the build procedure only.
1627 This is the name of the directory in which the build procedure installed
1628 Emacs's info files; the default value for `Info-default-directory-list'
1630 Vconfigure_info_directory
= build_string (PATH_INFO
);
1632 DEFVAR_LISP ("shared-game-score-directory", &Vshared_game_score_directory
,
1633 doc
: /* Directory of score files for games which come with GNU Emacs.
1634 If this variable is nil, then Emacs is unable to use a shared directory. */);
1636 Vshared_game_score_directory
= Qnil
;
1638 Vshared_game_score_directory
= build_string (PATH_GAME
);
1641 DEFVAR_LISP ("initial-environment", &Vinitial_environment
,
1642 doc
: /* List of environment variables inherited from the parent process.
1643 Each element should be a string of the form ENVVARNAME=VALUE.
1644 The elements must normally be decoded (using `locale-coding-system') for use. */);
1645 Vinitial_environment
= Qnil
;
1647 DEFVAR_LISP ("process-environment", &Vprocess_environment
,
1648 doc
: /* List of overridden environment variables for subprocesses to inherit.
1649 Each element should be a string of the form ENVVARNAME=VALUE.
1651 Entries in this list take precedence to those in the frame-local
1652 environments. Therefore, let-binding `process-environment' is an easy
1653 way to temporarily change the value of an environment variable,
1654 irrespective of where it comes from. To use `process-environment' to
1655 remove an environment variable, include only its name in the list,
1658 This variable is set to nil when Emacs starts.
1660 If multiple entries define the same variable, the first one always
1663 Non-ASCII characters are encoded according to the initial value of
1664 `locale-coding-system', i.e. the elements must normally be decoded for
1667 See `setenv' and `getenv'. */);
1668 Vprocess_environment
= Qnil
;
1670 defsubr (&Scall_process
);
1671 defsubr (&Sgetenv_internal
);
1672 defsubr (&Scall_process_region
);
1675 /* arch-tag: 769b8045-1df7-4d2b-8968-e3fb49017f95
1676 (do not change this comment) */