/* Synchronous subprocess invocation for GNU Emacs.
- Copyright (C) 1985, 86, 87, 88, 93, 94, 95 Free Software Foundation, Inc.
+ Copyright (C) 1985,86,87,88,93,94,95,99, 2000, 2001
+ Free Software Foundation, Inc.
This file is part of GNU Emacs.
Boston, MA 02111-1307, USA. */
+#include <config.h>
#include <signal.h>
#include <errno.h>
-
-#include <config.h>
#include <stdio.h>
+#ifndef USE_CRT_DLL
extern int errno;
-extern char *strerror ();
+#endif
/* Define SIGCHLD as an alias for SIGCLD. */
#include <sys/types.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
#include <sys/file.h>
#ifdef USG5
#define INCLUDED_FCNTL
#include "lisp.h"
#include "commands.h"
#include "buffer.h"
-#include "charset.h"
+#include "character.h"
#include "ccl.h"
#include "coding.h"
+#include "composite.h"
#include <epaths.h>
#include "process.h"
#include "syssignal.h"
#ifdef VMS
extern noshare char **environ;
#else
+#ifndef USE_CRT_DLL
extern char **environ;
#endif
+#endif
-#define max(a, b) ((a) > (b) ? (a) : (b))
+#ifdef HAVE_SETPGID
+#if !defined (USG) || defined (BSD_PGRPS)
+#undef setpgrp
+#define setpgrp setpgid
+#endif
+#endif
-Lisp_Object Vexec_path, Vexec_directory, Vdata_directory, Vdoc_directory;
+Lisp_Object Vexec_path, Vexec_directory, Vexec_suffixes;
+Lisp_Object Vdata_directory, Vdoc_directory;
Lisp_Object Vconfigure_info_directory;
Lisp_Object Vtemp_file_name_pattern;
call_process_kill (fdpid)
Lisp_Object fdpid;
{
- close (XFASTINT (Fcar (fdpid)));
+ emacs_close (XFASTINT (Fcar (fdpid)));
EMACS_KILLPG (XFASTINT (Fcdr (fdpid)), SIGKILL);
synch_process_alive = 0;
return Qnil;
/* for MSDOS fdpid is really (fd . tempfile) */
register Lisp_Object file;
file = Fcdr (fdpid);
- close (XFASTINT (Fcar (fdpid)));
+ emacs_close (XFASTINT (Fcar (fdpid)));
if (strcmp (XSTRING (file)-> data, NULL_DEVICE) != 0)
unlink (XSTRING (file)->data);
#else /* not MSDOS and not macintosh */
if (call_process_exited)
{
- close (XFASTINT (Fcar (fdpid)));
+ emacs_close (XFASTINT (Fcar (fdpid)));
return Qnil;
}
message1 ("Waiting for process to die...done");
}
synch_process_alive = 0;
- close (XFASTINT (Fcar (fdpid)));
+ emacs_close (XFASTINT (Fcar (fdpid)));
#endif /* not MSDOS */
return Qnil;
}
DEFUN ("call-process", Fcall_process, Scall_process, 1, MANY, 0,
- "Call PROGRAM synchronously in separate process.\n\
-The remaining arguments are optional.\n\
-The program's input comes from file INFILE (nil means `/dev/null').\n\
-Insert output in BUFFER before point; t means current buffer;\n\
- nil for BUFFER means discard it; 0 means discard and don't wait.\n\
-BUFFER can also have the form (REAL-BUFFER STDERR-FILE); in that case,\n\
-REAL-BUFFER says what to do with standard output, as above,\n\
-while STDERR-FILE says what to do with standard error in the child.\n\
-STDERR-FILE may be nil (discard standard error output),\n\
-t (mix it with ordinary output), or a file name string.\n\
-\n\
-Fourth arg DISPLAY non-nil means redisplay buffer as output is inserted.\n\
-Remaining arguments are strings passed as command arguments to PROGRAM.\n\
-\n\
-If BUFFER is 0, `call-process' returns immediately with value nil.\n\
-Otherwise it waits for PROGRAM to terminate\n\
-and returns a numeric exit status or a signal description string.\n\
-If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.")
- (nargs, args)
+ doc: /* Call PROGRAM synchronously in separate process.
+The remaining arguments are optional.
+The program's input comes from file INFILE (nil means `/dev/null').
+Insert output in BUFFER before point; t means current buffer;
+ nil for BUFFER means discard it; 0 means discard and don't wait.
+BUFFER can also have the form (REAL-BUFFER STDERR-FILE); in that case,
+REAL-BUFFER says what to do with standard output, as above,
+while STDERR-FILE says what to do with standard error in the child.
+STDERR-FILE may be nil (discard standard error output),
+t (mix it with ordinary output), or a file name string.
+
+Fourth arg DISPLAY non-nil means redisplay buffer as output is inserted.
+Remaining arguments are strings passed as command arguments to PROGRAM.
+
+If BUFFER is 0, `call-process' returns immediately with value nil.
+Otherwise it waits for PROGRAM to terminate
+and returns a numeric exit status or a signal description string.
+If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.
+
+usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS) */)
+ (nargs, args)
int nargs;
register Lisp_Object *args;
{
/* Qt denotes that Ffind_operation_coding_system is not yet called. */
coding_systems = Qt;
- CHECK_STRING (args[0], 0);
+ CHECK_STRING (args[0]);
error_file = Qt;
int must_encode = 0;
for (i = 4; i < nargs; i++)
- CHECK_STRING (args[i], i);
+ CHECK_STRING (args[i]);
for (i = 4; i < nargs; i++)
if (STRING_MULTIBYTE (args[i]))
if (nargs >= 2 && ! NILP (args[1]))
{
infile = Fexpand_file_name (args[1], current_buffer->directory);
- CHECK_STRING (infile, 1);
+ CHECK_STRING (infile);
}
else
infile = build_string (NULL_DEVICE);
buffer = Fget_buffer_create (buffer);
/* Mention the buffer name for a better error message. */
if (NILP (buffer))
- CHECK_BUFFER (spec_buffer, 2);
- CHECK_BUFFER (buffer, 2);
+ CHECK_BUFFER (spec_buffer);
+ CHECK_BUFFER (buffer);
}
}
else
display = nargs >= 4 ? args[3] : Qnil;
- filefd = open (XSTRING (infile)->data, O_RDONLY, 0);
+ filefd = emacs_open (XSTRING (infile)->data, O_RDONLY, 0);
if (filefd < 0)
{
report_file_error ("Opening process input file", Fcons (infile, Qnil));
struct gcpro gcpro1;
GCPRO1 (current_dir);
- openp (Vexec_path, args[0], EXEC_SUFFIXES, &path, 1);
+ openp (Vexec_path, args[0], Vexec_suffixes, &path, 1);
UNGCPRO;
}
if (NILP (path))
{
- close (filefd);
+ emacs_close (filefd);
report_file_error ("Searching for program", Fcons (args[0], Qnil));
}
new_argv[0] = XSTRING (path)->data;
if (nargs > 4)
{
register int i;
+ struct gcpro gcpro1, gcpro2, gcpro3;
- if (! CODING_REQUIRE_ENCODING (&argument_coding))
+ GCPRO3 (infile, buffer, current_dir);
+ argument_coding.dst_multibyte = 0;
+ for (i = 4; i < nargs; i++)
{
- for (i = 4; i < nargs; i++)
- new_argv[i - 3] = XSTRING (args[i])->data;
- }
- else
- {
- /* We must encode the arguments. */
- struct gcpro gcpro1, gcpro2, gcpro3;
-
- GCPRO3 (infile, buffer, current_dir);
- for (i = 4; i < nargs; i++)
- {
- int size = encoding_buffer_size (&argument_coding,
- STRING_BYTES (XSTRING (args[i])));
- unsigned char *dummy1 = (unsigned char *) alloca (size);
- int dummy;
-
- /* The Irix 4.0 compiler barfs if we eliminate dummy. */
- new_argv[i - 3] = dummy1;
- argument_coding.mode |= CODING_MODE_LAST_BLOCK;
- encode_coding (&argument_coding,
- XSTRING (args[i])->data,
- new_argv[i - 3],
- STRING_BYTES (XSTRING (args[i])),
- size);
- new_argv[i - 3][argument_coding.produced] = 0;
- /* We have to initialize CCL program status again. */
- if (argument_coding.type == coding_type_ccl)
- setup_ccl_program (&(argument_coding.spec.ccl.encoder), Qnil);
- }
- UNGCPRO;
+ argument_coding.src_multibyte = STRING_MULTIBYTE (args[i]);
+ if (CODING_REQUIRE_ENCODING (&argument_coding))
+ /* We must encode this argument. */
+ args[i] = encode_coding_string (&argument_coding, args[i], 1);
+ new_argv[i - 3] = XSTRING (args[i])->data;
}
+ UNGCPRO;
new_argv[nargs - 3] = 0;
}
else
outfilefd = creat (tempfile, S_IREAD | S_IWRITE);
if (outfilefd < 0)
{
- close (filefd);
+ emacs_close (filefd);
report_file_error ("Opening process output file",
Fcons (build_string (tempfile), Qnil));
}
#endif /* macintosh */
if (INTEGERP (buffer))
- fd[1] = open (NULL_DEVICE, O_WRONLY), fd[0] = -1;
+ fd[1] = emacs_open (NULL_DEVICE, O_WRONLY, 0), fd[0] = -1;
else
{
#ifndef MSDOS
#ifndef macintosh
- pipe (fd);
+ errno = 0;
+ if (pipe (fd) == -1)
+ {
+ emacs_close (filefd);
+ report_file_error ("Creating process pipe", Qnil);
+ }
#endif
#endif
#if 0
synch_process_retcode = 0;
if (NILP (error_file))
- fd_error = open (NULL_DEVICE, O_WRONLY);
+ fd_error = emacs_open (NULL_DEVICE, O_WRONLY, 0);
else if (STRINGP (error_file))
{
#ifdef DOS_NT
- fd_error = open (XSTRING (error_file)->data,
- O_WRONLY | O_TRUNC | O_CREAT | O_TEXT,
- S_IREAD | S_IWRITE);
+ fd_error = emacs_open (XSTRING (error_file)->data,
+ O_WRONLY | O_TRUNC | O_CREAT | O_TEXT,
+ S_IREAD | S_IWRITE);
#else /* not DOS_NT */
fd_error = creat (XSTRING (error_file)->data, 0666);
#endif /* not DOS_NT */
if (fd_error < 0)
{
- close (filefd);
+ emacs_close (filefd);
if (fd[0] != filefd)
- close (fd[0]);
+ emacs_close (fd[0]);
if (fd1 >= 0)
- close (fd1);
+ emacs_close (fd1);
#ifdef MSDOS
unlink (tempfile);
#endif
synch_process_alive = 0;
synch_process_retcode = pid;
if (synch_process_retcode < 0) /* means it couldn't be exec'ed */
- synch_process_death = strerror (errno);
+ {
+ synchronize_system_messages_locale ();
+ synch_process_death = strerror (errno);
+ }
/* Since CRLF is converted to LF within `decode_coding', we can
always open a file with binary mode. */
synch_process_alive = 0;
synch_process_retcode = pid;
if (synch_process_retcode < 0) /* means it couldn't be exec'ed */
- synch_process_death = strerror (errno);
+ {
+ synchronize_system_messages_locale ();
+ synch_process_death = strerror (errno);
+ }
- close (outfilefd);
+ emacs_close (outfilefd);
if (fd_error != outfilefd)
- close (fd_error);
+ emacs_close (fd_error);
fd1 = -1; /* No harm in closing that one! */
/* Since CRLF is converted to LF within `decode_coding', we can
always open a file with binary mode. */
- fd[0] = open (tempfile, O_BINARY);
+ fd[0] = emacs_open (tempfile, O_RDONLY | O_BINARY, 0);
if (fd[0] < 0)
{
unlink (tempfile);
- close (filefd);
+ emacs_close (filefd);
report_file_error ("Cannot re-open temporary file", Qnil);
}
#else /* not MSDOS */
if (pid == 0)
{
if (fd[0] >= 0)
- close (fd[0]);
+ emacs_close (fd[0]);
#ifdef HAVE_SETSID
setsid ();
#endif
/* The MSDOS case did this already. */
if (fd_error >= 0)
- close (fd_error);
+ emacs_close (fd_error);
#endif /* not MSDOS */
#endif /* not macintosh */
/* Close most of our fd's, but not fd[0]
since we will use that to read input from. */
- close (filefd);
+ emacs_close (filefd);
if (fd1 >= 0 && fd1 != fd_error)
- close (fd1);
+ emacs_close (fd1);
}
if (pid < 0)
{
if (fd[0] >= 0)
- close (fd[0]);
+ emacs_close (fd[0]);
report_file_error ("Doing vfork", Qnil);
}
if (INTEGERP (buffer))
{
if (fd[0] >= 0)
- close (fd[0]);
+ emacs_close (fd[0]);
#ifndef subprocesses
/* If Emacs has been built with asynchronous subprocess support,
we don't need to do this, I think because it will then have
else
val = Qnil;
}
- setup_coding_system (Fcheck_coding_system (val), &process_coding);
+ Fcheck_coding_system (val);
/* In unibyte mode, character code conversion should not take
place but EOL conversion should. So, setup raw-text or one
of the subsidiary according to the information just setup. */
if (NILP (current_buffer->enable_multibyte_characters)
&& !NILP (val))
- setup_raw_text_coding_system (&process_coding);
+ val = raw_text_coding_system (val);
+ setup_coding_system (val, &process_coding);
}
immediate_quit = 1;
struct coding_system saved_coding;
saved_coding = process_coding;
-
while (1)
{
/* Repeatedly read until we've filled as much as possible
nread = carryover;
while (nread < bufsize - 1024)
{
- int this_read = read (fd[0], bufptr + nread, bufsize - nread);
+ int this_read = emacs_read (fd[0], bufptr + nread,
+ bufsize - nread);
if (this_read < 0)
goto give_up;
if (!NILP (buffer))
{
- if (process_coding.type == coding_type_no_conversion)
- insert (bufptr, nread);
+ if (! CODING_MAY_REQUIRE_DECODING (&process_coding))
+ insert_1_both (bufptr, nread, nread, 0, 1, 0);
else
{ /* We have to decode the input. */
- int size = decoding_buffer_size (&process_coding, nread);
- char *decoding_buf = (char *) xmalloc (size);
+ Lisp_Object buf;
- decode_coding (&process_coding, bufptr, decoding_buf,
- nread, size);
+ XSETBUFFER (buf, current_buffer);
+ decode_coding_c_string (&process_coding, bufptr, nread,
+ buf);
if (display_on_the_fly
- && saved_coding.type == coding_type_undecided
- && process_coding.type != coding_type_undecided)
+ && CODING_REQUIRE_DETECTION (&saved_coding)
+ && ! CODING_REQUIRE_DETECTION (&process_coding))
{
/* We have detected some coding system. But,
there's a possibility that the detection was
done by insufficient data. So, we give up
displaying on the fly. */
- xfree (decoding_buf);
+ if (process_coding.produced > 0)
+ del_range_2 (process_coding.dst_pos,
+ process_coding.dst_pos_byte,
+ process_coding.dst_pos
+ + process_coding.produced_char,
+ process_coding.dst_pos_byte
+ + process_coding.produced, 0);
display_on_the_fly = 0;
process_coding = saved_coding;
carryover = nread;
continue;
}
- if (process_coding.produced > 0)
- insert (decoding_buf, process_coding.produced);
- xfree (decoding_buf);
- carryover = nread - process_coding.consumed;
+
+ TEMP_SET_PT_BOTH (PT + process_coding.produced_char,
+ PT_BYTE + process_coding.produced);
+ nread -= process_coding.consumed;
+ carryover = nread;
if (carryover > 0)
- {
- /* As CARRYOVER should not be that large, we had
- better avoid overhead of bcopy. */
- char *p = bufptr + process_coding.consumed;
- char *pend = p + carryover;
- char *dst = bufptr;
-
- while (p < pend) *dst++ = *p++;
- }
+ /* As CARRYOVER should not be that large, we had
+ better avoid overhead of bcopy. */
+ BCOPY_SHORT (bufptr + process_coding.consumed, bufptr,
+ carryover);
}
}
+
if (process_coding.mode & CODING_MODE_LAST_BLOCK)
- {
- if (carryover > 0)
- insert (bufptr, carryover);
- break;
- }
+ break;
/* Make the buffer bigger as we continue to read more data,
but not past 64k. */
if (bufsize < 64 * 1024 && total_read > 32 * bufsize)
{
+ char *tempptr;
bufsize *= 2;
- bufptr = (char *) alloca (bufsize);
+
+ tempptr = (char *) alloca (bufsize);
+ bcopy (bufptr, tempptr, bufsize / 2);
+ bufptr = tempptr;
}
if (!NILP (display) && INTERACTIVE)
if (first)
prepare_menu_bars ();
first = 0;
- redisplay_preserve_echo_area ();
+ redisplay_preserve_echo_area (1);
}
immediate_quit = 1;
QUIT;
}
give_up: ;
- Vlast_coding_system_used = process_coding.symbol;
-
- /* If the caller required, let the buffer inherit the
- coding-system used to decode the process output. */
- if (inherit_process_coding_system)
- call1 (intern ("after-insert-file-set-buffer-file-coding-system"),
- make_number (total_read));
+ Vlast_coding_system_used = CODING_ID_NAME (process_coding.id);
+ /* If the caller required, let the buffer inherit the
+ coding-system used to decode the process output. */
+ if (inherit_process_coding_system)
+ call1 (intern ("after-insert-file-set-buffer-file-coding-system"),
+ make_number (total_read));
}
/* Wait for it to terminate, unless it already has. */
unbind_to (count, Qnil);
if (synch_process_death)
- return build_string (synch_process_death);
+ return code_convert_string_norecord (build_string (synch_process_death),
+ Vlocale_coding_system, 0);
return make_number (synch_process_retcode);
}
#endif
/* Use Fdelete_file (indirectly) because that runs a file name handler.
We did that when writing the file, so we should do so when deleting. */
internal_delete_file (name);
+ return Qnil;
}
DEFUN ("call-process-region", Fcall_process_region, Scall_process_region,
- 3, MANY, 0,
- "Send text from START to END to a synchronous process running PROGRAM.\n\
-The remaining arguments are optional.\n\
-Delete the text if fourth arg DELETE is non-nil.\n\
-\n\
-Insert output in BUFFER before point; t means current buffer;\n\
- nil for BUFFER means discard it; 0 means discard and don't wait.\n\
-BUFFER can also have the form (REAL-BUFFER STDERR-FILE); in that case,\n\
-REAL-BUFFER says what to do with standard output, as above,\n\
-while STDERR-FILE says what to do with standard error in the child.\n\
-STDERR-FILE may be nil (discard standard error output),\n\
-t (mix it with ordinary output), or a file name string.\n\
-\n\
-Sixth arg DISPLAY non-nil means redisplay buffer as output is inserted.\n\
-Remaining args are passed to PROGRAM at startup as command args.\n\
-\n\
-If BUFFER is nil, `call-process-region' returns immediately with value nil.\n\
-Otherwise it waits for PROGRAM to terminate\n\
-and returns a numeric exit status or a signal description string.\n\
-If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.")
- (nargs, args)
+ 3, MANY, 0,
+ doc: /* Send text from START to END to a synchronous process running PROGRAM.
+The remaining arguments are optional.
+Delete the text if fourth arg DELETE is non-nil.
+
+Insert output in BUFFER before point; t means current buffer;
+ nil for BUFFER means discard it; 0 means discard and don't wait.
+BUFFER can also have the form (REAL-BUFFER STDERR-FILE); in that case,
+REAL-BUFFER says what to do with standard output, as above,
+while STDERR-FILE says what to do with standard error in the child.
+STDERR-FILE may be nil (discard standard error output),
+t (mix it with ordinary output), or a file name string.
+
+Sixth arg DISPLAY non-nil means redisplay buffer as output is inserted.
+Remaining args are passed to PROGRAM at startup as command args.
+
+If BUFFER is nil, `call-process-region' returns immediately with value nil.
+Otherwise it waits for PROGRAM to terminate
+and returns a numeric exit status or a signal description string.
+If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.
+
+usage: (call-process-region START END PROGRAM &optional DELETE BUFFER DISPLAY &rest ARGS) */)
+ (nargs, args)
int nargs;
register Lisp_Object *args;
{
coding_systems = Qt;
+#ifdef HAVE_MKSTEMP
+ {
+ int fd = mkstemp (tempfile);
+ if (fd == -1)
+ report_file_error ("Failed to open temporary file",
+ Fcons (Vtemp_file_name_pattern, Qnil));
+ else
+ close (fd);
+ }
+#else
mktemp (tempfile);
+#endif
filename_string = build_string (tempfile);
GCPRO1 (filename_string);
register int i;
i = STRING_BYTES (XSTRING (current_dir));
+#ifdef MSDOS
+ /* MSDOS must have all environment variables malloc'ed, because
+ low-level libc functions that launch subsidiary processes rely
+ on that. */
+ pwd_var = (char *) xmalloc (i + 6);
+#else
pwd_var = (char *) alloca (i + 6);
+#endif
temp = pwd_var + 4;
bcopy ("PWD=", pwd_var, 4);
bcopy (XSTRING (current_dir)->data, temp, i);
}
#ifndef MSDOS
- close (0);
- close (1);
- close (2);
+ emacs_close (0);
+ emacs_close (1);
+ emacs_close (2);
dup2 (in, 0);
dup2 (out, 1);
dup2 (err, 2);
- close (in);
- close (out);
- close (err);
+ emacs_close (in);
+ emacs_close (out);
+ emacs_close (err);
#endif /* not MSDOS */
#endif /* not WINDOWSNT */
/* setpgrp_of_tty is incorrect here; it uses input_fd. */
EMACS_SET_TTY_PGRP (0, &pid);
-#ifdef vipc
- something missing here;
-#endif /* vipc */
-
#ifdef MSDOS
pid = run_msdos_command (new_argv, pwd_var + 4, in, out, err, env);
+ xfree (pwd_var);
if (pid == -1)
/* An error occurred while trying to run the subprocess. */
report_file_error ("Spawning child process", Qnil);
environ = env;
execvp (new_argv[0], new_argv);
- write (1, "Can't exec program: ", 20);
- write (1, new_argv[0], strlen (new_argv[0]));
- write (1, "\n", 1);
+ emacs_write (1, "Can't exec program: ", 20);
+ emacs_write (1, new_argv[0], strlen (new_argv[0]));
+ emacs_write (1, "\n", 1);
_exit (1);
#endif /* not WINDOWSNT */
#endif /* not MSDOS */
char *message1 = "Error while setting up child: ";
char *errmessage = strerror (errno);
char *message2 = "\n";
- write (2, message1, strlen (message1));
- write (2, errmessage, strlen (errmessage));
- write (2, message2, strlen (message2));
+ emacs_write (2, message1, strlen (message1));
+ emacs_write (2, errmessage, strlen (errmessage));
+ emacs_write (2, message2, strlen (message2));
_exit (1);
}
/* Note that we hold the original FD open while we recurse,
to guarantee we'll get a new FD if we need it. */
new = relocate_fd (new, minfd);
- close (fd);
+ emacs_close (fd);
return new;
}
}
return 0;
}
-DEFUN ("getenv", Fgetenv, Sgetenv, 1, 1, 0,
- "Return the value of environment variable VAR, as a string.\n\
-VAR should be a string. Value is nil if VAR is undefined in the environment.\n\
-This function consults the variable ``process-environment'' for its value.")
- (var)
+DEFUN ("getenv-internal", Fgetenv_internal, Sgetenv_internal, 1, 1, 0,
+ doc: /* Return the value of environment variable VAR, as a string.
+VAR should be a string. Value is nil if VAR is undefined in the environment.
+This function consults the variable ``process-environment'' for its value. */)
+ (var)
Lisp_Object var;
{
char *value;
int valuelen;
- CHECK_STRING (var, 0);
+ CHECK_STRING (var);
if (getenv_internal (XSTRING (var)->data, STRING_BYTES (XSTRING (var)),
&value, &valuelen))
return make_string (value, valuelen);
#ifndef DOS_NT
/* MSDOS uses wrapped binaries, so don't do this. */
if (NILP (Fmember (tem, Vexec_path)))
- Vexec_path = nconc2 (Vexec_path, Fcons (tem, Qnil));
+ {
+ Vexec_path = decode_env_path ("EMACSPATH", PATH_EXEC);
+ Vexec_path = Fcons (tem, Vexec_path);
+ Vexec_path = nconc2 (decode_env_path ("PATH", ""), Vexec_path);
+ }
Vexec_directory = Ffile_name_as_directory (tem);
#endif /* not DOS_NT */
source directory. */
if (data_dir == 0)
{
- Lisp_Object tem, tem1, newdir;
+ Lisp_Object tem, tem1, srcdir;
+ srcdir = Fexpand_file_name (build_string ("../src/"),
+ build_string (PATH_DUMPLOADSEARCH));
tem = Fexpand_file_name (build_string ("GNU"), Vdata_directory);
tem1 = Ffile_exists_p (tem);
- if (NILP (tem1))
+ if (!NILP (Fequal (srcdir, Vinvocation_directory)) || NILP (tem1))
{
+ Lisp_Object newdir;
newdir = Fexpand_file_name (build_string ("../etc/"),
build_string (PATH_DUMPLOADSEARCH));
tem = Fexpand_file_name (build_string ("GNU"), newdir);
#endif /* DOS_NT */
DEFVAR_LISP ("shell-file-name", &Vshell_file_name,
- "*File name to load inferior shells from.\n\
-Initialized from the SHELL environment variable.");
+ doc: /* *File name to load inferior shells from.
+Initialized from the SHELL environment variable. */);
DEFVAR_LISP ("exec-path", &Vexec_path,
- "*List of directories to search programs to run in subprocesses.\n\
-Each element is a string (directory name) or nil (try default directory).");
+ doc: /* *List of directories to search programs to run in subprocesses.
+Each element is a string (directory name) or nil (try default directory). */);
+
+ DEFVAR_LISP ("exec-suffixes", &Vexec_suffixes,
+ doc: /* *List of suffixes to try to find executable file names.
+Each element is a string. */);
+ Vexec_suffixes = Qnil;
DEFVAR_LISP ("exec-directory", &Vexec_directory,
- "Directory for executables for Emacs to invoke.\n\
-More generally, this includes any architecture-dependent files\n\
-that are built and installed from the Emacs distribution.");
+ doc: /* Directory for executables for Emacs to invoke.
+More generally, this includes any architecture-dependent files
+that are built and installed from the Emacs distribution. */);
DEFVAR_LISP ("data-directory", &Vdata_directory,
- "Directory of machine-independent files that come with GNU Emacs.\n\
-These are files intended for Emacs to use while it runs.");
+ doc: /* Directory of machine-independent files that come with GNU Emacs.
+These are files intended for Emacs to use while it runs. */);
DEFVAR_LISP ("doc-directory", &Vdoc_directory,
- "Directory containing the DOC file that comes with GNU Emacs.\n\
-This is usually the same as data-directory.");
+ doc: /* Directory containing the DOC file that comes with GNU Emacs.
+This is usually the same as data-directory. */);
DEFVAR_LISP ("configure-info-directory", &Vconfigure_info_directory,
- "For internal use by the build procedure only.\n\
-This is the name of the directory in which the build procedure installed\n\
-Emacs's info files; the default value for Info-default-directory-list\n\
-includes this.");
+ doc: /* For internal use by the build procedure only.
+This is the name of the directory in which the build procedure installed
+Emacs's info files; the default value for Info-default-directory-list
+includes this. */);
Vconfigure_info_directory = build_string (PATH_INFO);
DEFVAR_LISP ("temp-file-name-pattern", &Vtemp_file_name_pattern,
- "Pattern for making names for temporary files.\n\
-This is used by `call-process-region'.");
+ doc: /* Pattern for making names for temporary files.
+This is used by `call-process-region'. */);
/* This variable is initialized in init_callproc. */
DEFVAR_LISP ("process-environment", &Vprocess_environment,
- "List of environment variables for subprocesses to inherit.\n\
-Each element should be a string of the form ENVVARNAME=VALUE.\n\
-The environment which Emacs inherits is placed in this variable\n\
-when Emacs starts.");
+ doc: /* List of environment variables for subprocesses to inherit.
+Each element should be a string of the form ENVVARNAME=VALUE.
+If multiple entries define the same variable, the first one always
+takes precedence.
+The environment which Emacs inherits is placed in this variable
+when Emacs starts. */);
#ifndef VMS
defsubr (&Scall_process);
- defsubr (&Sgetenv);
+ defsubr (&Sgetenv_internal);
#endif
defsubr (&Scall_process_region);
}