1 /* Synchronous subprocess invocation for GNU Emacs.
2 Copyright (C) 1985-1988, 1993-1995, 1999-2011
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
26 #include <sys/types.h>
36 #define _P_NOWAIT 1 /* from process.h */
39 #ifdef MSDOS /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
41 #include <sys/param.h>
47 #include "character.h"
50 #include "composite.h"
53 #include "syssignal.h"
55 #include "blockinput.h"
57 #include "termhooks.h"
64 extern char **environ
;
70 #define setpgrp setpgid
74 /* Pattern used by call-process-region to make temp files. */
75 static Lisp_Object Vtemp_file_name_pattern
;
77 /* True if we are about to fork off a synchronous process or if we
78 are waiting for it. */
79 int synch_process_alive
;
81 /* Nonzero => this is a string explaining death of synchronous subprocess. */
82 const char *synch_process_death
;
84 /* Nonzero => this is the signal number that terminated the subprocess. */
85 int synch_process_termsig
;
87 /* If synch_process_death is zero,
88 this is exit code of synchronous subprocess. */
89 int synch_process_retcode
;
92 /* Clean up when exiting Fcall_process.
93 On MSDOS, delete the temporary file on any kind of termination.
94 On Unix, kill the process and any children on termination by signal. */
96 /* Nonzero if this is termination due to exit. */
97 static int call_process_exited
;
99 static Lisp_Object
Fgetenv_internal (Lisp_Object
, Lisp_Object
);
102 call_process_kill (Lisp_Object fdpid
)
104 emacs_close (XFASTINT (Fcar (fdpid
)));
105 EMACS_KILLPG (XFASTINT (Fcdr (fdpid
)), SIGKILL
);
106 synch_process_alive
= 0;
111 call_process_cleanup (Lisp_Object arg
)
113 Lisp_Object fdpid
= Fcdr (arg
);
120 Fset_buffer (Fcar (arg
));
123 /* for MSDOS fdpid is really (fd . tempfile) */
125 emacs_close (XFASTINT (Fcar (fdpid
)));
126 if (strcmp (SDATA (file
), NULL_DEVICE
) != 0)
127 unlink (SDATA (file
));
128 #else /* not MSDOS */
129 pid
= XFASTINT (Fcdr (fdpid
));
131 if (call_process_exited
)
133 emacs_close (XFASTINT (Fcar (fdpid
)));
137 if (EMACS_KILLPG (pid
, SIGINT
) == 0)
139 int count
= SPECPDL_INDEX ();
140 record_unwind_protect (call_process_kill
, fdpid
);
141 message1 ("Waiting for process to die...(type C-g again to kill it instantly)");
144 wait_for_termination (pid
);
146 specpdl_ptr
= specpdl
+ count
; /* Discard the unwind protect. */
147 message1 ("Waiting for process to die...done");
149 synch_process_alive
= 0;
150 emacs_close (XFASTINT (Fcar (fdpid
)));
151 #endif /* not MSDOS */
155 DEFUN ("call-process", Fcall_process
, Scall_process
, 1, MANY
, 0,
156 doc
: /* Call PROGRAM synchronously in separate process.
157 The remaining arguments are optional.
158 The program's input comes from file INFILE (nil means `/dev/null').
159 Insert output in BUFFER before point; t means current buffer; nil for BUFFER
160 means discard it; 0 means discard and don't wait; and `(:file FILE)', where
161 FILE is a file name string, means that it should be written to that file.
162 BUFFER can also have the form (REAL-BUFFER STDERR-FILE); in that case,
163 REAL-BUFFER says what to do with standard output, as above,
164 while STDERR-FILE says what to do with standard error in the child.
165 STDERR-FILE may be nil (discard standard error output),
166 t (mix it with ordinary output), or a file name string.
168 Fourth arg DISPLAY non-nil means redisplay buffer as output is inserted.
169 Remaining arguments are strings passed as command arguments to PROGRAM.
171 If executable PROGRAM can't be found as an executable, `call-process'
172 signals a Lisp error. `call-process' reports errors in execution of
173 the program only through its return and output.
175 If BUFFER is 0, `call-process' returns immediately with value nil.
176 Otherwise it waits for PROGRAM to terminate
177 and returns a numeric exit status or a signal description string.
178 If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.
180 usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS) */)
181 (size_t nargs
, register Lisp_Object
*args
)
183 Lisp_Object infile
, buffer
, current_dir
, path
;
184 volatile int display_p_volatile
;
188 #define CALLPROC_BUFFER_SIZE_MIN (16 * 1024)
189 #define CALLPROC_BUFFER_SIZE_MAX (4 * CALLPROC_BUFFER_SIZE_MIN)
190 char buf
[CALLPROC_BUFFER_SIZE_MAX
];
191 int bufsize
= CALLPROC_BUFFER_SIZE_MIN
;
192 int count
= SPECPDL_INDEX ();
193 volatile USE_SAFE_ALLOCA
;
195 const unsigned char **volatile new_argv_volatile
;
196 register const unsigned char **new_argv
;
197 /* File to use for stderr in the child.
198 t means use same as standard output. */
199 Lisp_Object error_file
;
200 Lisp_Object output_file
= Qnil
;
201 #ifdef MSDOS /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
202 char *outf
, *tempfile
;
206 struct coding_system process_coding
; /* coding-system of process output */
207 struct coding_system argument_coding
; /* coding-system of arguments */
208 /* Set to the return value of Ffind_operation_coding_system. */
209 Lisp_Object coding_systems
;
210 int output_to_buffer
= 1;
212 /* Qt denotes that Ffind_operation_coding_system is not yet called. */
215 CHECK_STRING (args
[0]);
220 /* Without asynchronous processes we cannot have BUFFER == 0. */
222 && (INTEGERP (CONSP (args
[2]) ? XCAR (args
[2]) : args
[2])))
223 error ("Operating system cannot handle asynchronous subprocesses");
224 #endif /* subprocesses */
226 /* Decide the coding-system for giving arguments. */
228 Lisp_Object val
, *args2
;
231 /* If arguments are supplied, we may have to encode them. */
235 Lisp_Object coding_attrs
;
237 for (i
= 4; i
< nargs
; i
++)
238 CHECK_STRING (args
[i
]);
240 for (i
= 4; i
< nargs
; i
++)
241 if (STRING_MULTIBYTE (args
[i
]))
244 if (!NILP (Vcoding_system_for_write
))
245 val
= Vcoding_system_for_write
;
246 else if (! must_encode
)
250 SAFE_ALLOCA (args2
, Lisp_Object
*, (nargs
+ 1) * sizeof *args2
);
251 args2
[0] = Qcall_process
;
252 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
253 coding_systems
= Ffind_operation_coding_system (nargs
+ 1, args2
);
254 val
= CONSP (coding_systems
) ? XCDR (coding_systems
) : Qnil
;
256 val
= complement_process_encoding_system (val
);
257 setup_coding_system (Fcheck_coding_system (val
), &argument_coding
);
258 coding_attrs
= CODING_ID_ATTRS (argument_coding
.id
);
259 if (NILP (CODING_ATTR_ASCII_COMPAT (coding_attrs
)))
261 /* We should not use an ASCII incompatible coding system. */
262 val
= raw_text_coding_system (val
);
263 setup_coding_system (val
, &argument_coding
);
268 if (nargs
>= 2 && ! NILP (args
[1]))
270 infile
= Fexpand_file_name (args
[1], BVAR (current_buffer
, directory
));
271 CHECK_STRING (infile
);
274 infile
= build_string (NULL_DEVICE
);
280 /* If BUFFER is a list, its meaning is (BUFFER-FOR-STDOUT
281 FILE-FOR-STDERR), unless the first element is :file, in which case see
282 the next paragraph. */
283 if (CONSP (buffer
) &&
284 (! SYMBOLP (XCAR (buffer
)) ||
285 strcmp (SSDATA (SYMBOL_NAME (XCAR (buffer
))), ":file")))
287 if (CONSP (XCDR (buffer
)))
289 Lisp_Object stderr_file
;
290 stderr_file
= XCAR (XCDR (buffer
));
292 if (NILP (stderr_file
) || EQ (Qt
, stderr_file
))
293 error_file
= stderr_file
;
295 error_file
= Fexpand_file_name (stderr_file
, Qnil
);
298 buffer
= XCAR (buffer
);
301 /* If the buffer is (still) a list, it might be a (:file "file") spec. */
302 if (CONSP (buffer
) &&
303 SYMBOLP (XCAR (buffer
)) &&
304 ! strcmp (SSDATA (SYMBOL_NAME (XCAR (buffer
))), ":file"))
306 output_file
= Fexpand_file_name (XCAR (XCDR (buffer
)),
307 BVAR (current_buffer
, directory
));
308 CHECK_STRING (output_file
);
312 if (!(EQ (buffer
, Qnil
)
314 || INTEGERP (buffer
)))
316 Lisp_Object spec_buffer
;
317 spec_buffer
= buffer
;
318 buffer
= Fget_buffer_create (buffer
);
319 /* Mention the buffer name for a better error message. */
321 CHECK_BUFFER (spec_buffer
);
322 CHECK_BUFFER (buffer
);
328 /* Make sure that the child will be able to chdir to the current
329 buffer's current directory, or its unhandled equivalent. We
330 can't just have the child check for an error when it does the
331 chdir, since it's in a vfork.
333 We have to GCPRO around this because Fexpand_file_name,
334 Funhandled_file_name_directory, and Ffile_accessible_directory_p
335 might call a file name handling function. The argument list is
336 protected by the caller, so all we really have to worry about is
339 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
341 current_dir
= BVAR (current_buffer
, directory
);
343 GCPRO5 (infile
, buffer
, current_dir
, error_file
, output_file
);
345 current_dir
= Funhandled_file_name_directory (current_dir
);
346 if (NILP (current_dir
))
347 /* If the file name handler says that current_dir is unreachable, use
348 a sensible default. */
349 current_dir
= build_string ("~/");
350 current_dir
= expand_and_dir_to_file (current_dir
, Qnil
);
351 current_dir
= Ffile_name_as_directory (current_dir
);
353 if (NILP (Ffile_accessible_directory_p (current_dir
)))
354 report_file_error ("Setting current directory",
355 Fcons (BVAR (current_buffer
, directory
), Qnil
));
357 if (STRING_MULTIBYTE (infile
))
358 infile
= ENCODE_FILE (infile
);
359 if (STRING_MULTIBYTE (current_dir
))
360 current_dir
= ENCODE_FILE (current_dir
);
361 if (STRINGP (error_file
) && STRING_MULTIBYTE (error_file
))
362 error_file
= ENCODE_FILE (error_file
);
363 if (STRINGP (output_file
) && STRING_MULTIBYTE (output_file
))
364 output_file
= ENCODE_FILE (output_file
);
368 display_p_volatile
= INTERACTIVE
&& nargs
>= 4 && !NILP (args
[3]);
370 filefd
= emacs_open (SSDATA (infile
), O_RDONLY
, 0);
373 infile
= DECODE_FILE (infile
);
374 report_file_error ("Opening process input file", Fcons (infile
, Qnil
));
377 if (STRINGP (output_file
))
380 fd_output
= emacs_open (SSDATA (output_file
),
381 O_WRONLY
| O_TRUNC
| O_CREAT
| O_TEXT
,
383 #else /* not DOS_NT */
384 fd_output
= creat (SSDATA (output_file
), 0666);
385 #endif /* not DOS_NT */
388 output_file
= DECODE_FILE (output_file
);
389 report_file_error ("Opening process output file",
390 Fcons (output_file
, Qnil
));
392 if (STRINGP (error_file
) || NILP (error_file
))
393 output_to_buffer
= 0;
396 /* Search for program; barf if not found. */
398 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
400 GCPRO4 (infile
, buffer
, current_dir
, error_file
);
401 openp (Vexec_path
, args
[0], Vexec_suffixes
, &path
, make_number (X_OK
));
406 emacs_close (filefd
);
407 report_file_error ("Searching for program", Fcons (args
[0], Qnil
));
410 /* If program file name starts with /: for quoting a magic name,
412 if (SBYTES (path
) > 2 && SREF (path
, 0) == '/'
413 && SREF (path
, 1) == ':')
414 path
= Fsubstring (path
, make_number (2), Qnil
);
416 SAFE_ALLOCA (new_argv
, const unsigned char **,
417 (nargs
> 4 ? nargs
- 2 : 2) * sizeof *new_argv
);
418 new_argv_volatile
= new_argv
;
422 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
424 GCPRO5 (infile
, buffer
, current_dir
, path
, error_file
);
425 argument_coding
.dst_multibyte
= 0;
426 for (i
= 4; i
< nargs
; i
++)
428 argument_coding
.src_multibyte
= STRING_MULTIBYTE (args
[i
]);
429 if (CODING_REQUIRE_ENCODING (&argument_coding
))
430 /* We must encode this argument. */
431 args
[i
] = encode_coding_string (&argument_coding
, args
[i
], 1);
434 for (i
= 4; i
< nargs
; i
++)
435 new_argv
[i
- 3] = SDATA (args
[i
]);
440 new_argv
[0] = SDATA (path
);
442 #ifdef MSDOS /* MW, July 1993 */
443 if ((outf
= egetenv ("TMPDIR")))
444 strcpy (tempfile
= alloca (strlen (outf
) + 20), outf
);
447 tempfile
= alloca (20);
450 dostounix_filename (tempfile
);
451 if (*tempfile
== '\0' || tempfile
[strlen (tempfile
) - 1] != '/')
452 strcat (tempfile
, "/");
453 strcat (tempfile
, "detmp.XXX");
456 /* If we're redirecting STDOUT to a file, this is already opened. */
459 outfilefd
= creat (tempfile
, S_IREAD
| S_IWRITE
);
461 emacs_close (filefd
);
462 report_file_error ("Opening process output file",
463 Fcons (build_string (tempfile
), Qnil
));
467 outfilefd
= fd_output
;
472 if (INTEGERP (buffer
))
473 fd
[1] = emacs_open (NULL_DEVICE
, O_WRONLY
, 0), fd
[0] = -1;
480 emacs_close (filefd
);
481 report_file_error ("Creating process pipe", Qnil
);
487 /* child_setup must clobber environ in systems with true vfork.
488 Protect it from permanent change. */
489 register char **save_environ
= environ
;
490 register int fd1
= fd
[1];
492 #ifdef HAVE_WORKING_VFORK
495 struct sigaction sigpipe_action
;
500 #if 0 /* Some systems don't have sigblock. */
501 mask
= sigblock (sigmask (SIGCHLD
));
504 /* Record that we're about to create a synchronous process. */
505 synch_process_alive
= 1;
507 /* These vars record information from process termination.
508 Clear them now before process can possibly terminate,
509 to avoid timing error if process terminates soon. */
510 synch_process_death
= 0;
511 synch_process_retcode
= 0;
512 synch_process_termsig
= 0;
514 if (NILP (error_file
))
515 fd_error
= emacs_open (NULL_DEVICE
, O_WRONLY
, 0);
516 else if (STRINGP (error_file
))
519 fd_error
= emacs_open (SSDATA (error_file
),
520 O_WRONLY
| O_TRUNC
| O_CREAT
| O_TEXT
,
522 #else /* not DOS_NT */
523 fd_error
= creat (SSDATA (error_file
), 0666);
524 #endif /* not DOS_NT */
529 emacs_close (filefd
);
537 if (NILP (error_file
))
538 error_file
= build_string (NULL_DEVICE
);
539 else if (STRINGP (error_file
))
540 error_file
= DECODE_FILE (error_file
);
541 report_file_error ("Cannot redirect stderr", Fcons (error_file
, Qnil
));
544 #ifdef MSDOS /* MW, July 1993 */
545 /* Note that on MSDOS `child_setup' actually returns the child process
546 exit status, not its PID, so we assign it to `synch_process_retcode'
548 pid
= child_setup (filefd
, outfilefd
, fd_error
, (char **) new_argv
,
551 /* Record that the synchronous process exited and note its
552 termination status. */
553 synch_process_alive
= 0;
554 synch_process_retcode
= pid
;
555 if (synch_process_retcode
< 0) /* means it couldn't be exec'ed */
557 synchronize_system_messages_locale ();
558 synch_process_death
= strerror (errno
);
561 emacs_close (outfilefd
);
562 if (fd_error
!= outfilefd
)
563 emacs_close (fd_error
);
564 fd1
= -1; /* No harm in closing that one! */
565 /* Since CRLF is converted to LF within `decode_coding', we can
566 always open a file with binary mode. */
567 fd
[0] = emacs_open (tempfile
, O_RDONLY
| O_BINARY
, 0);
571 emacs_close (filefd
);
572 report_file_error ("Cannot re-open temporary file", Qnil
);
574 #else /* not MSDOS */
576 pid
= child_setup (filefd
, fd1
, fd_error
, (char **) new_argv
,
578 #else /* not WINDOWSNT */
580 #ifdef HAVE_WORKING_VFORK
581 /* On many hosts (e.g. Solaris 2.4), if a vforked child calls `signal',
582 this sets the parent's signal handlers as well as the child's.
583 So delay all interrupts whose handlers the child might munge,
584 and record the current handlers so they can be restored later. */
585 sigemptyset (&blocked
);
586 sigaddset (&blocked
, SIGPIPE
);
587 sigaction (SIGPIPE
, 0, &sigpipe_action
);
588 sigprocmask (SIG_BLOCK
, &blocked
, &procmask
);
595 new_argv
= new_argv_volatile
;
610 /* GConf causes us to ignore SIGPIPE, make sure it is restored
612 //signal (SIGPIPE, SIG_DFL);
613 #ifdef HAVE_WORKING_VFORK
614 sigprocmask (SIG_SETMASK
, &procmask
, 0);
617 child_setup (filefd
, fd1
, fd_error
, (char **) new_argv
,
623 #ifdef HAVE_WORKING_VFORK
624 /* Restore the signal state. */
625 sigaction (SIGPIPE
, &sigpipe_action
, 0);
626 sigprocmask (SIG_SETMASK
, &procmask
, 0);
629 #endif /* not WINDOWSNT */
631 /* The MSDOS case did this already. */
633 emacs_close (fd_error
);
634 #endif /* not MSDOS */
636 environ
= save_environ
;
638 /* Close most of our fd's, but not fd[0]
639 since we will use that to read input from. */
640 emacs_close (filefd
);
642 emacs_close (fd_output
);
643 if (fd1
>= 0 && fd1
!= fd_error
)
651 report_file_error ("Doing vfork", Qnil
);
654 if (INTEGERP (buffer
))
661 /* Enable sending signal if user quits below. */
662 call_process_exited
= 0;
665 /* MSDOS needs different cleanup information. */
666 record_unwind_protect (call_process_cleanup
,
667 Fcons (Fcurrent_buffer (),
668 Fcons (make_number (fd
[0]),
669 build_string (tempfile
))));
671 record_unwind_protect (call_process_cleanup
,
672 Fcons (Fcurrent_buffer (),
673 Fcons (make_number (fd
[0]), make_number (pid
))));
674 #endif /* not MSDOS */
677 if (BUFFERP (buffer
))
678 Fset_buffer (buffer
);
682 /* If BUFFER is nil, we must read process output once and then
683 discard it, so setup coding system but with nil. */
684 setup_coding_system (Qnil
, &process_coding
);
688 Lisp_Object val
, *args2
;
691 if (!NILP (Vcoding_system_for_read
))
692 val
= Vcoding_system_for_read
;
695 if (EQ (coding_systems
, Qt
))
699 SAFE_ALLOCA (args2
, Lisp_Object
*, (nargs
+ 1) * sizeof *args2
);
700 args2
[0] = Qcall_process
;
701 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
703 = Ffind_operation_coding_system (nargs
+ 1, args2
);
705 if (CONSP (coding_systems
))
706 val
= XCAR (coding_systems
);
707 else if (CONSP (Vdefault_process_coding_system
))
708 val
= XCAR (Vdefault_process_coding_system
);
712 Fcheck_coding_system (val
);
713 /* In unibyte mode, character code conversion should not take
714 place but EOL conversion should. So, setup raw-text or one
715 of the subsidiary according to the information just setup. */
716 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
))
718 val
= raw_text_coding_system (val
);
719 setup_coding_system (val
, &process_coding
);
725 if (output_to_buffer
)
727 register EMACS_INT nread
;
729 EMACS_INT total_read
= 0;
731 int display_p
= display_p_volatile
;
732 int display_on_the_fly
= display_p
;
733 struct coding_system saved_coding
;
735 saved_coding
= process_coding
;
738 /* Repeatedly read until we've filled as much as possible
739 of the buffer size we have. But don't read
740 less than 1024--save that for the next bufferful. */
742 while (nread
< bufsize
- 1024)
744 int this_read
= emacs_read (fd
[0], buf
+ nread
,
752 process_coding
.mode
|= CODING_MODE_LAST_BLOCK
;
757 total_read
+= this_read
;
759 if (display_on_the_fly
)
763 /* Now NREAD is the total amount of data in the buffer. */
768 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
))
769 && ! CODING_MAY_REQUIRE_DECODING (&process_coding
))
770 insert_1_both (buf
, nread
, nread
, 0, 1, 0);
772 { /* We have to decode the input. */
774 int count1
= SPECPDL_INDEX ();
776 XSETBUFFER (curbuf
, current_buffer
);
777 /* We cannot allow after-change-functions be run
778 during decoding, because that might modify the
779 buffer, while we rely on process_coding.produced to
780 faithfully reflect inserted text until we
781 TEMP_SET_PT_BOTH below. */
782 specbind (Qinhibit_modification_hooks
, Qt
);
783 decode_coding_c_string (&process_coding
, (unsigned char *) buf
,
785 unbind_to (count1
, Qnil
);
786 if (display_on_the_fly
787 && CODING_REQUIRE_DETECTION (&saved_coding
)
788 && ! CODING_REQUIRE_DETECTION (&process_coding
))
790 /* We have detected some coding system. But,
791 there's a possibility that the detection was
792 done by insufficient data. So, we give up
793 displaying on the fly. */
794 if (process_coding
.produced
> 0)
795 del_range_2 (process_coding
.dst_pos
,
796 process_coding
.dst_pos_byte
,
797 process_coding
.dst_pos
798 + process_coding
.produced_char
,
799 process_coding
.dst_pos_byte
800 + process_coding
.produced
, 0);
801 display_on_the_fly
= 0;
802 process_coding
= saved_coding
;
804 /* This is to make the above condition always
805 fails in the future. */
806 saved_coding
.common_flags
807 &= ~CODING_REQUIRE_DETECTION_MASK
;
811 TEMP_SET_PT_BOTH (PT
+ process_coding
.produced_char
,
812 PT_BYTE
+ process_coding
.produced
);
813 carryover
= process_coding
.carryover_bytes
;
815 memcpy (buf
, process_coding
.carryover
,
816 process_coding
.carryover_bytes
);
820 if (process_coding
.mode
& CODING_MODE_LAST_BLOCK
)
823 /* Make the buffer bigger as we continue to read more data,
824 but not past CALLPROC_BUFFER_SIZE_MAX. */
825 if (bufsize
< CALLPROC_BUFFER_SIZE_MAX
&& total_read
> 32 * bufsize
)
826 if ((bufsize
*= 2) > CALLPROC_BUFFER_SIZE_MAX
)
827 bufsize
= CALLPROC_BUFFER_SIZE_MAX
;
832 prepare_menu_bars ();
834 redisplay_preserve_echo_area (1);
835 /* This variable might have been set to 0 for code
836 detection. In that case, we set it back to 1 because
837 we should have already detected a coding system. */
838 display_on_the_fly
= 1;
845 Vlast_coding_system_used
= CODING_ID_NAME (process_coding
.id
);
846 /* If the caller required, let the buffer inherit the
847 coding-system used to decode the process output. */
848 if (inherit_process_coding_system
)
849 call1 (intern ("after-insert-file-set-buffer-file-coding-system"),
850 make_number (total_read
));
854 /* Wait for it to terminate, unless it already has. */
855 if (output_to_buffer
)
856 wait_for_termination (pid
);
858 interruptible_wait_for_termination (pid
);
863 /* Don't kill any children that the subprocess may have left behind
865 call_process_exited
= 1;
868 unbind_to (count
, Qnil
);
870 if (synch_process_termsig
)
874 synchronize_system_messages_locale ();
875 signame
= strsignal (synch_process_termsig
);
880 synch_process_death
= signame
;
883 if (synch_process_death
)
884 return code_convert_string_norecord (build_string (synch_process_death
),
885 Vlocale_coding_system
, 0);
886 return make_number (synch_process_retcode
);
890 delete_temp_file (Lisp_Object name
)
892 /* Suppress jka-compr handling, etc. */
893 int count
= SPECPDL_INDEX ();
894 specbind (intern ("file-name-handler-alist"), Qnil
);
895 internal_delete_file (name
);
896 unbind_to (count
, Qnil
);
900 DEFUN ("call-process-region", Fcall_process_region
, Scall_process_region
,
902 doc
: /* Send text from START to END to a synchronous process running PROGRAM.
903 The remaining arguments are optional.
904 Delete the text if fourth arg DELETE is non-nil.
906 Insert output in BUFFER before point; t means current buffer; nil for
907 BUFFER means discard it; 0 means discard and don't wait; and `(:file
908 FILE)', where FILE is a file name string, means that it should be
909 written to that file.
910 BUFFER can also have the form (REAL-BUFFER STDERR-FILE); in that case,
911 REAL-BUFFER says what to do with standard output, as above,
912 while STDERR-FILE says what to do with standard error in the child.
913 STDERR-FILE may be nil (discard standard error output),
914 t (mix it with ordinary output), or a file name string.
916 Sixth arg DISPLAY non-nil means redisplay buffer as output is inserted.
917 Remaining args are passed to PROGRAM at startup as command args.
919 If BUFFER is 0, `call-process-region' returns immediately with value nil.
920 Otherwise it waits for PROGRAM to terminate
921 and returns a numeric exit status or a signal description string.
922 If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.
924 usage: (call-process-region START END PROGRAM &optional DELETE BUFFER DISPLAY &rest ARGS) */)
925 (size_t nargs
, register Lisp_Object
*args
)
928 Lisp_Object filename_string
;
929 register Lisp_Object start
, end
;
930 int count
= SPECPDL_INDEX ();
931 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
932 Lisp_Object coding_systems
;
933 Lisp_Object val
, *args2
;
936 Lisp_Object tmpdir
, pattern
;
938 if (STRINGP (Vtemporary_file_directory
))
939 tmpdir
= Vtemporary_file_directory
;
943 if (getenv ("TMPDIR"))
944 tmpdir
= build_string (getenv ("TMPDIR"));
946 tmpdir
= build_string ("/tmp/");
949 if ((outf
= egetenv ("TMPDIR"))
950 || (outf
= egetenv ("TMP"))
951 || (outf
= egetenv ("TEMP")))
952 tmpdir
= build_string (outf
);
954 tmpdir
= Ffile_name_as_directory (build_string ("c:/temp"));
960 pattern
= Fexpand_file_name (Vtemp_file_name_pattern
, tmpdir
);
961 SAFE_ALLOCA (tempfile
, char *, SBYTES (pattern
) + 1);
962 memcpy (tempfile
, SDATA (pattern
), SBYTES (pattern
) + 1);
970 fd
= mkstemp (tempfile
);
973 report_file_error ("Failed to open temporary file",
974 Fcons (Vtemp_file_name_pattern
, Qnil
));
982 filename_string
= build_string (tempfile
);
983 GCPRO1 (filename_string
);
989 /* Decide coding-system of the contents of the temporary file. */
990 if (!NILP (Vcoding_system_for_write
))
991 val
= Vcoding_system_for_write
;
992 else if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
997 SAFE_ALLOCA (args2
, Lisp_Object
*, (nargs
+ 1) * sizeof *args2
);
998 args2
[0] = Qcall_process_region
;
999 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
1000 coding_systems
= Ffind_operation_coding_system (nargs
+ 1, args2
);
1001 val
= CONSP (coding_systems
) ? XCDR (coding_systems
) : Qnil
;
1004 val
= complement_process_encoding_system (val
);
1007 int count1
= SPECPDL_INDEX ();
1009 specbind (intern ("coding-system-for-write"), val
);
1010 /* POSIX lets mk[s]temp use "."; don't invoke jka-compr if we
1011 happen to get a ".Z" suffix. */
1012 specbind (intern ("file-name-handler-alist"), Qnil
);
1013 Fwrite_region (start
, end
, filename_string
, Qnil
, Qlambda
, Qnil
, Qnil
);
1015 unbind_to (count1
, Qnil
);
1018 /* Note that Fcall_process takes care of binding
1019 coding-system-for-read. */
1021 record_unwind_protect (delete_temp_file
, filename_string
);
1023 if (nargs
> 3 && !NILP (args
[3]))
1024 Fdelete_region (start
, end
);
1036 args
[1] = filename_string
;
1038 RETURN_UNGCPRO (unbind_to (count
, Fcall_process (nargs
, args
)));
1042 static int relocate_fd (int fd
, int minfd
);
1046 add_env (char **env
, char **new_env
, char *string
)
1053 /* See if this string duplicates any string already in the env.
1054 If so, don't put it in.
1055 When an env var has multiple definitions,
1056 we keep the definition that comes first in process-environment. */
1057 for (ep
= env
; ok
&& ep
!= new_env
; ep
++)
1059 char *p
= *ep
, *q
= string
;
1065 /* The string is a lone variable name; keep it for now, we
1066 will remove it later. It is a placeholder for a
1067 variable that is not to be included in the environment. */
1075 *new_env
++ = string
;
1079 /* This is the last thing run in a newly forked inferior
1080 either synchronous or asynchronous.
1081 Copy descriptors IN, OUT and ERR as descriptors 0, 1 and 2.
1082 Initialize inferior's priority, pgrp, connected dir and environment.
1083 then exec another program based on new_argv.
1085 This function may change environ for the superior process.
1086 Therefore, the superior process must save and restore the value
1087 of environ around the vfork and the call to this function.
1089 SET_PGRP is nonzero if we should put the subprocess into a separate
1092 CURRENT_DIR is an elisp string giving the path of the current
1093 directory the subprocess should have. Since we can't really signal
1094 a decent error from within the child, this should be verified as an
1095 executable directory by the parent. */
1098 child_setup (int in
, int out
, int err
, register char **new_argv
, int set_pgrp
, Lisp_Object current_dir
)
1105 #endif /* WINDOWSNT */
1107 int pid
= getpid ();
1109 /* Close Emacs's descriptors that this process should not have. */
1110 close_process_descs ();
1112 /* DOS_NT isn't in a vfork, so if we are in the middle of load-file,
1113 we will lose if we call close_load_descs here. */
1115 close_load_descs ();
1118 /* Note that use of alloca is always safe here. It's obvious for systems
1119 that do not have true vfork or that have true (stack) alloca.
1120 If using vfork and C_ALLOCA (when Emacs used to include
1121 src/alloca.c) it is safe because that changes the superior's
1122 static variables as if the superior had done alloca and will be
1123 cleaned up in the usual way. */
1125 register char *temp
;
1128 i
= SBYTES (current_dir
);
1130 /* MSDOS must have all environment variables malloc'ed, because
1131 low-level libc functions that launch subsidiary processes rely
1133 pwd_var
= (char *) xmalloc (i
+ 6);
1135 pwd_var
= (char *) alloca (i
+ 6);
1138 memcpy (pwd_var
, "PWD=", 4);
1139 memcpy (temp
, SDATA (current_dir
), i
);
1140 if (!IS_DIRECTORY_SEP (temp
[i
- 1])) temp
[i
++] = DIRECTORY_SEP
;
1144 /* We can't signal an Elisp error here; we're in a vfork. Since
1145 the callers check the current directory before forking, this
1146 should only return an error if the directory's permissions
1147 are changed between the check and this chdir, but we should
1149 if (chdir (temp
) < 0)
1152 /* Get past the drive letter, so that d:/ is left alone. */
1153 if (i
> 2 && IS_DEVICE_SEP (temp
[1]) && IS_DIRECTORY_SEP (temp
[2]))
1160 /* Strip trailing slashes for PWD, but leave "/" and "//" alone. */
1161 while (i
> 2 && IS_DIRECTORY_SEP (temp
[i
- 1]))
1165 /* Set `env' to a vector of the strings in the environment. */
1167 register Lisp_Object tem
;
1168 register char **new_env
;
1170 register int new_length
;
1171 Lisp_Object display
= Qnil
;
1175 for (tem
= Vprocess_environment
;
1176 CONSP (tem
) && STRINGP (XCAR (tem
));
1179 if (strncmp (SSDATA (XCAR (tem
)), "DISPLAY", 7) == 0
1180 && (SDATA (XCAR (tem
)) [7] == '\0'
1181 || SDATA (XCAR (tem
)) [7] == '='))
1182 /* DISPLAY is specified in process-environment. */
1187 /* If not provided yet, use the frame's DISPLAY. */
1190 Lisp_Object tmp
= Fframe_parameter (selected_frame
, Qdisplay
);
1191 if (!STRINGP (tmp
) && CONSP (Vinitial_environment
))
1192 /* If still not found, Look for DISPLAY in Vinitial_environment. */
1193 tmp
= Fgetenv_internal (build_string ("DISPLAY"),
1194 Vinitial_environment
);
1202 /* new_length + 2 to include PWD and terminating 0. */
1203 env
= new_env
= (char **) alloca ((new_length
+ 2) * sizeof (char *));
1204 /* If we have a PWD envvar, pass one down,
1205 but with corrected value. */
1206 if (egetenv ("PWD"))
1207 *new_env
++ = pwd_var
;
1209 if (STRINGP (display
))
1211 int vlen
= strlen ("DISPLAY=") + strlen (SSDATA (display
)) + 1;
1212 char *vdata
= (char *) alloca (vlen
);
1213 strcpy (vdata
, "DISPLAY=");
1214 strcat (vdata
, SSDATA (display
));
1215 new_env
= add_env (env
, new_env
, vdata
);
1219 for (tem
= Vprocess_environment
;
1220 CONSP (tem
) && STRINGP (XCAR (tem
));
1222 new_env
= add_env (env
, new_env
, SSDATA (XCAR (tem
)));
1226 /* Remove variable names without values. */
1230 while (*q
!= 0 && strchr (*q
, '=') == NULL
)
1240 prepare_standard_handles (in
, out
, err
, handles
);
1241 set_process_dir (SDATA (current_dir
));
1242 /* Spawn the child. (See ntproc.c:Spawnve). */
1243 cpid
= spawnve (_P_NOWAIT
, new_argv
[0], new_argv
, env
);
1244 reset_standard_handles (in
, out
, err
, handles
);
1246 /* An error occurred while trying to spawn the process. */
1247 report_file_error ("Spawning child process", Qnil
);
1250 #else /* not WINDOWSNT */
1251 /* Make sure that in, out, and err are not actually already in
1252 descriptors zero, one, or two; this could happen if Emacs is
1253 started with its standard in, out, or error closed, as might
1256 int oin
= in
, oout
= out
;
1258 /* We have to avoid relocating the same descriptor twice! */
1260 in
= relocate_fd (in
, 3);
1265 out
= relocate_fd (out
, 3);
1269 else if (err
== oout
)
1272 err
= relocate_fd (err
, 3);
1286 if (err
!= in
&& err
!= out
)
1290 #ifndef SETPGRP_RELEASES_CTTY
1291 setpgrp (); /* No arguments but equivalent in this case */
1295 #endif /* not USG */
1297 /* setpgrp_of_tty is incorrect here; it uses input_fd. */
1300 /* execvp does not accept an environment arg so the only way
1301 to pass this environment is to set environ. Our caller
1302 is responsible for restoring the ambient value of environ. */
1304 execvp (new_argv
[0], new_argv
);
1306 emacs_write (1, "Can't exec program: ", 20);
1307 emacs_write (1, new_argv
[0], strlen (new_argv
[0]));
1308 emacs_write (1, "\n", 1);
1312 pid
= run_msdos_command (new_argv
, pwd_var
+ 4, in
, out
, err
, env
);
1315 /* An error occurred while trying to run the subprocess. */
1316 report_file_error ("Spawning child process", Qnil
);
1319 #endif /* not WINDOWSNT */
1323 /* Move the file descriptor FD so that its number is not less than MINFD.
1324 If the file descriptor is moved at all, the original is freed. */
1326 relocate_fd (int fd
, int minfd
)
1334 new = fcntl (fd
, F_DUPFD
, minfd
);
1338 /* Note that we hold the original FD open while we recurse,
1339 to guarantee we'll get a new FD if we need it. */
1340 new = relocate_fd (new, minfd
);
1344 const char *message_1
= "Error while setting up child: ";
1345 const char *errmessage
= strerror (errno
);
1346 const char *message_2
= "\n";
1347 emacs_write (2, message_1
, strlen (message_1
));
1348 emacs_write (2, errmessage
, strlen (errmessage
));
1349 emacs_write (2, message_2
, strlen (message_2
));
1356 #endif /* not WINDOWSNT */
1359 getenv_internal_1 (const char *var
, int varlen
, char **value
, int *valuelen
,
1362 for (; CONSP (env
); env
= XCDR (env
))
1364 Lisp_Object entry
= XCAR (env
);
1366 && SBYTES (entry
) >= varlen
1368 /* NT environment variables are case insensitive. */
1369 && ! strnicmp (SDATA (entry
), var
, varlen
)
1370 #else /* not WINDOWSNT */
1371 && ! memcmp (SDATA (entry
), var
, varlen
)
1372 #endif /* not WINDOWSNT */
1375 if (SBYTES (entry
) > varlen
&& SREF (entry
, varlen
) == '=')
1377 *value
= SSDATA (entry
) + (varlen
+ 1);
1378 *valuelen
= SBYTES (entry
) - (varlen
+ 1);
1381 else if (SBYTES (entry
) == varlen
)
1383 /* Lone variable names in Vprocess_environment mean that
1384 variable should be removed from the environment. */
1394 getenv_internal (const char *var
, int varlen
, char **value
, int *valuelen
,
1397 /* Try to find VAR in Vprocess_environment first. */
1398 if (getenv_internal_1 (var
, varlen
, value
, valuelen
,
1399 Vprocess_environment
))
1400 return *value
? 1 : 0;
1402 /* For DISPLAY try to get the values from the frame or the initial env. */
1403 if (strcmp (var
, "DISPLAY") == 0)
1406 = Fframe_parameter (NILP (frame
) ? selected_frame
: frame
, Qdisplay
);
1407 if (STRINGP (display
))
1409 *value
= SSDATA (display
);
1410 *valuelen
= SBYTES (display
);
1413 /* If still not found, Look for DISPLAY in Vinitial_environment. */
1414 if (getenv_internal_1 (var
, varlen
, value
, valuelen
,
1415 Vinitial_environment
))
1416 return *value
? 1 : 0;
1422 DEFUN ("getenv-internal", Fgetenv_internal
, Sgetenv_internal
, 1, 2, 0,
1423 doc
: /* Get the value of environment variable VARIABLE.
1424 VARIABLE should be a string. Value is nil if VARIABLE is undefined in
1425 the environment. Otherwise, value is a string.
1427 This function searches `process-environment' for VARIABLE.
1429 If optional parameter ENV is a list, then search this list instead of
1430 `process-environment', and return t when encountering a negative entry
1431 \(an entry for a variable with no value). */)
1432 (Lisp_Object variable
, Lisp_Object env
)
1437 CHECK_STRING (variable
);
1440 if (getenv_internal_1 (SSDATA (variable
), SBYTES (variable
),
1441 &value
, &valuelen
, env
))
1442 return value
? make_string (value
, valuelen
) : Qt
;
1446 else if (getenv_internal (SSDATA (variable
), SBYTES (variable
),
1447 &value
, &valuelen
, env
))
1448 return make_string (value
, valuelen
);
1453 /* A version of getenv that consults the Lisp environment lists,
1454 easily callable from C. */
1456 egetenv (const char *var
)
1461 if (getenv_internal (var
, strlen (var
), &value
, &valuelen
, Qnil
))
1468 /* This is run before init_cmdargs. */
1471 init_callproc_1 (void)
1473 char *data_dir
= egetenv ("EMACSDATA");
1474 char *doc_dir
= egetenv ("EMACSDOC");
1477 = Ffile_name_as_directory (build_string (data_dir
? data_dir
1480 = Ffile_name_as_directory (build_string (doc_dir
? doc_dir
1483 /* Check the EMACSPATH environment variable, defaulting to the
1484 PATH_EXEC path from epaths.h. */
1485 Vexec_path
= decode_env_path ("EMACSPATH", PATH_EXEC
);
1486 Vexec_directory
= Ffile_name_as_directory (Fcar (Vexec_path
));
1487 Vexec_path
= nconc2 (decode_env_path ("PATH", ""), Vexec_path
);
1490 /* This is run after init_cmdargs, when Vinstallation_directory is valid. */
1493 init_callproc (void)
1495 char *data_dir
= egetenv ("EMACSDATA");
1498 Lisp_Object tempdir
;
1500 if (!NILP (Vinstallation_directory
))
1502 /* Add to the path the lib-src subdir of the installation dir. */
1504 tem
= Fexpand_file_name (build_string ("lib-src"),
1505 Vinstallation_directory
);
1507 /* MSDOS uses wrapped binaries, so don't do this. */
1508 if (NILP (Fmember (tem
, Vexec_path
)))
1510 Vexec_path
= decode_env_path ("EMACSPATH", PATH_EXEC
);
1511 Vexec_path
= Fcons (tem
, Vexec_path
);
1512 Vexec_path
= nconc2 (decode_env_path ("PATH", ""), Vexec_path
);
1515 Vexec_directory
= Ffile_name_as_directory (tem
);
1516 #endif /* not DOS_NT */
1518 /* Maybe use ../etc as well as ../lib-src. */
1521 tem
= Fexpand_file_name (build_string ("etc"),
1522 Vinstallation_directory
);
1523 Vdoc_directory
= Ffile_name_as_directory (tem
);
1527 /* Look for the files that should be in etc. We don't use
1528 Vinstallation_directory, because these files are never installed
1529 near the executable, and they are never in the build
1530 directory when that's different from the source directory.
1532 Instead, if these files are not in the nominal place, we try the
1533 source directory. */
1536 Lisp_Object tem
, tem1
, srcdir
;
1538 srcdir
= Fexpand_file_name (build_string ("../src/"),
1539 build_string (PATH_DUMPLOADSEARCH
));
1540 tem
= Fexpand_file_name (build_string ("GNU"), Vdata_directory
);
1541 tem1
= Ffile_exists_p (tem
);
1542 if (!NILP (Fequal (srcdir
, Vinvocation_directory
)) || NILP (tem1
))
1545 newdir
= Fexpand_file_name (build_string ("../etc/"),
1546 build_string (PATH_DUMPLOADSEARCH
));
1547 tem
= Fexpand_file_name (build_string ("GNU"), newdir
);
1548 tem1
= Ffile_exists_p (tem
);
1550 Vdata_directory
= newdir
;
1558 tempdir
= Fdirectory_file_name (Vexec_directory
);
1559 if (access (SSDATA (tempdir
), 0) < 0)
1560 dir_warning ("Warning: arch-dependent data dir (%s) does not exist.\n",
1564 tempdir
= Fdirectory_file_name (Vdata_directory
);
1565 if (access (SSDATA (tempdir
), 0) < 0)
1566 dir_warning ("Warning: arch-independent data dir (%s) does not exist.\n",
1569 sh
= (char *) getenv ("SHELL");
1570 Vshell_file_name
= build_string (sh
? sh
: "/bin/sh");
1573 Vshared_game_score_directory
= Qnil
;
1575 Vshared_game_score_directory
= build_string (PATH_GAME
);
1576 if (NILP (Ffile_directory_p (Vshared_game_score_directory
)))
1577 Vshared_game_score_directory
= Qnil
;
1582 set_initial_environment (void)
1584 register char **envp
;
1586 Vprocess_environment
= Qnil
;
1591 for (envp
= environ
; *envp
; envp
++)
1592 Vprocess_environment
= Fcons (build_string (*envp
),
1593 Vprocess_environment
);
1594 /* Ideally, the `copy' shouldn't be necessary, but it seems it's frequent
1595 to use `delete' and friends on process-environment. */
1596 Vinitial_environment
= Fcopy_sequence (Vprocess_environment
);
1601 syms_of_callproc (void)
1604 Vtemp_file_name_pattern
= build_string ("emacsXXXXXX");
1605 #elif defined (WINDOWSNT)
1606 Vtemp_file_name_pattern
= build_string ("emXXXXXX");
1608 Vtemp_file_name_pattern
= build_string ("detmp.XXX");
1610 staticpro (&Vtemp_file_name_pattern
);
1612 DEFVAR_LISP ("shell-file-name", Vshell_file_name
,
1613 doc
: /* *File name to load inferior shells from.
1614 Initialized from the SHELL environment variable, or to a system-dependent
1615 default if SHELL is not set. */);
1617 DEFVAR_LISP ("exec-path", Vexec_path
,
1618 doc
: /* *List of directories to search programs to run in subprocesses.
1619 Each element is a string (directory name) or nil (try default directory). */);
1621 DEFVAR_LISP ("exec-suffixes", Vexec_suffixes
,
1622 doc
: /* *List of suffixes to try to find executable file names.
1623 Each element is a string. */);
1624 Vexec_suffixes
= Qnil
;
1626 DEFVAR_LISP ("exec-directory", Vexec_directory
,
1627 doc
: /* Directory for executables for Emacs to invoke.
1628 More generally, this includes any architecture-dependent files
1629 that are built and installed from the Emacs distribution. */);
1631 DEFVAR_LISP ("data-directory", Vdata_directory
,
1632 doc
: /* Directory of machine-independent files that come with GNU Emacs.
1633 These are files intended for Emacs to use while it runs. */);
1635 DEFVAR_LISP ("doc-directory", Vdoc_directory
,
1636 doc
: /* Directory containing the DOC file that comes with GNU Emacs.
1637 This is usually the same as `data-directory'. */);
1639 DEFVAR_LISP ("configure-info-directory", Vconfigure_info_directory
,
1640 doc
: /* For internal use by the build procedure only.
1641 This is the name of the directory in which the build procedure installed
1642 Emacs's info files; the default value for `Info-default-directory-list'
1644 Vconfigure_info_directory
= build_string (PATH_INFO
);
1646 DEFVAR_LISP ("shared-game-score-directory", Vshared_game_score_directory
,
1647 doc
: /* Directory of score files for games which come with GNU Emacs.
1648 If this variable is nil, then Emacs is unable to use a shared directory. */);
1650 Vshared_game_score_directory
= Qnil
;
1652 Vshared_game_score_directory
= build_string (PATH_GAME
);
1655 DEFVAR_LISP ("initial-environment", Vinitial_environment
,
1656 doc
: /* List of environment variables inherited from the parent process.
1657 Each element should be a string of the form ENVVARNAME=VALUE.
1658 The elements must normally be decoded (using `locale-coding-system') for use. */);
1659 Vinitial_environment
= Qnil
;
1661 DEFVAR_LISP ("process-environment", Vprocess_environment
,
1662 doc
: /* List of overridden environment variables for subprocesses to inherit.
1663 Each element should be a string of the form ENVVARNAME=VALUE.
1665 Entries in this list take precedence to those in the frame-local
1666 environments. Therefore, let-binding `process-environment' is an easy
1667 way to temporarily change the value of an environment variable,
1668 irrespective of where it comes from. To use `process-environment' to
1669 remove an environment variable, include only its name in the list,
1672 This variable is set to nil when Emacs starts.
1674 If multiple entries define the same variable, the first one always
1677 Non-ASCII characters are encoded according to the initial value of
1678 `locale-coding-system', i.e. the elements must normally be decoded for
1681 See `setenv' and `getenv'. */);
1682 Vprocess_environment
= Qnil
;
1684 defsubr (&Scall_process
);
1685 defsubr (&Sgetenv_internal
);
1686 defsubr (&Scall_process_region
);