/* Synchronous subprocess invocation for GNU Emacs.
Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995, 1999, 2000, 2001,
- 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+ 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
This file is part of GNU Emacs.
GNU Emacs is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
+the Free Software Foundation; either version 3, or (at your option)
any later version.
GNU Emacs is distributed in the hope that it will be useful,
Lisp_Object Vshell_file_name;
-Lisp_Object Vglobal_environment;
-Lisp_Object Vprocess_environment;
+Lisp_Object Vprocess_environment, Vinitial_environment;
#ifdef DOS_NT
Lisp_Object Qbuffer_file_type;
#endif /* DOS_NT */
-/* True iff we are about to fork off a synchronous process or if we
+/* True if we are about to fork off a synchronous process or if we
are waiting for it. */
int synch_process_alive;
this is exit code of synchronous subprocess. */
int synch_process_retcode;
-/* List of environment variables to look up in emacsclient. */
-Lisp_Object Vlocal_environment_variables;
-
\f
/* Clean up when exiting Fcall_process.
On MSDOS, delete the temporary file on any kind of termination.
/* Nonzero if this is termination due to exit. */
static int call_process_exited;
+EXFUN (Fgetenv_internal, 2);
+
#ifndef VMS /* VMS version is in vmsproc.c. */
static Lisp_Object
Fourth arg DISPLAY non-nil means redisplay buffer as output is inserted.
Remaining arguments are strings passed as command arguments to PROGRAM.
+If executable PROGRAM can't be found as an executable, `call-process'
+signals a Lisp error. `call-process' reports errors in execution of
+the program only through its return and output.
+
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.
val = Qnil;
}
setup_coding_system (Fcheck_coding_system (val), &argument_coding);
+ if (argument_coding.common_flags & CODING_ASCII_INCOMPATIBLE_MASK)
+ setup_coding_system (Qraw_text, &argument_coding);
+ if (argument_coding.eol_type == CODING_EOL_UNDECIDED)
+ argument_coding.eol_type = system_eol_type;
}
}
#ifdef HAVE_MKSTEMP
{
- int fd = mkstemp (tempfile);
+ int fd;
+
+ BLOCK_INPUT;
+ fd = mkstemp (tempfile);
+ UNBLOCK_INPUT;
if (fd == -1)
report_file_error ("Failed to open temporary file",
Fcons (Vtemp_file_name_pattern, Qnil));
/* Note that use of alloca is always safe here. It's obvious for systems
that do not have true vfork or that have true (stack) alloca.
- If using vfork and C_ALLOCA it is safe because that changes
- the superior's static variables as if the superior had done alloca
- and will be cleaned up in the usual way. */
+ If using vfork and C_ALLOCA (when Emacs used to include
+ src/alloca.c) it is safe because that changes the superior's
+ static variables as if the superior had done alloca and will be
+ cleaned up in the usual way. */
{
register char *temp;
register int i;
register char **new_env;
char **p, **q;
register int new_length;
- Lisp_Object environment = Vglobal_environment;
- Lisp_Object local;
-
+ Lisp_Object display = Qnil;
+
new_length = 0;
for (tem = Vprocess_environment;
CONSP (tem) && STRINGP (XCAR (tem));
tem = XCDR (tem))
- new_length++;
-
- if (!NILP (Vlocal_environment_variables))
{
- local = get_frame_param (XFRAME (Fframe_with_environment (selected_frame)),
- Qenvironment);
- if (EQ (Vlocal_environment_variables, Qt)
- && !NILP (local))
- environment = local;
- else if (CONSP (local))
- {
- new_length += Fsafe_length (Vlocal_environment_variables);
- }
+ if (strncmp (SDATA (XCAR (tem)), "DISPLAY", 7) == 0
+ && (SDATA (XCAR (tem)) [7] == '\0'
+ || SDATA (XCAR (tem)) [7] == '='))
+ /* DISPLAY is specified in process-environment. */
+ display = Qt;
+ new_length++;
}
- for (tem = environment;
- CONSP (tem) && STRINGP (XCAR (tem));
- tem = XCDR (tem))
- new_length++;
+ /* If not provided yet, use the frame's DISPLAY. */
+ if (NILP (display))
+ {
+ Lisp_Object tmp = Fframe_parameter (selected_frame, Qdisplay);
+ if (!STRINGP (tmp) && CONSP (Vinitial_environment))
+ /* If still not found, Look for DISPLAY in Vinitial_environment. */
+ tmp = Fgetenv_internal (build_string ("DISPLAY"),
+ Vinitial_environment);
+ if (STRINGP (tmp))
+ {
+ display = tmp;
+ new_length++;
+ }
+ }
/* new_length + 2 to include PWD and terminating 0. */
env = new_env = (char **) alloca ((new_length + 2) * sizeof (char *));
-
/* If we have a PWD envvar, pass one down,
but with corrected value. */
- if (getenv ("PWD"))
+ if (egetenv ("PWD"))
*new_env++ = pwd_var;
+ if (STRINGP (display))
+ {
+ int vlen = strlen ("DISPLAY=") + strlen (SDATA (display)) + 1;
+ char *vdata = (char *) alloca (vlen);
+ strcpy (vdata, "DISPLAY=");
+ strcat (vdata, SDATA (display));
+ new_env = add_env (env, new_env, vdata);
+ }
+
/* Overrides. */
for (tem = Vprocess_environment;
CONSP (tem) && STRINGP (XCAR (tem));
tem = XCDR (tem))
new_env = add_env (env, new_env, SDATA (XCAR (tem)));
- /* Local part of environment, if Vlocal_environment_variables is a list. */
- for (tem = Vlocal_environment_variables;
- CONSP (tem) && STRINGP (XCAR (tem));
- tem = XCDR (tem))
- new_env = add_env (env, new_env, egetenv (SDATA (XCAR (tem))));
-
- /* The rest of the environment (either Vglobal_environment or the
- 'environment frame parameter). */
- for (tem = environment;
- CONSP (tem) && STRINGP (XCAR (tem));
- tem = XCDR (tem))
- new_env = add_env (env, new_env, SDATA (XCAR (tem)));
-
*new_env = 0;
/* Remove variable names without values. */
p++;
}
}
+
+
#ifdef WINDOWSNT
prepare_standard_handles (in, out, err, handles);
set_process_dir (SDATA (current_dir));
}
static int
-getenv_internal (var, varlen, value, valuelen, frame)
+getenv_internal_1 (var, varlen, value, valuelen, env)
char *var;
int varlen;
char **value;
int *valuelen;
- Lisp_Object frame;
+ Lisp_Object env;
{
- Lisp_Object scan;
- Lisp_Object environment = Vglobal_environment;
-
- /* Try to find VAR in Vprocess_environment first. */
- for (scan = Vprocess_environment; CONSP (scan); scan = XCDR (scan))
+ for (; CONSP (env); env = XCDR (env))
{
- Lisp_Object entry = XCAR (scan);
+ Lisp_Object entry = XCAR (env);
if (STRINGP (entry)
- && SBYTES (entry) >= varlen
+ && SBYTES (entry) >= varlen
#ifdef WINDOWSNT
- /* NT environment variables are case insensitive. */
- && ! strnicmp (SDATA (entry), var, varlen)
+ /* NT environment variables are case insensitive. */
+ && ! strnicmp (SDATA (entry), var, varlen)
#else /* not WINDOWSNT */
- && ! bcmp (SDATA (entry), var, varlen)
+ && ! bcmp (SDATA (entry), var, varlen)
#endif /* not WINDOWSNT */
- )
- {
- if (SBYTES (entry) > varlen && SREF (entry, varlen) == '=')
- {
- *value = (char *) SDATA (entry) + (varlen + 1);
- *valuelen = SBYTES (entry) - (varlen + 1);
- return 1;
- }
- else if (SBYTES (entry) == varlen)
- {
- /* Lone variable names in Vprocess_environment mean that
- variable should be removed from the environment. */
- return 0;
- }
- }
+ )
+ {
+ if (SBYTES (entry) > varlen && SREF (entry, varlen) == '=')
+ {
+ *value = (char *) SDATA (entry) + (varlen + 1);
+ *valuelen = SBYTES (entry) - (varlen + 1);
+ return 1;
+ }
+ else if (SBYTES (entry) == varlen)
+ {
+ /* Lone variable names in Vprocess_environment mean that
+ variable should be removed from the environment. */
+ *value = NULL;
+ return 1;
+ }
+ }
}
+ return 0;
+}
- /* Find the environment in which to search the variable. */
- if (!NILP (frame))
- {
- Lisp_Object local;
-
- CHECK_FRAME (frame);
- frame = Fframe_with_environment (frame);
- local = get_frame_param (XFRAME (frame), Qenvironment);
- /* Use Vglobal_environment if there is no local environment. */
- if (!NILP (local))
- environment = local;
- }
- else if (!NILP (Vlocal_environment_variables))
- {
- Lisp_Object local = get_frame_param (XFRAME (Fframe_with_environment (selected_frame)),
- Qenvironment);
- if (EQ (Vlocal_environment_variables, Qt)
- && !NILP (local))
- environment = local;
- else if (CONSP (local))
- {
- for (scan = Vlocal_environment_variables; CONSP (scan); scan = XCDR (scan))
- {
- Lisp_Object entry = XCAR (scan);
- if (STRINGP (entry)
- && SBYTES (entry) == varlen
-#ifdef WINDOWSNT
- /* NT environment variables are case insensitive. */
- && ! strnicmp (SDATA (entry), var, varlen)
-#else /* not WINDOWSNT */
- && ! bcmp (SDATA (entry), var, varlen)
-#endif /* not WINDOWSNT */
- )
- {
- environment = local;
- break;
- }
- }
- }
- }
+static int
+getenv_internal (var, varlen, value, valuelen, frame)
+ char *var;
+ int varlen;
+ char **value;
+ int *valuelen;
+ Lisp_Object frame;
+{
+ /* Try to find VAR in Vprocess_environment first. */
+ if (getenv_internal_1 (var, varlen, value, valuelen,
+ Vprocess_environment))
+ return *value ? 1 : 0;
- for (scan = environment; CONSP (scan); scan = XCDR (scan))
+ /* For DISPLAY try to get the values from the frame or the initial env. */
+ if (strcmp (var, "DISPLAY") == 0)
{
- Lisp_Object entry;
-
- entry = XCAR (scan);
- if (STRINGP (entry)
- && SBYTES (entry) > varlen
- && SREF (entry, varlen) == '='
-#ifdef WINDOWSNT
- /* NT environment variables are case insensitive. */
- && ! strnicmp (SDATA (entry), var, varlen)
-#else /* not WINDOWSNT */
- && ! bcmp (SDATA (entry), var, varlen)
-#endif /* not WINDOWSNT */
- )
+ Lisp_Object display
+ = Fframe_parameter (NILP (frame) ? selected_frame : frame, Qdisplay);
+ if (STRINGP (display))
{
- *value = (char *) SDATA (entry) + (varlen + 1);
- *valuelen = SBYTES (entry) - (varlen + 1);
+ *value = (char *) SDATA (display);
+ *valuelen = SBYTES (display);
return 1;
}
+ /* If still not found, Look for DISPLAY in Vinitial_environment. */
+ if (getenv_internal_1 (var, varlen, value, valuelen,
+ Vinitial_environment))
+ return *value ? 1 : 0;
}
return 0;
VARIABLE should be a string. Value is nil if VARIABLE is undefined in
the environment. Otherwise, value is a string.
-If optional parameter FRAME is non-nil, then it should be a frame. If
-that frame has its own set of environment variables, this function
-will look up VARIABLE in there.
+This function searches `process-environment' for VARIABLE. If it is
+not found there, then it continues the search in the environment list
+of the selected frame.
+
+If optional parameter ENV is a list, then search this list instead of
+`process-environment', and return t when encountering a negative entry.
-Otherwise, this function searches `process-environment' for VARIABLE.
-If it is not found there, then it continues the search in either
-`global-environment' or the environment list of the selected frame,
-depending on the value of `local-environment-variables'. */)
- (variable, frame)
- Lisp_Object variable, frame;
+If it is a frame, then this function will ignore `process-environment' and
+will simply look up the variable in that frame's environment. */)
+ (variable, env)
+ Lisp_Object variable, env;
{
char *value;
int valuelen;
CHECK_STRING (variable);
- if (getenv_internal (SDATA (variable), SBYTES (variable),
- &value, &valuelen, frame))
+ if (CONSP (env))
+ {
+ if (getenv_internal_1 (SDATA (variable), SBYTES (variable),
+ &value, &valuelen, env))
+ return value ? make_string (value, valuelen) : Qt;
+ else
+ return Qnil;
+ }
+ else if (getenv_internal (SDATA (variable), SBYTES (variable),
+ &value, &valuelen, env))
return make_string (value, valuelen);
else
return Qnil;
{
char *dir = getenv ("TMPDIR");
Vtemp_file_name_pattern
- = Fexpand_file_name (build_string ("emacsXXXXXX"),
- build_string (dir));
+ = Fexpand_file_name (build_string ("emacsXXXXXX"),
+ build_string (dir));
}
else
Vtemp_file_name_pattern = build_string ("/tmp/emacsXXXXXX");
}
void
-set_global_environment ()
+set_initial_environment ()
{
register char **envp;
-
- Vglobal_environment = Qnil;
#ifndef CANNOT_DUMP
if (initialized)
#endif
- for (envp = environ; *envp; envp++)
- Vglobal_environment = Fcons (build_string (*envp),
- Vglobal_environment);
+ {
+ for (envp = environ; *envp; envp++)
+ Vprocess_environment = Fcons (build_string (*envp),
+ Vprocess_environment);
+ store_frame_param (SELECTED_FRAME(), Qenvironment, Vprocess_environment);
+ /* Ideally, the `copy' shouldn't be necessary, but it seems it's frequent
+ to use `delete' and friends on process-environment. */
+ Vinitial_environment = Fcopy_sequence (Vprocess_environment);
+ }
}
void
DEFVAR_LISP ("shell-file-name", &Vshell_file_name,
doc: /* *File name to load inferior shells from.
-Initialized from the SHELL environment variable. */);
+Initialized from the SHELL environment variable, or to a system-dependent
+default if SHELL is not set. */);
DEFVAR_LISP ("exec-path", &Vexec_path,
doc: /* *List of directories to search programs to run in subprocesses.
DEFVAR_LISP ("doc-directory", &Vdoc_directory,
doc: /* Directory containing the DOC file that comes with GNU Emacs.
-This is usually the same as data-directory. */);
+This is usually the same as `data-directory'. */);
DEFVAR_LISP ("configure-info-directory", &Vconfigure_info_directory,
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
+Emacs's info files; the default value for `Info-default-directory-list'
includes this. */);
Vconfigure_info_directory = build_string (PATH_INFO);
This is used by `call-process-region'. */);
/* This variable is initialized in init_callproc. */
- DEFVAR_LISP ("global-environment", &Vglobal_environment,
- doc: /* Global list of environment variables for subprocesses to inherit.
+ DEFVAR_LISP ("initial-environment", &Vinitial_environment,
+ doc: /* List of environment variables inherited from the parent process.
Each element should be a string of the form ENVVARNAME=VALUE.
-
-The environment which Emacs inherits is placed in this variable when
-Emacs starts.
-
-Some frames may have their own local list of environment variables in
-their 'environment parameter, which may override this global list; see
-`local-environment-variables' and `frame-with-environment'. See
-`process-environment' for a way to modify an environment variable on
-all frames.
-
-If multiple entries define the same variable, the first one always
-takes precedence.
-
-Non-ASCII characters are encoded according to the initial value of
-`locale-coding-system', i.e. the elements must normally be decoded for use.
-See `setenv' and `getenv'. */);
+The elements must normally be decoded (using `locale-coding-system') for use. */);
+ Vinitial_environment = Qnil;
DEFVAR_LISP ("process-environment", &Vprocess_environment,
doc: /* List of overridden environment variables for subprocesses to inherit.
Each element should be a string of the form ENVVARNAME=VALUE.
-Entries in this list take precedence to those in `global-environment'
-or the frame-local environments. (See `local-environment-variables'
-and `frame-with-environment'.) Therefore, let-binding
-`process-environment' is an easy way to temporarily change the value
-of an environment variable, irrespective of where it comes from. To
-use `process-environment' to remove an environment variable, include
-only its name in the list, without "=VALUE".
+Entries in this list take precedence to those in the frame-local
+environments. Therefore, let-binding `process-environment' is an easy
+way to temporarily change the value of an environment variable,
+irrespective of where it comes from. To use `process-environment' to
+remove an environment variable, include only its name in the list,
+without "=VALUE".
This variable is set to nil when Emacs starts.
defsubr (&Sgetenv_internal);
#endif
defsubr (&Scall_process_region);
-
- DEFVAR_LISP ("local-environment-variables", &Vlocal_environment_variables,
- doc: /* Enable or disable frame-local environment variables.
-If set to t, `getenv', `setenv' and subprocess creation functions use
-the local environment of the selected frame, ignoring
-`global-environment'.
-
-If set to nil, Emacs uses `global-environment' and ignores the
-frame-local environment.
-
-Otherwise, `local-environment-variables' should be a list of variable
-names (represented by Lisp strings) to look up in the frame's
-environment. The rest will come from `global-environment'.
-
-The frame-local environment is stored in the 'environment frame
-parameter. See `frame-with-environment'. */);
- Vlocal_environment_variables = Qt;
}
/* arch-tag: 769b8045-1df7-4d2b-8968-e3fb49017f95