1 /* variables.c -- Functions for hacking shell variables. */
3 /* Copyright (C) 1987-2013 Free Software Foundation, Inc.
5 This file is part of GNU Bash, the Bourne Again SHell.
7 Bash 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 Bash 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 Bash. If not, see <http://www.gnu.org/licenses/>.
23 #include "bashtypes.h"
24 #include "posixstat.h"
25 #include "posixtime.h"
28 # if defined (__QNXNTO__)
29 # include <sys/netmgr.h>
32 # endif /* !__QNXNTO__ */
35 #if defined (HAVE_UNISTD_H)
40 #include "chartypes.h"
41 #if defined (HAVE_PWD_H)
47 #define NEED_XTRACE_SET_DECL
51 #include "execute_cmd.h"
53 #include "mailcheck.h"
62 #include "builtins/getopt.h"
63 #include "builtins/common.h"
64 #include "builtins/builtext.h"
66 #if defined (READLINE)
67 # include "bashline.h"
68 # include <readline/readline.h>
70 # include <tilde/tilde.h>
74 # include "bashhist.h"
75 # include <readline/history.h>
78 #if defined (PROGRAMMABLE_COMPLETION)
79 # include "pcomplete.h"
82 #define TEMPENV_HASH_BUCKETS 4 /* must be power of two */
84 #define ifsname(s) ((s)[0] == 'I' && (s)[1] == 'F' && (s)[2] == 'S' && (s)[3] == '\0')
86 #define BASHFUNC_PREFIX "BASH_FUNC_"
87 #define BASHFUNC_PREFLEN 10 /* == strlen(BASHFUNC_PREFIX */
88 #define BASHFUNC_SUFFIX "%%"
89 #define BASHFUNC_SUFFLEN 2 /* == strlen(BASHFUNC_SUFFIX) */
91 extern char **environ;
93 /* Variables used here and defined in other files. */
94 extern int posixly_correct;
95 extern int line_number, line_number_base;
96 extern int subshell_environment, indirection_level, subshell_level;
97 extern int build_version, patch_level;
98 extern int expanding_redir;
99 extern int last_command_exit_value;
100 extern char *dist_version, *release_status;
101 extern char *shell_name;
102 extern char *primary_prompt, *secondary_prompt;
103 extern char *current_host_name;
104 extern sh_builtin_func_t *this_shell_builtin;
105 extern SHELL_VAR *this_shell_function;
106 extern char *the_printed_command_except_trap;
107 extern char *this_command_name;
108 extern char *command_execution_string;
109 extern time_t shell_start_time;
110 extern int assigning_in_environment;
111 extern int executing_builtin;
112 extern int funcnest_max;
114 #if defined (READLINE)
115 extern int no_line_editing;
116 extern int perform_hostname_completion;
119 /* The list of shell variables that the user has created at the global
120 scope, or that came from the environment. */
121 VAR_CONTEXT *global_variables = (VAR_CONTEXT *)NULL;
123 /* The current list of shell variables, including function scopes */
124 VAR_CONTEXT *shell_variables = (VAR_CONTEXT *)NULL;
126 /* The list of shell functions that the user has created, or that came from
128 HASH_TABLE *shell_functions = (HASH_TABLE *)NULL;
130 #if defined (DEBUGGER)
131 /* The table of shell function definitions that the user defined or that
132 came from the environment. */
133 HASH_TABLE *shell_function_defs = (HASH_TABLE *)NULL;
136 /* The current variable context. This is really a count of how deep into
137 executing functions we are. */
138 int variable_context = 0;
140 /* The set of shell assignments which are made only in the environment
141 for a single command. */
142 HASH_TABLE *temporary_env = (HASH_TABLE *)NULL;
144 /* Set to non-zero if an assignment error occurs while putting variables
145 into the temporary environment. */
146 int tempenv_assign_error;
148 /* Some funky variables which are known about specially. Here is where
149 "$*", "$1", and all the cruft is kept. */
150 char *dollar_vars[10];
151 WORD_LIST *rest_of_args = (WORD_LIST *)NULL;
153 /* The value of $$. */
154 pid_t dollar_dollar_pid;
156 /* Non-zero means that we have to remake EXPORT_ENV. */
157 int array_needs_making = 1;
159 /* The number of times BASH has been executed. This is set
160 by initialize_variables (). */
163 /* An array which is passed to commands as their environment. It is
164 manufactured from the union of the initial environment and the
165 shell variables that are marked for export. */
166 char **export_env = (char **)NULL;
167 static int export_env_index;
168 static int export_env_size;
170 #if defined (READLINE)
171 static int winsize_assignment; /* currently assigning to LINES or COLUMNS */
174 static HASH_TABLE *last_table_searched; /* hash_lookup sets this */
176 /* Some forward declarations. */
177 static void create_variable_tables __P((void));
179 static void set_machine_vars __P((void));
180 static void set_home_var __P((void));
181 static void set_shell_var __P((void));
182 static char *get_bash_name __P((void));
183 static void initialize_shell_level __P((void));
184 static void uidset __P((void));
185 #if defined (ARRAY_VARS)
186 static void make_vers_array __P((void));
189 static SHELL_VAR *null_assign __P((SHELL_VAR *, char *, arrayind_t, char *));
190 #if defined (ARRAY_VARS)
191 static SHELL_VAR *null_array_assign __P((SHELL_VAR *, char *, arrayind_t, char *));
193 static SHELL_VAR *get_self __P((SHELL_VAR *));
195 #if defined (ARRAY_VARS)
196 static SHELL_VAR *init_dynamic_array_var __P((char *, sh_var_value_func_t *, sh_var_assign_func_t *, int));
197 static SHELL_VAR *init_dynamic_assoc_var __P((char *, sh_var_value_func_t *, sh_var_assign_func_t *, int));
200 static SHELL_VAR *assign_seconds __P((SHELL_VAR *, char *, arrayind_t, char *));
201 static SHELL_VAR *get_seconds __P((SHELL_VAR *));
202 static SHELL_VAR *init_seconds_var __P((void));
204 static int brand __P((void));
205 static void sbrand __P((unsigned long)); /* set bash random number generator. */
206 static void seedrand __P((void)); /* seed generator randomly */
207 static SHELL_VAR *assign_random __P((SHELL_VAR *, char *, arrayind_t, char *));
208 static SHELL_VAR *get_random __P((SHELL_VAR *));
210 static SHELL_VAR *assign_lineno __P((SHELL_VAR *, char *, arrayind_t, char *));
211 static SHELL_VAR *get_lineno __P((SHELL_VAR *));
213 static SHELL_VAR *assign_subshell __P((SHELL_VAR *, char *, arrayind_t, char *));
214 static SHELL_VAR *get_subshell __P((SHELL_VAR *));
216 static SHELL_VAR *get_bashpid __P((SHELL_VAR *));
218 #if defined (HISTORY)
219 static SHELL_VAR *get_histcmd __P((SHELL_VAR *));
222 #if defined (READLINE)
223 static SHELL_VAR *get_comp_wordbreaks __P((SHELL_VAR *));
224 static SHELL_VAR *assign_comp_wordbreaks __P((SHELL_VAR *, char *, arrayind_t, char *));
227 #if defined (PUSHD_AND_POPD) && defined (ARRAY_VARS)
228 static SHELL_VAR *assign_dirstack __P((SHELL_VAR *, char *, arrayind_t, char *));
229 static SHELL_VAR *get_dirstack __P((SHELL_VAR *));
232 #if defined (ARRAY_VARS)
233 static SHELL_VAR *get_groupset __P((SHELL_VAR *));
235 static SHELL_VAR *build_hashcmd __P((SHELL_VAR *));
236 static SHELL_VAR *get_hashcmd __P((SHELL_VAR *));
237 static SHELL_VAR *assign_hashcmd __P((SHELL_VAR *, char *, arrayind_t, char *));
239 static SHELL_VAR *build_aliasvar __P((SHELL_VAR *));
240 static SHELL_VAR *get_aliasvar __P((SHELL_VAR *));
241 static SHELL_VAR *assign_aliasvar __P((SHELL_VAR *, char *, arrayind_t, char *));
245 static SHELL_VAR *get_funcname __P((SHELL_VAR *));
246 static SHELL_VAR *init_funcname_var __P((void));
248 static void initialize_dynamic_variables __P((void));
250 static SHELL_VAR *hash_lookup __P((const char *, HASH_TABLE *));
251 static SHELL_VAR *new_shell_variable __P((const char *));
252 static SHELL_VAR *make_new_variable __P((const char *, HASH_TABLE *));
253 static SHELL_VAR *bind_variable_internal __P((const char *, char *, HASH_TABLE *, int, int));
255 static void dispose_variable_value __P((SHELL_VAR *));
256 static void free_variable_hash_data __P((PTR_T));
258 static VARLIST *vlist_alloc __P((int));
259 static VARLIST *vlist_realloc __P((VARLIST *, int));
260 static void vlist_add __P((VARLIST *, SHELL_VAR *, int));
262 static void flatten __P((HASH_TABLE *, sh_var_map_func_t *, VARLIST *, int));
264 static int qsort_var_comp __P((SHELL_VAR **, SHELL_VAR **));
266 static SHELL_VAR **vapply __P((sh_var_map_func_t *));
267 static SHELL_VAR **fapply __P((sh_var_map_func_t *));
269 static int visible_var __P((SHELL_VAR *));
270 static int visible_and_exported __P((SHELL_VAR *));
271 static int export_environment_candidate __P((SHELL_VAR *));
272 static int local_and_exported __P((SHELL_VAR *));
273 static int variable_in_context __P((SHELL_VAR *));
274 #if defined (ARRAY_VARS)
275 static int visible_array_vars __P((SHELL_VAR *));
278 static SHELL_VAR *find_nameref_at_context __P((SHELL_VAR *, VAR_CONTEXT *));
279 static SHELL_VAR *find_variable_nameref_context __P((SHELL_VAR *, VAR_CONTEXT *, VAR_CONTEXT **));
280 static SHELL_VAR *find_variable_last_nameref_context __P((SHELL_VAR *, VAR_CONTEXT *, VAR_CONTEXT **));
282 static SHELL_VAR *bind_tempenv_variable __P((const char *, char *));
283 static void push_temp_var __P((PTR_T));
284 static void propagate_temp_var __P((PTR_T));
285 static void dispose_temporary_env __P((sh_free_func_t *));
287 static inline char *mk_env_string __P((const char *, const char *, int));
288 static char **make_env_array_from_var_list __P((SHELL_VAR **));
289 static char **make_var_export_array __P((VAR_CONTEXT *));
290 static char **make_func_export_array __P((void));
291 static void add_temp_array_to_env __P((char **, int, int));
293 static int n_shell_variables __P((void));
294 static int set_context __P((SHELL_VAR *));
296 static void push_func_var __P((PTR_T));
297 static void push_exported_var __P((PTR_T));
299 static inline int find_special_var __P((const char *));
302 create_variable_tables ()
304 if (shell_variables == 0)
306 shell_variables = global_variables = new_var_context ((char *)NULL, 0);
307 shell_variables->scope = 0;
308 shell_variables->table = hash_create (0);
311 if (shell_functions == 0)
312 shell_functions = hash_create (0);
314 #if defined (DEBUGGER)
315 if (shell_function_defs == 0)
316 shell_function_defs = hash_create (0);
320 /* Initialize the shell variables from the current environment.
321 If PRIVMODE is nonzero, don't import functions from ENV or
324 initialize_shell_variables (env, privmode)
328 char *name, *string, *temp_string;
329 int c, char_index, string_index, string_length, ro;
332 create_variable_tables ();
334 for (string_index = 0; string = env[string_index++]; )
338 while ((c = *string++) && c != '=')
340 if (string[-1] == '=')
341 char_index = string - name - 1;
343 /* If there are weird things in the environment, like `=xxx' or a
344 string without an `=', just skip them. */
348 /* ASSERT(name[char_index] == '=') */
349 name[char_index] = '\0';
350 /* Now, name = env variable name, string = env variable value, and
351 char_index == strlen (name) */
353 temp_var = (SHELL_VAR *)NULL;
355 /* If exported function, define it now. Don't import functions from
356 the environment in privileged mode. */
357 if (privmode == 0 && read_but_dont_execute == 0 &&
358 STREQN (BASHFUNC_PREFIX, name, BASHFUNC_PREFLEN) &&
359 STREQ (BASHFUNC_SUFFIX, name + char_index - BASHFUNC_SUFFLEN) &&
360 STREQN ("() {", string, 4))
363 char *tname; /* desired imported function name */
365 namelen = char_index - BASHFUNC_PREFLEN - BASHFUNC_SUFFLEN;
367 tname = name + BASHFUNC_PREFLEN; /* start of func name */
368 tname[namelen] = '\0'; /* now tname == func name */
370 string_length = strlen (string);
371 temp_string = (char *)xmalloc (namelen + string_length + 2);
373 memcpy (temp_string, tname, namelen);
374 temp_string[namelen] = ' ';
375 memcpy (temp_string + namelen + 1, string, string_length + 1);
377 /* Don't import function names that are invalid identifiers from the
378 environment, though we still allow them to be defined as shell
380 if (absolute_program (tname) == 0 && (posixly_correct == 0 || legal_identifier (tname)))
381 parse_and_execute (temp_string, tname, SEVAL_NONINT|SEVAL_NOHIST|SEVAL_FUNCDEF|SEVAL_ONECMD);
383 if (temp_var = find_function (tname))
385 VSETATTR (temp_var, (att_exported|att_imported));
386 array_needs_making = 1;
390 if (temp_var = bind_variable (name, string, 0))
392 VSETATTR (temp_var, (att_exported | att_imported | att_invisible));
393 array_needs_making = 1;
395 last_command_exit_value = 1;
396 report_error (_("error importing function definition for `%s'"), tname);
399 /* Restore original suffix */
400 tname[namelen] = BASHFUNC_SUFFIX[0];
402 #if defined (ARRAY_VARS)
404 /* Array variables may not yet be exported. */
405 else if (*string == '(' && string[1] == '[' && string[strlen (string) - 1] == ')')
408 temp_string = extract_array_assignment_list (string, &string_length);
409 temp_var = assign_array_from_string (name, temp_string);
411 VSETATTR (temp_var, (att_exported | att_imported));
412 array_needs_making = 1;
414 # endif /* ARRAY_EXPORT */
417 else if (legal_identifier (name))
423 if (posixly_correct && STREQ (name, "SHELLOPTS"))
425 temp_var = find_variable ("SHELLOPTS");
426 ro = temp_var && readonly_p (temp_var);
428 VUNSETATTR (temp_var, att_readonly);
430 temp_var = bind_variable (name, string, 0);
433 if (legal_identifier (name))
434 VSETATTR (temp_var, (att_exported | att_imported));
436 VSETATTR (temp_var, (att_exported | att_imported | att_invisible));
438 VSETATTR (temp_var, att_readonly);
439 array_needs_making = 1;
443 name[char_index] = '=';
444 /* temp_var can be NULL if it was an exported function with a syntax
445 error (a different bug, but it still shouldn't dump core). */
446 if (temp_var && function_p (temp_var) == 0) /* XXX not yet */
448 CACHE_IMPORTSTR (temp_var, name);
454 /* Set up initial value of $_ */
455 temp_var = set_if_not ("_", dollar_vars[0]);
457 /* Remember this pid. */
458 dollar_dollar_pid = getpid ();
460 /* Now make our own defaults in case the vars that we think are
461 important are missing. */
462 temp_var = set_if_not ("PATH", DEFAULT_PATH_VALUE);
464 set_auto_export (temp_var); /* XXX */
467 temp_var = set_if_not ("TERM", "dumb");
469 set_auto_export (temp_var); /* XXX */
472 #if defined (__QNX__)
473 /* set node id -- don't import it from the environment */
476 # if defined (__QNXNTO__)
477 netmgr_ndtostr(ND2S_LOCAL_STR, ND_LOCAL_NODE, node_name, sizeof(node_name));
479 qnx_nidtostr (getnid (), node_name, sizeof (node_name));
481 temp_var = bind_variable ("NODE", node_name, 0);
482 set_auto_export (temp_var);
486 /* set up the prompts. */
487 if (interactive_shell)
489 #if defined (PROMPT_STRING_DECODE)
490 set_if_not ("PS1", primary_prompt);
492 if (current_user.uid == -1)
493 get_current_user_info ();
494 set_if_not ("PS1", current_user.euid == 0 ? "# " : primary_prompt);
496 set_if_not ("PS2", secondary_prompt);
498 set_if_not ("PS4", "+ ");
500 /* Don't allow IFS to be imported from the environment. */
501 temp_var = bind_variable ("IFS", " \t\n", 0);
504 /* Magic machine types. Pretty convenient. */
507 /* Default MAILCHECK for interactive shells. Defer the creation of a
508 default MAILPATH until the startup files are read, because MAIL
509 names a mail file if MAILPATH is not set, and we should provide a
510 default only if neither is set. */
511 if (interactive_shell)
513 temp_var = set_if_not ("MAILCHECK", posixly_correct ? "600" : "60");
514 VSETATTR (temp_var, att_integer);
517 /* Do some things with shell level. */
518 initialize_shell_level ();
522 /* Initialize the `getopts' stuff. */
523 temp_var = bind_variable ("OPTIND", "1", 0);
524 VSETATTR (temp_var, att_integer);
526 bind_variable ("OPTERR", "1", 0);
529 if (login_shell == 1 && posixly_correct == 0)
532 /* Get the full pathname to THIS shell, and set the BASH variable
534 name = get_bash_name ();
535 temp_var = bind_variable ("BASH", name, 0);
538 /* Make the exported environment variable SHELL be the user's login
539 shell. Note that the `tset' command looks at this variable
540 to determine what style of commands to output; if it ends in "csh",
541 then C-shell commands are output, else Bourne shell commands. */
544 /* Make a variable called BASH_VERSION which contains the version info. */
545 bind_variable ("BASH_VERSION", shell_version_string (), 0);
546 #if defined (ARRAY_VARS)
550 if (command_execution_string)
551 bind_variable ("BASH_EXECUTION_STRING", command_execution_string, 0);
553 /* Find out if we're supposed to be in Posix.2 mode via an
554 environment variable. */
555 temp_var = find_variable ("POSIXLY_CORRECT");
557 temp_var = find_variable ("POSIX_PEDANTIC");
558 if (temp_var && imported_p (temp_var))
559 sv_strict_posix (temp_var->name);
561 #if defined (HISTORY)
562 /* Set history variables to defaults, and then do whatever we would
563 do if the variable had just been set. Do this only in the case
564 that we are remembering commands on the history list. */
565 if (remember_on_history)
567 name = bash_tilde_expand (posixly_correct ? "~/.sh_history" : "~/.bash_history", 0);
569 set_if_not ("HISTFILE", name);
574 /* Seed the random number generator. */
577 /* Handle some "special" variables that we may have inherited from a
579 if (interactive_shell)
581 temp_var = find_variable ("IGNOREEOF");
583 temp_var = find_variable ("ignoreeof");
584 if (temp_var && imported_p (temp_var))
585 sv_ignoreeof (temp_var->name);
588 #if defined (HISTORY)
589 if (interactive_shell && remember_on_history)
591 sv_history_control ("HISTCONTROL");
592 sv_histignore ("HISTIGNORE");
593 sv_histtimefmt ("HISTTIMEFORMAT");
597 #if defined (READLINE) && defined (STRICT_POSIX)
598 /* POSIXLY_CORRECT will only be 1 here if the shell was compiled
600 if (interactive_shell && posixly_correct && no_line_editing == 0)
601 rl_prefer_env_winsize = 1;
602 #endif /* READLINE && STRICT_POSIX */
607 * I'm tired of the arguing and bug reports. Bash now leaves SSH_CLIENT
608 * and SSH2_CLIENT alone. I'm going to rely on the shell_level check in
609 * isnetconn() to avoid running the startup files more often than wanted.
610 * That will, of course, only work if the user's login shell is bash, so
611 * I've made that behavior conditional on SSH_SOURCE_BASHRC being defined
615 temp_var = find_variable ("SSH_CLIENT");
616 if (temp_var && imported_p (temp_var))
618 VUNSETATTR (temp_var, att_exported);
619 array_needs_making = 1;
621 temp_var = find_variable ("SSH2_CLIENT");
622 if (temp_var && imported_p (temp_var))
624 VUNSETATTR (temp_var, att_exported);
625 array_needs_making = 1;
629 /* Get the user's real and effective user ids. */
632 temp_var = find_variable ("BASH_XTRACEFD");
633 if (temp_var && imported_p (temp_var))
634 sv_xtracefd (temp_var->name);
636 /* Initialize the dynamic variables, and seed their values. */
637 initialize_dynamic_variables ();
640 /* **************************************************************** */
642 /* Setting values for special shell variables */
644 /* **************************************************************** */
651 temp_var = set_if_not ("HOSTTYPE", HOSTTYPE);
652 temp_var = set_if_not ("OSTYPE", OSTYPE);
653 temp_var = set_if_not ("MACHTYPE", MACHTYPE);
655 temp_var = set_if_not ("HOSTNAME", current_host_name);
658 /* Set $HOME to the information in the password file if we didn't get
659 it from the environment. */
661 /* This function is not static so the tilde and readline libraries can
666 if (current_user.home_dir == 0)
667 get_current_user_info ();
668 return current_user.home_dir;
676 temp_var = find_variable ("HOME");
678 temp_var = bind_variable ("HOME", sh_get_home_dir (), 0);
680 VSETATTR (temp_var, att_exported);
684 /* Set $SHELL to the user's login shell if it is not already set. Call
685 get_current_user_info if we haven't already fetched the shell. */
691 temp_var = find_variable ("SHELL");
694 if (current_user.shell == 0)
695 get_current_user_info ();
696 temp_var = bind_variable ("SHELL", current_user.shell, 0);
699 VSETATTR (temp_var, att_exported);
708 if ((login_shell == 1) && RELPATH(shell_name))
710 if (current_user.shell == 0)
711 get_current_user_info ();
712 name = savestring (current_user.shell);
714 else if (ABSPATH(shell_name))
715 name = savestring (shell_name);
716 else if (shell_name[0] == '.' && shell_name[1] == '/')
718 /* Fast path for common case. */
722 cdir = get_string_value ("PWD");
726 name = (char *)xmalloc (len + strlen (shell_name) + 1);
728 strcpy (name + len, shell_name + 1);
731 name = savestring (shell_name);
738 tname = find_user_command (shell_name);
742 /* Try the current directory. If there is not an executable
743 there, just punt and use the login shell. */
744 s = file_status (shell_name);
747 tname = make_absolute (shell_name, get_string_value ("PWD"));
748 if (*shell_name == '.')
750 name = sh_canonpath (tname, PATH_CHECKDOTDOT|PATH_CHECKEXISTS);
761 if (current_user.shell == 0)
762 get_current_user_info ();
763 name = savestring (current_user.shell);
768 name = full_pathname (tname);
777 adjust_shell_level (change)
780 char new_level[5], *old_SHLVL;
784 old_SHLVL = get_string_value ("SHLVL");
785 if (old_SHLVL == 0 || *old_SHLVL == '\0' || legal_number (old_SHLVL, &old_level) == 0)
788 shell_level = old_level + change;
791 else if (shell_level > 1000)
793 internal_warning (_("shell level (%d) too high, resetting to 1"), shell_level);
797 /* We don't need the full generality of itos here. */
798 if (shell_level < 10)
800 new_level[0] = shell_level + '0';
803 else if (shell_level < 100)
805 new_level[0] = (shell_level / 10) + '0';
806 new_level[1] = (shell_level % 10) + '0';
809 else if (shell_level < 1000)
811 new_level[0] = (shell_level / 100) + '0';
812 old_level = shell_level % 100;
813 new_level[1] = (old_level / 10) + '0';
814 new_level[2] = (old_level % 10) + '0';
818 temp_var = bind_variable ("SHLVL", new_level, 0);
819 set_auto_export (temp_var);
823 initialize_shell_level ()
825 adjust_shell_level (1);
828 /* If we got PWD from the environment, update our idea of the current
829 working directory. In any case, make sure that PWD exists before
830 checking it. It is possible for getcwd () to fail on shell startup,
831 and in that case, PWD would be undefined. If this is an interactive
832 login shell, see if $HOME is the current working directory, and if
833 that's not the same string as $PWD, set PWD=$HOME. */
838 SHELL_VAR *temp_var, *home_var;
839 char *temp_string, *home_string;
841 home_var = find_variable ("HOME");
842 home_string = home_var ? value_cell (home_var) : (char *)NULL;
844 temp_var = find_variable ("PWD");
845 if (temp_var && imported_p (temp_var) &&
846 (temp_string = value_cell (temp_var)) &&
847 same_file (temp_string, ".", (struct stat *)NULL, (struct stat *)NULL))
848 set_working_directory (temp_string);
849 else if (home_string && interactive_shell && login_shell &&
850 same_file (home_string, ".", (struct stat *)NULL, (struct stat *)NULL))
852 set_working_directory (home_string);
853 temp_var = bind_variable ("PWD", home_string, 0);
854 set_auto_export (temp_var);
858 temp_string = get_working_directory ("shell-init");
861 temp_var = bind_variable ("PWD", temp_string, 0);
862 set_auto_export (temp_var);
867 /* According to the Single Unix Specification, v2, $OLDPWD is an
868 `environment variable' and therefore should be auto-exported.
869 Make a dummy invisible variable for OLDPWD, and mark it as exported. */
870 temp_var = bind_variable ("OLDPWD", (char *)NULL, 0);
871 VSETATTR (temp_var, (att_exported | att_invisible));
874 /* Make a variable $PPID, which holds the pid of the shell's parent. */
878 char namebuf[INT_STRLEN_BOUND(pid_t) + 1], *name;
881 name = inttostr (getppid (), namebuf, sizeof(namebuf));
882 temp_var = find_variable ("PPID");
884 VUNSETATTR (temp_var, (att_readonly | att_exported));
885 temp_var = bind_variable ("PPID", name, 0);
886 VSETATTR (temp_var, (att_readonly | att_integer));
892 char buff[INT_STRLEN_BOUND(uid_t) + 1], *b;
893 register SHELL_VAR *v;
895 b = inttostr (current_user.uid, buff, sizeof (buff));
896 v = find_variable ("UID");
899 v = bind_variable ("UID", b, 0);
900 VSETATTR (v, (att_readonly | att_integer));
903 if (current_user.euid != current_user.uid)
904 b = inttostr (current_user.euid, buff, sizeof (buff));
906 v = find_variable ("EUID");
909 v = bind_variable ("EUID", b, 0);
910 VSETATTR (v, (att_readonly | att_integer));
914 #if defined (ARRAY_VARS)
920 char *s, d[32], b[INT_STRLEN_BOUND(int) + 1];
922 unbind_variable ("BASH_VERSINFO");
924 vv = make_new_array_variable ("BASH_VERSINFO");
925 av = array_cell (vv);
926 strcpy (d, dist_version);
930 array_insert (av, 0, d);
931 array_insert (av, 1, s);
932 s = inttostr (patch_level, b, sizeof (b));
933 array_insert (av, 2, s);
934 s = inttostr (build_version, b, sizeof (b));
935 array_insert (av, 3, s);
936 array_insert (av, 4, release_status);
937 array_insert (av, 5, MACHTYPE);
939 VSETATTR (vv, att_readonly);
941 #endif /* ARRAY_VARS */
943 /* Set the environment variables $LINES and $COLUMNS in response to
944 a window size change. */
946 sh_set_lines_and_columns (lines, cols)
949 char val[INT_STRLEN_BOUND(int) + 1], *v;
951 #if defined (READLINE)
952 /* If we are currently assigning to LINES or COLUMNS, don't do anything. */
953 if (winsize_assignment)
957 v = inttostr (lines, val, sizeof (val));
958 bind_variable ("LINES", v, 0);
960 v = inttostr (cols, val, sizeof (val));
961 bind_variable ("COLUMNS", v, 0);
964 /* **************************************************************** */
966 /* Printing variables and values */
968 /* **************************************************************** */
970 /* Print LIST (a list of shell variables) to stdout in such a way that
971 they can be read back in. */
973 print_var_list (list)
974 register SHELL_VAR **list;
977 register SHELL_VAR *var;
979 for (i = 0; list && (var = list[i]); i++)
980 if (invisible_p (var) == 0)
981 print_assignment (var);
984 /* Print LIST (a list of shell functions) to stdout in such a way that
985 they can be read back in. */
987 print_func_list (list)
988 register SHELL_VAR **list;
991 register SHELL_VAR *var;
993 for (i = 0; list && (var = list[i]); i++)
995 printf ("%s ", var->name);
996 print_var_function (var);
1001 /* Print the value of a single SHELL_VAR. No newline is
1002 output, but the variable is printed in such a way that
1003 it can be read back in. */
1005 print_assignment (var)
1008 if (var_isset (var) == 0)
1011 if (function_p (var))
1013 printf ("%s", var->name);
1014 print_var_function (var);
1017 #if defined (ARRAY_VARS)
1018 else if (array_p (var))
1019 print_array_assignment (var, 0);
1020 else if (assoc_p (var))
1021 print_assoc_assignment (var, 0);
1022 #endif /* ARRAY_VARS */
1025 printf ("%s=", var->name);
1026 print_var_value (var, 1);
1031 /* Print the value cell of VAR, a shell variable. Do not print
1032 the name, nor leading/trailing newline. If QUOTE is non-zero,
1033 and the value contains shell metacharacters, quote the value
1034 in such a way that it can be read back in. */
1036 print_var_value (var, quote)
1042 if (var_isset (var) == 0)
1045 if (quote && posixly_correct == 0 && ansic_shouldquote (value_cell (var)))
1047 t = ansic_quote (value_cell (var), 0, (int *)0);
1051 else if (quote && sh_contains_shell_metas (value_cell (var)))
1053 t = sh_single_quote (value_cell (var));
1058 printf ("%s", value_cell (var));
1061 /* Print the function cell of VAR, a shell variable. Do not
1062 print the name, nor leading/trailing newline. */
1064 print_var_function (var)
1069 if (function_p (var) && var_isset (var))
1071 x = named_function_string ((char *)NULL, function_cell(var), FUNC_MULTILINE|FUNC_EXTERNAL);
1076 /* **************************************************************** */
1078 /* Dynamic Variables */
1080 /* **************************************************************** */
1082 /* DYNAMIC VARIABLES
1084 These are variables whose values are generated anew each time they are
1085 referenced. These are implemented using a pair of function pointers
1086 in the struct variable: assign_func, which is called from bind_variable
1087 and, if arrays are compiled into the shell, some of the functions in
1088 arrayfunc.c, and dynamic_value, which is called from find_variable.
1090 assign_func is called from bind_variable_internal, if
1091 bind_variable_internal discovers that the variable being assigned to
1092 has such a function. The function is called as
1093 SHELL_VAR *temp = (*(entry->assign_func)) (entry, value, ind)
1094 and the (SHELL_VAR *)temp is returned as the value of bind_variable. It
1095 is usually ENTRY (self). IND is an index for an array variable, and
1098 dynamic_value is called from find_variable_internal to return a `new'
1099 value for the specified dynamic varible. If this function is NULL,
1100 the variable is treated as a `normal' shell variable. If it is not,
1101 however, then this function is called like this:
1102 tempvar = (*(var->dynamic_value)) (var);
1104 Sometimes `tempvar' will replace the value of `var'. Other times, the
1105 shell will simply use the string value. Pretty object-oriented, huh?
1107 Be warned, though: if you `unset' a special variable, it loses its
1108 special meaning, even if you subsequently set it.
1110 The special assignment code would probably have been better put in
1111 subst.c: do_assignment_internal, in the same style as
1112 stupidly_hack_special_variables, but I wanted the changes as
1113 localized as possible. */
1115 #define INIT_DYNAMIC_VAR(var, val, gfunc, afunc) \
1118 v = bind_variable (var, (val), 0); \
1119 v->dynamic_value = gfunc; \
1120 v->assign_func = afunc; \
1124 #define INIT_DYNAMIC_ARRAY_VAR(var, gfunc, afunc) \
1127 v = make_new_array_variable (var); \
1128 v->dynamic_value = gfunc; \
1129 v->assign_func = afunc; \
1133 #define INIT_DYNAMIC_ASSOC_VAR(var, gfunc, afunc) \
1136 v = make_new_assoc_variable (var); \
1137 v->dynamic_value = gfunc; \
1138 v->assign_func = afunc; \
1143 null_assign (self, value, unused, key)
1152 #if defined (ARRAY_VARS)
1154 null_array_assign (self, value, ind, key)
1164 /* Degenerate `dynamic_value' function; just returns what's passed without
1173 #if defined (ARRAY_VARS)
1174 /* A generic dynamic array variable initializer. Initialize array variable
1175 NAME with dynamic value function GETFUNC and assignment function SETFUNC. */
1177 init_dynamic_array_var (name, getfunc, setfunc, attrs)
1179 sh_var_value_func_t *getfunc;
1180 sh_var_assign_func_t *setfunc;
1185 v = find_variable (name);
1188 INIT_DYNAMIC_ARRAY_VAR (name, getfunc, setfunc);
1190 VSETATTR (v, attrs);
1195 init_dynamic_assoc_var (name, getfunc, setfunc, attrs)
1197 sh_var_value_func_t *getfunc;
1198 sh_var_assign_func_t *setfunc;
1203 v = find_variable (name);
1206 INIT_DYNAMIC_ASSOC_VAR (name, getfunc, setfunc);
1208 VSETATTR (v, attrs);
1213 /* The value of $SECONDS. This is the number of seconds since shell
1214 invocation, or, the number of seconds since the last assignment + the
1215 value of the last assignment. */
1216 static intmax_t seconds_value_assigned;
1219 assign_seconds (self, value, unused, key)
1225 if (legal_number (value, &seconds_value_assigned) == 0)
1226 seconds_value_assigned = 0;
1227 shell_start_time = NOW;
1235 time_t time_since_start;
1238 time_since_start = NOW - shell_start_time;
1239 p = itos(seconds_value_assigned + time_since_start);
1241 FREE (value_cell (var));
1243 VSETATTR (var, att_integer);
1244 var_setvalue (var, p);
1253 v = find_variable ("SECONDS");
1256 if (legal_number (value_cell(v), &seconds_value_assigned) == 0)
1257 seconds_value_assigned = 0;
1259 INIT_DYNAMIC_VAR ("SECONDS", (v ? value_cell (v) : (char *)NULL), get_seconds, assign_seconds);
1263 /* The random number seed. You can change this by setting RANDOM. */
1264 static unsigned long rseed = 1;
1265 static int last_random_value;
1266 static int seeded_subshell = 0;
1268 /* A linear congruential random number generator based on the example
1269 one in the ANSI C standard. This one isn't very good, but a more
1270 complicated one is overkill. */
1272 /* Returns a pseudo-random number between 0 and 32767. */
1276 /* From "Random number generators: good ones are hard to find",
1277 Park and Miller, Communications of the ACM, vol. 31, no. 10,
1278 October 1988, p. 1195. filtered through FreeBSD */
1281 /* Can't seed with 0. */
1286 rseed = 16807 * l - 2836 * h;
1289 rseed += 0x7fffffff;
1291 return ((unsigned int)(rseed & 32767)); /* was % 32768 */
1294 /* Set the random number generator seed to SEED. */
1300 last_random_value = 0;
1308 gettimeofday (&tv, NULL);
1309 sbrand (tv.tv_sec ^ tv.tv_usec ^ getpid ());
1313 assign_random (self, value, unused, key)
1319 sbrand (strtoul (value, (char **)NULL, 10));
1320 if (subshell_environment)
1321 seeded_subshell = getpid ();
1326 get_random_number ()
1330 /* Reset for command and process substitution. */
1332 if (subshell_environment && seeded_subshell != pid)
1335 seeded_subshell = pid;
1340 while (rv == last_random_value);
1351 rv = get_random_number ();
1352 last_random_value = rv;
1355 FREE (value_cell (var));
1357 VSETATTR (var, att_integer);
1358 var_setvalue (var, p);
1363 assign_lineno (var, value, unused, key)
1371 if (value == 0 || *value == '\0' || legal_number (value, &new_value) == 0)
1373 line_number = line_number_base = new_value;
1377 /* Function which returns the current line number. */
1385 ln = executing_line_number ();
1387 FREE (value_cell (var));
1388 var_setvalue (var, p);
1393 assign_subshell (var, value, unused, key)
1401 if (value == 0 || *value == '\0' || legal_number (value, &new_value) == 0)
1403 subshell_level = new_value;
1413 p = itos (subshell_level);
1414 FREE (value_cell (var));
1415 var_setvalue (var, p);
1429 FREE (value_cell (var));
1430 VSETATTR (var, att_integer|att_readonly);
1431 var_setvalue (var, p);
1436 get_bash_command (var)
1441 if (the_printed_command_except_trap)
1442 p = savestring (the_printed_command_except_trap);
1445 p = (char *)xmalloc (1);
1448 FREE (value_cell (var));
1449 var_setvalue (var, p);
1453 #if defined (HISTORY)
1460 p = itos (history_number ());
1461 FREE (value_cell (var));
1462 var_setvalue (var, p);
1467 #if defined (READLINE)
1468 /* When this function returns, VAR->value points to malloced memory. */
1470 get_comp_wordbreaks (var)
1473 /* If we don't have anything yet, assign a default value. */
1474 if (rl_completer_word_break_characters == 0 && bash_readline_initialized == 0)
1475 enable_hostname_completion (perform_hostname_completion);
1477 FREE (value_cell (var));
1478 var_setvalue (var, savestring (rl_completer_word_break_characters));
1483 /* When this function returns, rl_completer_word_break_characters points to
1486 assign_comp_wordbreaks (self, value, unused, key)
1492 if (rl_completer_word_break_characters &&
1493 rl_completer_word_break_characters != rl_basic_word_break_characters)
1494 free (rl_completer_word_break_characters);
1496 rl_completer_word_break_characters = savestring (value);
1499 #endif /* READLINE */
1501 #if defined (PUSHD_AND_POPD) && defined (ARRAY_VARS)
1503 assign_dirstack (self, value, ind, key)
1509 set_dirstack_element (ind, 1, value);
1520 l = get_directory_stack (0);
1521 a = array_from_word_list (l);
1522 array_dispose (array_cell (self));
1524 var_setarray (self, a);
1527 #endif /* PUSHD AND POPD && ARRAY_VARS */
1529 #if defined (ARRAY_VARS)
1530 /* We don't want to initialize the group set with a call to getgroups()
1531 unless we're asked to, but we only want to do it once. */
1539 static char **group_set = (char **)NULL;
1543 group_set = get_group_list (&ng);
1544 a = array_cell (self);
1545 for (i = 0; i < ng; i++)
1546 array_insert (a, i, group_set[i]);
1552 build_hashcmd (self)
1558 BUCKET_CONTENTS *item;
1560 h = assoc_cell (self);
1564 if (hashed_filenames == 0 || HASH_ENTRIES (hashed_filenames) == 0)
1566 var_setvalue (self, (char *)NULL);
1570 h = assoc_create (hashed_filenames->nbuckets);
1571 for (i = 0; i < hashed_filenames->nbuckets; i++)
1573 for (item = hash_items (i, hashed_filenames); item; item = item->next)
1575 k = savestring (item->key);
1576 v = pathdata(item)->path;
1577 assoc_insert (h, k, v);
1581 var_setvalue (self, (char *)h);
1589 build_hashcmd (self);
1594 assign_hashcmd (self, value, ind, key)
1600 phash_insert (key, value, 0, 0);
1601 return (build_hashcmd (self));
1606 build_aliasvar (self)
1612 BUCKET_CONTENTS *item;
1614 h = assoc_cell (self);
1618 if (aliases == 0 || HASH_ENTRIES (aliases) == 0)
1620 var_setvalue (self, (char *)NULL);
1624 h = assoc_create (aliases->nbuckets);
1625 for (i = 0; i < aliases->nbuckets; i++)
1627 for (item = hash_items (i, aliases); item; item = item->next)
1629 k = savestring (item->key);
1630 v = ((alias_t *)(item->data))->value;
1631 assoc_insert (h, k, v);
1635 var_setvalue (self, (char *)h);
1643 build_aliasvar (self);
1648 assign_aliasvar (self, value, ind, key)
1654 add_alias (key, value);
1655 return (build_aliasvar (self));
1659 #endif /* ARRAY_VARS */
1661 /* If ARRAY_VARS is not defined, this just returns the name of any
1662 currently-executing function. If we have arrays, it's a call stack. */
1667 #if ! defined (ARRAY_VARS)
1669 if (variable_context && this_shell_function)
1671 FREE (value_cell (self));
1672 t = savestring (this_shell_function->name);
1673 var_setvalue (self, t);
1680 make_funcname_visible (on_or_off)
1685 v = find_variable ("FUNCNAME");
1686 if (v == 0 || v->dynamic_value == 0)
1690 VUNSETATTR (v, att_invisible);
1692 VSETATTR (v, att_invisible);
1696 init_funcname_var ()
1700 v = find_variable ("FUNCNAME");
1703 #if defined (ARRAY_VARS)
1704 INIT_DYNAMIC_ARRAY_VAR ("FUNCNAME", get_funcname, null_array_assign);
1706 INIT_DYNAMIC_VAR ("FUNCNAME", (char *)NULL, get_funcname, null_assign);
1708 VSETATTR (v, att_invisible|att_noassign);
1713 initialize_dynamic_variables ()
1717 v = init_seconds_var ();
1719 INIT_DYNAMIC_VAR ("BASH_COMMAND", (char *)NULL, get_bash_command, (sh_var_assign_func_t *)NULL);
1720 INIT_DYNAMIC_VAR ("BASH_SUBSHELL", (char *)NULL, get_subshell, assign_subshell);
1722 INIT_DYNAMIC_VAR ("RANDOM", (char *)NULL, get_random, assign_random);
1723 VSETATTR (v, att_integer);
1724 INIT_DYNAMIC_VAR ("LINENO", (char *)NULL, get_lineno, assign_lineno);
1725 VSETATTR (v, att_integer);
1727 INIT_DYNAMIC_VAR ("BASHPID", (char *)NULL, get_bashpid, null_assign);
1728 VSETATTR (v, att_integer|att_readonly);
1730 #if defined (HISTORY)
1731 INIT_DYNAMIC_VAR ("HISTCMD", (char *)NULL, get_histcmd, (sh_var_assign_func_t *)NULL);
1732 VSETATTR (v, att_integer);
1735 #if defined (READLINE)
1736 INIT_DYNAMIC_VAR ("COMP_WORDBREAKS", (char *)NULL, get_comp_wordbreaks, assign_comp_wordbreaks);
1739 #if defined (PUSHD_AND_POPD) && defined (ARRAY_VARS)
1740 v = init_dynamic_array_var ("DIRSTACK", get_dirstack, assign_dirstack, 0);
1741 #endif /* PUSHD_AND_POPD && ARRAY_VARS */
1743 #if defined (ARRAY_VARS)
1744 v = init_dynamic_array_var ("GROUPS", get_groupset, null_array_assign, att_noassign);
1746 # if defined (DEBUGGER)
1747 v = init_dynamic_array_var ("BASH_ARGC", get_self, null_array_assign, att_noassign|att_nounset);
1748 v = init_dynamic_array_var ("BASH_ARGV", get_self, null_array_assign, att_noassign|att_nounset);
1749 # endif /* DEBUGGER */
1750 v = init_dynamic_array_var ("BASH_SOURCE", get_self, null_array_assign, att_noassign|att_nounset);
1751 v = init_dynamic_array_var ("BASH_LINENO", get_self, null_array_assign, att_noassign|att_nounset);
1753 v = init_dynamic_assoc_var ("BASH_CMDS", get_hashcmd, assign_hashcmd, att_nofree);
1754 # if defined (ALIAS)
1755 v = init_dynamic_assoc_var ("BASH_ALIASES", get_aliasvar, assign_aliasvar, att_nofree);
1759 v = init_funcname_var ();
1762 /* **************************************************************** */
1764 /* Retrieving variables and values */
1766 /* **************************************************************** */
1768 /* How to get a pointer to the shell variable or function named NAME.
1769 HASHED_VARS is a pointer to the hash table containing the list
1770 of interest (either variables or functions). */
1773 hash_lookup (name, hashed_vars)
1775 HASH_TABLE *hashed_vars;
1777 BUCKET_CONTENTS *bucket;
1779 bucket = hash_search (name, hashed_vars, 0);
1780 /* If we find the name in HASHED_VARS, set LAST_TABLE_SEARCHED to that
1783 last_table_searched = hashed_vars;
1784 return (bucket ? (SHELL_VAR *)bucket->data : (SHELL_VAR *)NULL);
1788 var_lookup (name, vcontext)
1790 VAR_CONTEXT *vcontext;
1795 v = (SHELL_VAR *)NULL;
1796 for (vc = vcontext; vc; vc = vc->down)
1797 if (v = hash_lookup (name, vc->table))
1803 /* Look up the variable entry named NAME. If SEARCH_TEMPENV is non-zero,
1804 then also search the temporarily built list of exported variables.
1805 The lookup order is:
1807 shell_variables list
1811 find_variable_internal (name, force_tempenv)
1819 var = (SHELL_VAR *)NULL;
1821 /* If explicitly requested, first look in the temporary environment for
1822 the variable. This allows constructs such as "foo=x eval 'echo $foo'"
1823 to get the `exported' value of $foo. This happens if we are executing
1824 a function or builtin, or if we are looking up a variable in a
1825 "subshell environment". */
1826 search_tempenv = force_tempenv || (expanding_redir == 0 && subshell_environment);
1828 if (search_tempenv && temporary_env)
1829 var = hash_lookup (name, temporary_env);
1831 vc = shell_variables;
1833 if (search_tempenv == 0 && /* (subshell_environment & SUBSHELL_COMSUB) && */
1835 (this_shell_builtin == eval_builtin || this_shell_builtin == command_builtin))
1837 itrace("find_variable_internal: search_tempenv == 0: skipping VC_BLTNENV");
1838 while (vc && (vc->flags & VC_BLTNENV))
1841 vc = shell_variables;
1846 var = var_lookup (name, vc);
1849 return ((SHELL_VAR *)NULL);
1851 return (var->dynamic_value ? (*(var->dynamic_value)) (var) : var);
1854 /* Look up and resolve the chain of nameref variables starting at V all the
1855 way to NULL or non-nameref. */
1857 find_variable_nameref (v)
1862 SHELL_VAR *orig, *oldv;
1866 while (v && nameref_p (v))
1869 if (level > NAMEREF_MAX)
1870 return ((SHELL_VAR *)0); /* error message here? */
1871 newname = nameref_cell (v);
1872 if (newname == 0 || *newname == '\0')
1873 return ((SHELL_VAR *)0);
1875 v = find_variable_internal (newname, (expanding_redir == 0 && (assigning_in_environment || executing_builtin)));
1876 if (v == orig || v == oldv)
1878 internal_warning (_("%s: circular name reference"), orig->name);
1879 return ((SHELL_VAR *)0);
1885 /* Resolve the chain of nameref variables for NAME. XXX - could change later */
1887 find_variable_last_nameref (name)
1894 nv = v = find_variable_noref (name);
1896 while (v && nameref_p (v))
1899 if (level > NAMEREF_MAX)
1900 return ((SHELL_VAR *)0); /* error message here? */
1901 newname = nameref_cell (v);
1902 if (newname == 0 || *newname == '\0')
1903 return ((SHELL_VAR *)0);
1905 v = find_variable_internal (newname, (expanding_redir == 0 && (assigning_in_environment || executing_builtin)));
1910 /* Resolve the chain of nameref variables for NAME. XXX - could change later */
1912 find_global_variable_last_nameref (name)
1919 nv = v = find_global_variable_noref (name);
1921 while (v && nameref_p (v))
1924 if (level > NAMEREF_MAX)
1925 return ((SHELL_VAR *)0); /* error message here? */
1926 newname = nameref_cell (v);
1927 if (newname == 0 || *newname == '\0')
1928 return ((SHELL_VAR *)0);
1930 v = find_global_variable_noref (newname);
1936 find_nameref_at_context (v, vc)
1940 SHELL_VAR *nv, *nv2;
1947 while (nv && nameref_p (nv))
1950 if (level > NAMEREF_MAX)
1951 return ((SHELL_VAR *)NULL);
1952 newname = nameref_cell (nv);
1953 if (newname == 0 || *newname == '\0')
1954 return ((SHELL_VAR *)NULL);
1955 nv2 = hash_lookup (newname, vc->table);
1963 /* Do nameref resolution from the VC, which is the local context for some
1964 function or builtin, `up' the chain to the global variables context. If
1965 NVCP is not NULL, return the variable context where we finally ended the
1966 nameref resolution (so the bind_variable_internal can use the correct
1967 variable context and hash table). */
1969 find_variable_nameref_context (v, vc, nvcp)
1974 SHELL_VAR *nv, *nv2;
1977 /* Look starting at the current context all the way `up' */
1978 for (nv = v, nvc = vc; nvc; nvc = nvc->down)
1980 nv2 = find_nameref_at_context (nv, nvc);
1986 if (nameref_p (nv) == 0)
1989 return (nameref_p (nv) ? (SHELL_VAR *)NULL : nv);
1992 /* Do nameref resolution from the VC, which is the local context for some
1993 function or builtin, `up' the chain to the global variables context. If
1994 NVCP is not NULL, return the variable context where we finally ended the
1995 nameref resolution (so the bind_variable_internal can use the correct
1996 variable context and hash table). */
1998 find_variable_last_nameref_context (v, vc, nvcp)
2003 SHELL_VAR *nv, *nv2;
2006 /* Look starting at the current context all the way `up' */
2007 for (nv = v, nvc = vc; nvc; nvc = nvc->down)
2009 nv2 = find_nameref_at_context (nv, nvc);
2016 return (nameref_p (nv) ? nv : (SHELL_VAR *)NULL);
2019 /* Find a variable, forcing a search of the temporary environment first */
2021 find_variable_tempenv (name)
2026 var = find_variable_internal (name, 1);
2027 if (var && nameref_p (var))
2028 var = find_variable_nameref (var);
2032 /* Find a variable, not forcing a search of the temporary environment first */
2034 find_variable_notempenv (name)
2039 var = find_variable_internal (name, 0);
2040 if (var && nameref_p (var))
2041 var = find_variable_nameref (var);
2046 find_global_variable (name)
2051 var = var_lookup (name, global_variables);
2052 if (var && nameref_p (var))
2053 var = find_variable_nameref (var);
2056 return ((SHELL_VAR *)NULL);
2058 return (var->dynamic_value ? (*(var->dynamic_value)) (var) : var);
2062 find_global_variable_noref (name)
2067 var = var_lookup (name, global_variables);
2070 return ((SHELL_VAR *)NULL);
2072 return (var->dynamic_value ? (*(var->dynamic_value)) (var) : var);
2076 find_shell_variable (name)
2081 var = var_lookup (name, shell_variables);
2082 if (var && nameref_p (var))
2083 var = find_variable_nameref (var);
2086 return ((SHELL_VAR *)NULL);
2088 return (var->dynamic_value ? (*(var->dynamic_value)) (var) : var);
2091 /* Look up the variable entry named NAME. Returns the entry or NULL. */
2093 find_variable (name)
2098 last_table_searched = 0;
2099 v = find_variable_internal (name, (expanding_redir == 0 && (assigning_in_environment || executing_builtin)));
2100 if (v && nameref_p (v))
2101 v = find_variable_nameref (v);
2106 find_variable_noref (name)
2111 v = find_variable_internal (name, (expanding_redir == 0 && (assigning_in_environment || executing_builtin)));
2115 /* Look up the function entry whose name matches STRING.
2116 Returns the entry or NULL. */
2118 find_function (name)
2121 return (hash_lookup (name, shell_functions));
2124 /* Find the function definition for the shell function named NAME. Returns
2125 the entry or NULL. */
2127 find_function_def (name)
2130 #if defined (DEBUGGER)
2131 return ((FUNCTION_DEF *)hash_lookup (name, shell_function_defs));
2133 return ((FUNCTION_DEF *)0);
2137 /* Return the value of VAR. VAR is assumed to have been the result of a
2138 lookup without any subscript, if arrays are compiled into the shell. */
2140 get_variable_value (var)
2144 return ((char *)NULL);
2145 #if defined (ARRAY_VARS)
2146 else if (array_p (var))
2147 return (array_reference (array_cell (var), 0));
2148 else if (assoc_p (var))
2149 return (assoc_reference (assoc_cell (var), "0"));
2152 return (value_cell (var));
2155 /* Return the string value of a variable. Return NULL if the variable
2156 doesn't exist. Don't cons a new string. This is a potential memory
2157 leak if the variable is found in the temporary environment. Since
2158 functions and variables have separate name spaces, returns NULL if
2159 var_name is a shell function only. */
2161 get_string_value (var_name)
2162 const char *var_name;
2166 var = find_variable (var_name);
2167 return ((var) ? get_variable_value (var) : (char *)NULL);
2170 /* This is present for use by the tilde and readline libraries. */
2172 sh_get_env_value (v)
2175 return get_string_value (v);
2178 /* **************************************************************** */
2180 /* Creating and setting variables */
2182 /* **************************************************************** */
2184 /* Set NAME to VALUE if NAME has no value. */
2186 set_if_not (name, value)
2191 if (shell_variables == 0)
2192 create_variable_tables ();
2194 v = find_variable (name);
2196 v = bind_variable_internal (name, value, global_variables->table, HASH_NOSRCH, 0);
2200 /* Create a local variable referenced by NAME. */
2202 make_local_variable (name)
2205 SHELL_VAR *new_var, *old_var;
2210 /* local foo; local foo; is a no-op. */
2211 old_var = find_variable (name);
2212 if (old_var && local_p (old_var) && old_var->context == variable_context)
2215 was_tmpvar = old_var && tempvar_p (old_var);
2216 /* If we're making a local variable in a shell function, the temporary env
2217 has already been merged into the function's variable context stack. We
2218 can assume that a temporary var in the same context appears in the same
2219 VAR_CONTEXT and can safely be returned without creating a new variable
2220 (which results in duplicate names in the same VAR_CONTEXT->table */
2221 /* We can't just test tmpvar_p because variables in the temporary env given
2222 to a shell function appear in the function's local variable VAR_CONTEXT
2223 but retain their tempvar attribute. We want temporary variables that are
2224 found in temporary_env, hence the test for last_table_searched, which is
2225 set in hash_lookup and only (so far) checked here. */
2226 if (was_tmpvar && old_var->context == variable_context && last_table_searched != temporary_env)
2228 VUNSETATTR (old_var, att_invisible);
2232 tmp_value = value_cell (old_var);
2234 for (vc = shell_variables; vc; vc = vc->down)
2235 if (vc_isfuncenv (vc) && vc->scope == variable_context)
2240 internal_error (_("make_local_variable: no function context at current scope"));
2241 return ((SHELL_VAR *)NULL);
2243 else if (vc->table == 0)
2244 vc->table = hash_create (TEMPENV_HASH_BUCKETS);
2246 /* Since this is called only from the local/declare/typeset code, we can
2247 call builtin_error here without worry (of course, it will also work
2248 for anything that sets this_command_name). Variables with the `noassign'
2249 attribute may not be made local. The test against old_var's context
2250 level is to disallow local copies of readonly global variables (since I
2251 believe that this could be a security hole). Readonly copies of calling
2252 function local variables are OK. */
2253 if (old_var && (noassign_p (old_var) ||
2254 (readonly_p (old_var) && old_var->context == 0)))
2256 if (readonly_p (old_var))
2258 else if (noassign_p (old_var))
2259 builtin_error (_("%s: variable may not be assigned value"), name);
2261 /* Let noassign variables through with a warning */
2262 if (readonly_p (old_var))
2264 return ((SHELL_VAR *)NULL);
2268 new_var = make_new_variable (name, vc->table);
2271 new_var = make_new_variable (name, vc->table);
2273 /* If we found this variable in one of the temporary environments,
2274 inherit its value. Watch to see if this causes problems with
2275 things like `x=4 local x'. XXX - see above for temporary env
2276 variables with the same context level as variable_context */
2277 /* XXX - we should only do this if the variable is not an array. */
2279 var_setvalue (new_var, savestring (tmp_value));
2281 new_var->attributes = exported_p (old_var) ? att_exported : 0;
2284 vc->flags |= VC_HASLOCAL;
2286 new_var->context = variable_context;
2287 VSETATTR (new_var, att_local);
2292 if (was_tmpvar == 0)
2293 VSETATTR (new_var, att_invisible); /* XXX */
2297 /* Create a new shell variable with name NAME. */
2299 new_shell_variable (name)
2304 entry = (SHELL_VAR *)xmalloc (sizeof (SHELL_VAR));
2306 entry->name = savestring (name);
2307 var_setvalue (entry, (char *)NULL);
2308 CLEAR_EXPORTSTR (entry);
2310 entry->dynamic_value = (sh_var_value_func_t *)NULL;
2311 entry->assign_func = (sh_var_assign_func_t *)NULL;
2313 entry->attributes = 0;
2315 /* Always assume variables are to be made at toplevel!
2316 make_local_variable has the responsibility of changing the
2317 variable context. */
2323 /* Create a new shell variable with name NAME and add it to the hash table
2326 make_new_variable (name, table)
2331 BUCKET_CONTENTS *elt;
2333 entry = new_shell_variable (name);
2335 /* Make sure we have a shell_variables hash table to add to. */
2336 if (shell_variables == 0)
2337 create_variable_tables ();
2339 elt = hash_insert (savestring (name), table, HASH_NOSRCH);
2340 elt->data = (PTR_T)entry;
2345 #if defined (ARRAY_VARS)
2347 make_new_array_variable (name)
2353 entry = make_new_variable (name, global_variables->table);
2354 array = array_create ();
2356 var_setarray (entry, array);
2357 VSETATTR (entry, att_array);
2362 make_local_array_variable (name, assoc_ok)
2369 var = make_local_variable (name);
2370 if (var == 0 || array_p (var) || (assoc_ok && assoc_p (var)))
2373 array = array_create ();
2375 dispose_variable_value (var);
2376 var_setarray (var, array);
2377 VSETATTR (var, att_array);
2382 make_new_assoc_variable (name)
2388 entry = make_new_variable (name, global_variables->table);
2389 hash = assoc_create (0);
2391 var_setassoc (entry, hash);
2392 VSETATTR (entry, att_assoc);
2397 make_local_assoc_variable (name)
2403 var = make_local_variable (name);
2404 if (var == 0 || assoc_p (var))
2407 dispose_variable_value (var);
2408 hash = assoc_create (0);
2410 var_setassoc (var, hash);
2411 VSETATTR (var, att_assoc);
2417 make_variable_value (var, value, flags)
2422 char *retval, *oval;
2423 intmax_t lval, rval;
2424 int expok, olen, op;
2426 /* If this variable has had its type set to integer (via `declare -i'),
2427 then do expression evaluation on it and store the result. The
2428 functions in expr.c (evalexp()) and bind_int_variable() are responsible
2429 for turning off the integer flag if they don't want further
2431 if (integer_p (var))
2433 if (flags & ASS_APPEND)
2435 oval = value_cell (var);
2436 lval = evalexp (oval, &expok); /* ksh93 seems to do this */
2439 top_level_cleanup ();
2440 jump_to_top_level (DISCARD);
2443 rval = evalexp (value, &expok);
2446 top_level_cleanup ();
2447 jump_to_top_level (DISCARD);
2449 /* This can be fooled if the variable's value changes while evaluating
2450 `rval'. We can change it if we move the evaluation of lval to here. */
2451 if (flags & ASS_APPEND)
2453 retval = itos (rval);
2455 #if defined (CASEMOD_ATTRS)
2456 else if (capcase_p (var) || uppercase_p (var) || lowercase_p (var))
2458 if (flags & ASS_APPEND)
2460 oval = get_variable_value (var);
2461 if (oval == 0) /* paranoia */
2463 olen = STRLEN (oval);
2464 retval = (char *)xmalloc (olen + (value ? STRLEN (value) : 0) + 1);
2465 strcpy (retval, oval);
2467 strcpy (retval+olen, value);
2470 retval = savestring (value);
2473 retval = (char *)xmalloc (1);
2476 op = capcase_p (var) ? CASE_CAPITALIZE
2477 : (uppercase_p (var) ? CASE_UPPER : CASE_LOWER);
2478 oval = sh_modcase (retval, (char *)0, op);
2482 #endif /* CASEMOD_ATTRS */
2485 if (flags & ASS_APPEND)
2487 oval = get_variable_value (var);
2488 if (oval == 0) /* paranoia */
2490 olen = STRLEN (oval);
2491 retval = (char *)xmalloc (olen + (value ? STRLEN (value) : 0) + 1);
2492 strcpy (retval, oval);
2494 strcpy (retval+olen, value);
2497 retval = savestring (value);
2500 retval = (char *)xmalloc (1);
2505 retval = (char *)NULL;
2510 /* Bind a variable NAME to VALUE in the HASH_TABLE TABLE, which may be the
2511 temporary environment (but usually is not). */
2513 bind_variable_internal (name, value, table, hflags, aflags)
2522 entry = (hflags & HASH_NOSRCH) ? (SHELL_VAR *)NULL : hash_lookup (name, table);
2523 /* Follow the nameref chain here if this is the global variables table */
2524 if (entry && nameref_p (entry) && (invisible_p (entry) == 0) && table == global_variables->table)
2526 entry = find_global_variable (entry->name);
2527 /* Let's see if we have a nameref referencing a variable that hasn't yet
2530 entry = find_variable_last_nameref (name); /* XXX */
2531 if (entry == 0) /* just in case */
2535 /* The first clause handles `declare -n ref; ref=x;' */
2536 if (entry && invisible_p (entry) && nameref_p (entry))
2538 else if (entry && nameref_p (entry))
2540 newval = nameref_cell (entry);
2541 #if defined (ARRAY_VARS)
2542 /* declare -n foo=x[2] */
2543 if (valid_array_reference (newval))
2544 /* XXX - should it be aflags? */
2545 entry = assign_array_element (newval, make_variable_value (entry, value, 0), aflags);
2549 entry = make_new_variable (newval, table);
2550 var_setvalue (entry, make_variable_value (entry, value, 0));
2553 else if (entry == 0)
2555 entry = make_new_variable (name, table);
2556 var_setvalue (entry, make_variable_value (entry, value, 0)); /* XXX */
2558 else if (entry->assign_func) /* array vars have assign functions now */
2560 INVALIDATE_EXPORTSTR (entry);
2561 newval = (aflags & ASS_APPEND) ? make_variable_value (entry, value, aflags) : value;
2562 if (assoc_p (entry))
2563 entry = (*(entry->assign_func)) (entry, newval, -1, savestring ("0"));
2564 else if (array_p (entry))
2565 entry = (*(entry->assign_func)) (entry, newval, 0, 0);
2567 entry = (*(entry->assign_func)) (entry, newval, -1, 0);
2568 if (newval != value)
2575 if (readonly_p (entry) || noassign_p (entry))
2577 if (readonly_p (entry))
2578 err_readonly (name);
2582 /* Variables which are bound are visible. */
2583 VUNSETATTR (entry, att_invisible);
2585 #if defined (ARRAY_VARS)
2586 if (assoc_p (entry) || array_p (entry))
2587 newval = make_array_variable_value (entry, 0, "0", value, aflags);
2591 newval = make_variable_value (entry, value, aflags); /* XXX */
2593 /* Invalidate any cached export string */
2594 INVALIDATE_EXPORTSTR (entry);
2596 #if defined (ARRAY_VARS)
2597 /* XXX -- this bears looking at again -- XXX */
2598 /* If an existing array variable x is being assigned to with x=b or
2599 `read x' or something of that nature, silently convert it to
2600 x[0]=b or `read x[0]'. */
2601 if (assoc_p (entry))
2603 assoc_insert (assoc_cell (entry), savestring ("0"), newval);
2606 else if (array_p (entry))
2608 array_insert (array_cell (entry), 0, newval);
2614 FREE (value_cell (entry));
2615 var_setvalue (entry, newval);
2619 if (mark_modified_vars)
2620 VSETATTR (entry, att_exported);
2622 if (exported_p (entry))
2623 array_needs_making = 1;
2628 /* Bind a variable NAME to VALUE. This conses up the name
2629 and value strings. If we have a temporary environment, we bind there
2630 first, then we bind into shell_variables. */
2633 bind_variable (name, value, flags)
2639 VAR_CONTEXT *vc, *nvc;
2642 if (shell_variables == 0)
2643 create_variable_tables ();
2645 /* If we have a temporary environment, look there first for the variable,
2646 and, if found, modify the value there before modifying it in the
2647 shell_variables table. This allows sourced scripts to modify values
2648 given to them in a temporary environment while modifying the variable
2649 value that the caller sees. */
2651 bind_tempenv_variable (name, value);
2653 /* XXX -- handle local variables here. */
2654 for (vc = shell_variables; vc; vc = vc->down)
2656 if (vc_isfuncenv (vc) || vc_isbltnenv (vc))
2658 v = hash_lookup (name, vc->table);
2660 if (v && nameref_p (v))
2662 nv = find_variable_nameref_context (v, vc, &nvc);
2665 nv = find_variable_last_nameref_context (v, vc, &nvc);
2666 if (nv && nameref_p (nv))
2668 /* If this nameref variable doesn't have a value yet,
2669 set the value. Otherwise, assign using the value as
2671 if (nameref_cell (nv) == 0)
2672 return (bind_variable_internal (nv->name, value, nvc->table, 0, flags));
2673 return (bind_variable_internal (nameref_cell (nv), value, nvc->table, 0, flags));
2682 return (bind_variable_internal (v->name, value, nvc->table, 0, flags));
2685 /* bind_variable_internal will handle nameref resolution in this case */
2686 return (bind_variable_internal (name, value, global_variables->table, 0, flags));
2690 bind_global_variable (name, value, flags)
2696 VAR_CONTEXT *vc, *nvc;
2699 if (shell_variables == 0)
2700 create_variable_tables ();
2702 /* bind_variable_internal will handle nameref resolution in this case */
2703 return (bind_variable_internal (name, value, global_variables->table, 0, flags));
2706 /* Make VAR, a simple shell variable, have value VALUE. Once assigned a
2707 value, variables are no longer invisible. This is a duplicate of part
2708 of the internals of bind_variable. If the variable is exported, or
2709 all modified variables should be exported, mark the variable for export
2710 and note that the export environment needs to be recreated. */
2712 bind_variable_value (var, value, aflags)
2720 invis = invisible_p (var);
2721 VUNSETATTR (var, att_invisible);
2723 if (var->assign_func)
2725 /* If we're appending, we need the old value, so use
2726 make_variable_value */
2727 t = (aflags & ASS_APPEND) ? make_variable_value (var, value, aflags) : value;
2728 (*(var->assign_func)) (var, t, -1, 0);
2729 if (t != value && t)
2734 t = make_variable_value (var, value, aflags);
2735 #if defined (ARRAY_VARS)
2736 if ((aflags & ASS_NAMEREF) && (t == 0 || *t == 0 || (legal_identifier (t) == 0 && valid_array_reference (t) == 0)))
2738 if ((aflags & ASS_NAMEREF) && (t == 0 || *t == 0 || legal_identifier (t) == 0))
2743 VSETATTR (var, att_invisible); /* XXX */
2744 return ((SHELL_VAR *)NULL);
2746 FREE (value_cell (var));
2747 var_setvalue (var, t);
2750 INVALIDATE_EXPORTSTR (var);
2752 if (mark_modified_vars)
2753 VSETATTR (var, att_exported);
2755 if (exported_p (var))
2756 array_needs_making = 1;
2761 /* Bind/create a shell variable with the name LHS to the RHS.
2762 This creates or modifies a variable such that it is an integer.
2764 This used to be in expr.c, but it is here so that all of the
2765 variable binding stuff is localized. Since we don't want any
2766 recursive evaluation from bind_variable() (possible without this code,
2767 since bind_variable() calls the evaluator for variables with the integer
2768 attribute set), we temporarily turn off the integer attribute for each
2769 variable we set here, then turn it back on after binding as necessary. */
2772 bind_int_variable (lhs, rhs)
2775 register SHELL_VAR *v;
2776 int isint, isarr, implicitarray;
2778 isint = isarr = implicitarray = 0;
2779 #if defined (ARRAY_VARS)
2780 if (valid_array_reference (lhs))
2783 v = array_variable_part (lhs, (char **)0, (int *)0);
2787 v = find_variable (lhs);
2791 isint = integer_p (v);
2792 VUNSETATTR (v, att_integer);
2793 #if defined (ARRAY_VARS)
2794 if (array_p (v) && isarr == 0)
2799 #if defined (ARRAY_VARS)
2801 v = assign_array_element (lhs, rhs, 0);
2802 else if (implicitarray)
2803 v = bind_array_variable (lhs, 0, rhs, 0);
2806 v = bind_variable (lhs, rhs, 0);
2809 VSETATTR (v, att_integer);
2811 VUNSETATTR (v, att_invisible);
2817 bind_var_to_int (var, val)
2821 char ibuf[INT_STRLEN_BOUND (intmax_t) + 1], *p;
2823 p = fmtulong (val, 10, ibuf, sizeof (ibuf), 0);
2824 return (bind_int_variable (var, p));
2827 /* Do a function binding to a variable. You pass the name and
2828 the command to bind to. This conses the name and command. */
2830 bind_function (name, value)
2836 entry = find_function (name);
2839 BUCKET_CONTENTS *elt;
2841 elt = hash_insert (savestring (name), shell_functions, HASH_NOSRCH);
2842 entry = new_shell_variable (name);
2843 elt->data = (PTR_T)entry;
2846 INVALIDATE_EXPORTSTR (entry);
2848 if (var_isset (entry))
2849 dispose_command (function_cell (entry));
2852 var_setfunc (entry, copy_command (value));
2854 var_setfunc (entry, 0);
2856 VSETATTR (entry, att_function);
2858 if (mark_modified_vars)
2859 VSETATTR (entry, att_exported);
2861 VUNSETATTR (entry, att_invisible); /* Just to be sure */
2863 if (exported_p (entry))
2864 array_needs_making = 1;
2866 #if defined (PROGRAMMABLE_COMPLETION)
2867 set_itemlist_dirty (&it_functions);
2873 #if defined (DEBUGGER)
2874 /* Bind a function definition, which includes source file and line number
2875 information in addition to the command, into the FUNCTION_DEF hash table.*/
2877 bind_function_def (name, value)
2879 FUNCTION_DEF *value;
2881 FUNCTION_DEF *entry;
2882 BUCKET_CONTENTS *elt;
2885 entry = find_function_def (name);
2888 dispose_function_def_contents (entry);
2889 entry = copy_function_def_contents (value, entry);
2893 cmd = value->command;
2895 entry = copy_function_def (value);
2896 value->command = cmd;
2898 elt = hash_insert (savestring (name), shell_function_defs, HASH_NOSRCH);
2899 elt->data = (PTR_T *)entry;
2902 #endif /* DEBUGGER */
2904 /* Add STRING, which is of the form foo=bar, to the temporary environment
2905 HASH_TABLE (temporary_env). The functions in execute_cmd.c are
2906 responsible for moving the main temporary env to one of the other
2907 temporary environments. The expansion code in subst.c calls this. */
2909 assign_in_env (word, flags)
2914 char *name, *temp, *value;
2918 string = word->word;
2921 offset = assignment (string, 0);
2922 name = savestring (string);
2923 value = (char *)NULL;
2925 if (name[offset] == '=')
2929 /* don't ignore the `+' when assigning temporary environment */
2930 if (name[offset - 1] == '+')
2932 name[offset - 1] = '\0';
2933 aflags |= ASS_APPEND;
2936 var = find_variable (name);
2937 if (var && (readonly_p (var) || noassign_p (var)))
2939 if (readonly_p (var))
2940 err_readonly (name);
2945 temp = name + offset + 1;
2946 value = expand_assignment_string_to_string (temp, 0);
2948 if (var && (aflags & ASS_APPEND))
2950 temp = make_variable_value (var, value, aflags);
2956 if (temporary_env == 0)
2957 temporary_env = hash_create (TEMPENV_HASH_BUCKETS);
2959 var = hash_lookup (name, temporary_env);
2961 var = make_new_variable (name, temporary_env);
2963 FREE (value_cell (var));
2967 value = (char *)xmalloc (1); /* like do_assignment_internal */
2971 var_setvalue (var, value);
2972 var->attributes |= (att_exported|att_tempvar);
2973 var->context = variable_context; /* XXX */
2975 INVALIDATE_EXPORTSTR (var);
2976 var->exportstr = mk_env_string (name, value, 0);
2978 array_needs_making = 1;
2981 stupidly_hack_special_variables (name);
2983 if (echo_command_at_execute)
2984 /* The Korn shell prints the `+ ' in front of assignment statements,
2986 xtrace_print_assignment (name, value, 0, 1);
2992 /* **************************************************************** */
2994 /* Copying variables */
2996 /* **************************************************************** */
2998 #ifdef INCLUDE_UNUSED
2999 /* Copy VAR to a new data structure and return that structure. */
3004 SHELL_VAR *copy = (SHELL_VAR *)NULL;
3008 copy = (SHELL_VAR *)xmalloc (sizeof (SHELL_VAR));
3010 copy->attributes = var->attributes;
3011 copy->name = savestring (var->name);
3013 if (function_p (var))
3014 var_setfunc (copy, copy_command (function_cell (var)));
3015 #if defined (ARRAY_VARS)
3016 else if (array_p (var))
3017 var_setarray (copy, array_copy (array_cell (var)));
3018 else if (assoc_p (var))
3019 var_setassoc (copy, assoc_copy (assoc_cell (var)));
3021 else if (nameref_cell (var)) /* XXX - nameref */
3022 var_setref (copy, savestring (nameref_cell (var)));
3023 else if (value_cell (var)) /* XXX - nameref */
3024 var_setvalue (copy, savestring (value_cell (var)));
3026 var_setvalue (copy, (char *)NULL);
3028 copy->dynamic_value = var->dynamic_value;
3029 copy->assign_func = var->assign_func;
3031 copy->exportstr = COPY_EXPORTSTR (var);
3033 copy->context = var->context;
3039 /* **************************************************************** */
3041 /* Deleting and unsetting variables */
3043 /* **************************************************************** */
3045 /* Dispose of the information attached to VAR. */
3047 dispose_variable_value (var)
3050 if (function_p (var))
3051 dispose_command (function_cell (var));
3052 #if defined (ARRAY_VARS)
3053 else if (array_p (var))
3054 array_dispose (array_cell (var));
3055 else if (assoc_p (var))
3056 assoc_dispose (assoc_cell (var));
3058 else if (nameref_p (var))
3059 FREE (nameref_cell (var));
3061 FREE (value_cell (var));
3065 dispose_variable (var)
3071 if (nofree_p (var) == 0)
3072 dispose_variable_value (var);
3074 FREE_EXPORTSTR (var);
3078 if (exported_p (var))
3079 array_needs_making = 1;
3084 /* Unset the shell variable referenced by NAME. Unsetting a nameref variable
3085 unsets the variable it resolves to but leaves the nameref alone. */
3087 unbind_variable (name)
3093 v = var_lookup (name, shell_variables);
3094 nv = (v && nameref_p (v)) ? find_variable_nameref (v) : (SHELL_VAR *)NULL;
3096 r = nv ? makunbound (nv->name, shell_variables) : makunbound (name, shell_variables);
3100 /* Unbind NAME, where NAME is assumed to be a nameref variable */
3102 unbind_nameref (name)
3107 v = var_lookup (name, shell_variables);
3108 if (v && nameref_p (v))
3109 return makunbound (name, shell_variables);
3113 /* Unset the shell function named NAME. */
3118 BUCKET_CONTENTS *elt;
3121 elt = hash_remove (name, shell_functions, 0);
3126 #if defined (PROGRAMMABLE_COMPLETION)
3127 set_itemlist_dirty (&it_functions);
3130 func = (SHELL_VAR *)elt->data;
3133 if (exported_p (func))
3134 array_needs_making++;
3135 dispose_variable (func);
3144 #if defined (DEBUGGER)
3146 unbind_function_def (name)
3149 BUCKET_CONTENTS *elt;
3150 FUNCTION_DEF *funcdef;
3152 elt = hash_remove (name, shell_function_defs, 0);
3157 funcdef = (FUNCTION_DEF *)elt->data;
3159 dispose_function_def (funcdef);
3166 #endif /* DEBUGGER */
3169 delete_var (name, vc)
3173 BUCKET_CONTENTS *elt;
3177 for (elt = (BUCKET_CONTENTS *)NULL, v = vc; v; v = v->down)
3178 if (elt = hash_remove (name, v->table, 0))
3184 old_var = (SHELL_VAR *)elt->data;
3188 dispose_variable (old_var);
3192 /* Make the variable associated with NAME go away. HASH_LIST is the
3193 hash table from which this variable should be deleted (either
3194 shell_variables or shell_functions).
3195 Returns non-zero if the variable couldn't be found. */
3197 makunbound (name, vc)
3201 BUCKET_CONTENTS *elt, *new_elt;
3206 for (elt = (BUCKET_CONTENTS *)NULL, v = vc; v; v = v->down)
3207 if (elt = hash_remove (name, v->table, 0))
3213 old_var = (SHELL_VAR *)elt->data;
3215 if (old_var && exported_p (old_var))
3216 array_needs_making++;
3218 /* If we're unsetting a local variable and we're still executing inside
3219 the function, just mark the variable as invisible. The function
3220 eventually called by pop_var_context() will clean it up later. This
3221 must be done so that if the variable is subsequently assigned a new
3222 value inside the function, the `local' attribute is still present.
3223 We also need to add it back into the correct hash table. */
3224 if (old_var && local_p (old_var) && variable_context == old_var->context)
3226 if (nofree_p (old_var))
3227 var_setvalue (old_var, (char *)NULL);
3228 #if defined (ARRAY_VARS)
3229 else if (array_p (old_var))
3230 array_dispose (array_cell (old_var));
3231 else if (assoc_p (old_var))
3232 assoc_dispose (assoc_cell (old_var));
3234 else if (nameref_p (old_var))
3235 FREE (nameref_cell (old_var));
3237 FREE (value_cell (old_var));
3238 /* Reset the attributes. Preserve the export attribute if the variable
3239 came from a temporary environment. Make sure it stays local, and
3240 make it invisible. */
3241 old_var->attributes = (exported_p (old_var) && tempvar_p (old_var)) ? att_exported : 0;
3242 VSETATTR (old_var, att_local);
3243 VSETATTR (old_var, att_invisible);
3244 var_setvalue (old_var, (char *)NULL);
3245 INVALIDATE_EXPORTSTR (old_var);
3247 new_elt = hash_insert (savestring (old_var->name), v->table, 0);
3248 new_elt->data = (PTR_T)old_var;
3249 stupidly_hack_special_variables (old_var->name);
3256 /* Have to save a copy of name here, because it might refer to
3257 old_var->name. If so, stupidly_hack_special_variables will
3258 reference freed memory. */
3259 t = savestring (name);
3264 dispose_variable (old_var);
3265 stupidly_hack_special_variables (t);
3271 /* Get rid of all of the variables in the current context. */
3273 kill_all_local_variables ()
3277 for (vc = shell_variables; vc; vc = vc->down)
3278 if (vc_isfuncenv (vc) && vc->scope == variable_context)
3283 if (vc->table && vc_haslocals (vc))
3285 delete_all_variables (vc->table);
3286 hash_dispose (vc->table);
3288 vc->table = (HASH_TABLE *)NULL;
3292 free_variable_hash_data (data)
3297 var = (SHELL_VAR *)data;
3298 dispose_variable (var);
3301 /* Delete the entire contents of the hash table. */
3303 delete_all_variables (hashed_vars)
3304 HASH_TABLE *hashed_vars;
3306 hash_flush (hashed_vars, free_variable_hash_data);
3309 /* **************************************************************** */
3311 /* Setting variable attributes */
3313 /* **************************************************************** */
3315 #define FIND_OR_MAKE_VARIABLE(name, entry) \
3318 entry = find_variable (name); \
3321 entry = bind_variable (name, "", 0); \
3322 if (!no_invisible_vars && entry) entry->attributes |= att_invisible; \
3327 /* Make the variable associated with NAME be readonly.
3328 If NAME does not exist yet, create it. */
3330 set_var_read_only (name)
3335 FIND_OR_MAKE_VARIABLE (name, entry);
3336 VSETATTR (entry, att_readonly);
3339 #ifdef INCLUDE_UNUSED
3340 /* Make the function associated with NAME be readonly.
3341 If NAME does not exist, we just punt, like auto_export code below. */
3343 set_func_read_only (name)
3348 entry = find_function (name);
3350 VSETATTR (entry, att_readonly);
3353 /* Make the variable associated with NAME be auto-exported.
3354 If NAME does not exist yet, create it. */
3356 set_var_auto_export (name)
3361 FIND_OR_MAKE_VARIABLE (name, entry);
3362 set_auto_export (entry);
3365 /* Make the function associated with NAME be auto-exported. */
3367 set_func_auto_export (name)
3372 entry = find_function (name);
3374 set_auto_export (entry);
3378 /* **************************************************************** */
3380 /* Creating lists of variables */
3382 /* **************************************************************** */
3385 vlist_alloc (nentries)
3390 vlist = (VARLIST *)xmalloc (sizeof (VARLIST));
3391 vlist->list = (SHELL_VAR **)xmalloc ((nentries + 1) * sizeof (SHELL_VAR *));
3392 vlist->list_size = nentries;
3393 vlist->list_len = 0;
3394 vlist->list[0] = (SHELL_VAR *)NULL;
3400 vlist_realloc (vlist, n)
3405 return (vlist = vlist_alloc (n));
3406 if (n > vlist->list_size)
3408 vlist->list_size = n;
3409 vlist->list = (SHELL_VAR **)xrealloc (vlist->list, (vlist->list_size + 1) * sizeof (SHELL_VAR *));
3415 vlist_add (vlist, var, flags)
3422 for (i = 0; i < vlist->list_len; i++)
3423 if (STREQ (var->name, vlist->list[i]->name))
3425 if (i < vlist->list_len)
3428 if (i >= vlist->list_size)
3429 vlist = vlist_realloc (vlist, vlist->list_size + 16);
3431 vlist->list[vlist->list_len++] = var;
3432 vlist->list[vlist->list_len] = (SHELL_VAR *)NULL;
3435 /* Map FUNCTION over the variables in VAR_HASH_TABLE. Return an array of the
3436 variables for which FUNCTION returns a non-zero value. A NULL value
3437 for FUNCTION means to use all variables. */
3439 map_over (function, vc)
3440 sh_var_map_func_t *function;
3448 for (nentries = 0, v = vc; v; v = v->down)
3449 nentries += HASH_ENTRIES (v->table);
3452 return (SHELL_VAR **)NULL;
3454 vlist = vlist_alloc (nentries);
3456 for (v = vc; v; v = v->down)
3457 flatten (v->table, function, vlist, 0);
3465 map_over_funcs (function)
3466 sh_var_map_func_t *function;
3471 if (shell_functions == 0 || HASH_ENTRIES (shell_functions) == 0)
3472 return ((SHELL_VAR **)NULL);
3474 vlist = vlist_alloc (HASH_ENTRIES (shell_functions));
3476 flatten (shell_functions, function, vlist, 0);
3483 /* Flatten VAR_HASH_TABLE, applying FUNC to each member and adding those
3484 elements for which FUNC succeeds to VLIST->list. FLAGS is reserved
3485 for future use. Only unique names are added to VLIST. If FUNC is
3486 NULL, each variable in VAR_HASH_TABLE is added to VLIST. If VLIST is
3487 NULL, FUNC is applied to each SHELL_VAR in VAR_HASH_TABLE. If VLIST
3488 and FUNC are both NULL, nothing happens. */
3490 flatten (var_hash_table, func, vlist, flags)
3491 HASH_TABLE *var_hash_table;
3492 sh_var_map_func_t *func;
3497 register BUCKET_CONTENTS *tlist;
3501 if (var_hash_table == 0 || (HASH_ENTRIES (var_hash_table) == 0) || (vlist == 0 && func == 0))
3504 for (i = 0; i < var_hash_table->nbuckets; i++)
3506 for (tlist = hash_items (i, var_hash_table); tlist; tlist = tlist->next)
3508 var = (SHELL_VAR *)tlist->data;
3510 r = func ? (*func) (var) : 1;
3512 vlist_add (vlist, var, flags);
3518 sort_variables (array)
3521 qsort (array, strvec_len ((char **)array), sizeof (SHELL_VAR *), (QSFUNC *)qsort_var_comp);
3525 qsort_var_comp (var1, var2)
3526 SHELL_VAR **var1, **var2;
3530 if ((result = (*var1)->name[0] - (*var2)->name[0]) == 0)
3531 result = strcmp ((*var1)->name, (*var2)->name);
3536 /* Apply FUNC to each variable in SHELL_VARIABLES, adding each one for
3537 which FUNC succeeds to an array of SHELL_VAR *s. Returns the array. */
3540 sh_var_map_func_t *func;
3544 list = map_over (func, shell_variables);
3545 if (list /* && posixly_correct */)
3546 sort_variables (list);
3550 /* Apply FUNC to each variable in SHELL_FUNCTIONS, adding each one for
3551 which FUNC succeeds to an array of SHELL_VAR *s. Returns the array. */
3554 sh_var_map_func_t *func;
3558 list = map_over_funcs (func);
3559 if (list /* && posixly_correct */)
3560 sort_variables (list);
3564 /* Create a NULL terminated array of all the shell variables. */
3566 all_shell_variables ()
3568 return (vapply ((sh_var_map_func_t *)NULL));
3571 /* Create a NULL terminated array of all the shell functions. */
3573 all_shell_functions ()
3575 return (fapply ((sh_var_map_func_t *)NULL));
3582 return (invisible_p (var) == 0);
3586 all_visible_functions ()
3588 return (fapply (visible_var));
3592 all_visible_variables ()
3594 return (vapply (visible_var));
3597 /* Return non-zero if the variable VAR is visible and exported. Array
3598 variables cannot be exported. */
3600 visible_and_exported (var)
3603 return (invisible_p (var) == 0 && exported_p (var));
3606 /* Candidate variables for the export environment are either valid variables
3607 with the export attribute or invalid variables inherited from the initial
3608 environment and simply passed through. */
3610 export_environment_candidate (var)
3613 return (exported_p (var) && (invisible_p (var) == 0 || imported_p (var)));
3616 /* Return non-zero if VAR is a local variable in the current context and
3619 local_and_exported (var)
3622 return (invisible_p (var) == 0 && local_p (var) && var->context == variable_context && exported_p (var));
3626 all_exported_variables ()
3628 return (vapply (visible_and_exported));
3632 local_exported_variables ()
3634 return (vapply (local_and_exported));
3638 variable_in_context (var)
3641 return (invisible_p (var) == 0 && local_p (var) && var->context == variable_context);
3645 all_local_variables ()
3651 vc = shell_variables;
3652 for (vc = shell_variables; vc; vc = vc->down)
3653 if (vc_isfuncenv (vc) && vc->scope == variable_context)
3658 internal_error (_("all_local_variables: no function context at current scope"));
3659 return (SHELL_VAR **)NULL;
3661 if (vc->table == 0 || HASH_ENTRIES (vc->table) == 0 || vc_haslocals (vc) == 0)
3662 return (SHELL_VAR **)NULL;
3664 vlist = vlist_alloc (HASH_ENTRIES (vc->table));
3666 flatten (vc->table, variable_in_context, vlist, 0);
3671 sort_variables (ret);
3675 #if defined (ARRAY_VARS)
3676 /* Return non-zero if the variable VAR is visible and an array. */
3678 visible_array_vars (var)
3681 return (invisible_p (var) == 0 && array_p (var));
3685 all_array_variables ()
3687 return (vapply (visible_array_vars));
3689 #endif /* ARRAY_VARS */
3692 all_variables_matching_prefix (prefix)
3695 SHELL_VAR **varlist;
3697 int vind, rind, plen;
3699 plen = STRLEN (prefix);
3700 varlist = all_visible_variables ();
3701 for (vind = 0; varlist && varlist[vind]; vind++)
3703 if (varlist == 0 || vind == 0)
3704 return ((char **)NULL);
3705 rlist = strvec_create (vind + 1);
3706 for (vind = rind = 0; varlist[vind]; vind++)
3708 if (plen == 0 || STREQN (prefix, varlist[vind]->name, plen))
3709 rlist[rind++] = savestring (varlist[vind]->name);
3711 rlist[rind] = (char *)0;
3717 /* **************************************************************** */
3719 /* Managing temporary variable scopes */
3721 /* **************************************************************** */
3723 /* Make variable NAME have VALUE in the temporary environment. */
3725 bind_tempenv_variable (name, value)
3731 var = temporary_env ? hash_lookup (name, temporary_env) : (SHELL_VAR *)NULL;
3735 FREE (value_cell (var));
3736 var_setvalue (var, savestring (value));
3737 INVALIDATE_EXPORTSTR (var);
3743 /* Find a variable in the temporary environment that is named NAME.
3744 Return the SHELL_VAR *, or NULL if not found. */
3746 find_tempenv_variable (name)
3749 return (temporary_env ? hash_lookup (name, temporary_env) : (SHELL_VAR *)NULL);
3752 char **tempvar_list;
3755 /* Push the variable described by (SHELL_VAR *)DATA down to the next
3756 variable context from the temporary environment. */
3758 push_temp_var (data)
3762 HASH_TABLE *binding_table;
3764 var = (SHELL_VAR *)data;
3766 binding_table = shell_variables->table;
3767 if (binding_table == 0)
3769 if (shell_variables == global_variables)
3770 /* shouldn't happen */
3771 binding_table = shell_variables->table = global_variables->table = hash_create (0);
3773 binding_table = shell_variables->table = hash_create (TEMPENV_HASH_BUCKETS);
3776 v = bind_variable_internal (var->name, value_cell (var), binding_table, 0, 0);
3778 /* XXX - should we set the context here? It shouldn't matter because of how
3779 assign_in_env works, but might want to check. */
3780 if (binding_table == global_variables->table) /* XXX */
3781 var->attributes &= ~(att_tempvar|att_propagate);
3784 var->attributes |= att_propagate;
3785 if (binding_table == shell_variables->table)
3786 shell_variables->flags |= VC_HASTMPVAR;
3788 v->attributes |= var->attributes;
3790 if (find_special_var (var->name) >= 0)
3791 tempvar_list[tvlist_ind++] = savestring (var->name);
3793 dispose_variable (var);
3797 propagate_temp_var (data)
3802 var = (SHELL_VAR *)data;
3803 if (tempvar_p (var) && (var->attributes & att_propagate))
3804 push_temp_var (data);
3807 if (find_special_var (var->name) >= 0)
3808 tempvar_list[tvlist_ind++] = savestring (var->name);
3809 dispose_variable (var);
3813 /* Free the storage used in the hash table for temporary
3814 environment variables. PUSHF is a function to be called
3815 to free each hash table entry. It takes care of pushing variables
3816 to previous scopes if appropriate. PUSHF stores names of variables
3817 that require special handling (e.g., IFS) on tempvar_list, so this
3818 function can call stupidly_hack_special_variables on all the
3819 variables in the list when the temporary hash table is destroyed. */
3821 dispose_temporary_env (pushf)
3822 sh_free_func_t *pushf;
3826 tempvar_list = strvec_create (HASH_ENTRIES (temporary_env) + 1);
3827 tempvar_list[tvlist_ind = 0] = 0;
3829 hash_flush (temporary_env, pushf);
3830 hash_dispose (temporary_env);
3831 temporary_env = (HASH_TABLE *)NULL;
3833 tempvar_list[tvlist_ind] = 0;
3835 array_needs_making = 1;
3838 sv_ifs ("IFS"); /* XXX here for now -- check setifs in assign_in_env */
3840 for (i = 0; i < tvlist_ind; i++)
3841 stupidly_hack_special_variables (tempvar_list[i]);
3843 strvec_dispose (tempvar_list);
3849 dispose_used_env_vars ()
3853 dispose_temporary_env (propagate_temp_var);
3854 maybe_make_export_env ();
3858 /* Take all of the shell variables in the temporary environment HASH_TABLE
3859 and make shell variables from them at the current variable context. */
3861 merge_temporary_env ()
3864 dispose_temporary_env (push_temp_var);
3867 /* **************************************************************** */
3869 /* Creating and manipulating the environment */
3871 /* **************************************************************** */
3873 static inline char *
3874 mk_env_string (name, value, isfunc)
3875 const char *name, *value;
3878 size_t name_len, value_len;
3881 name_len = strlen (name);
3882 value_len = STRLEN (value);
3884 /* If we are exporting a shell function, construct the encoded function
3886 if (isfunc && value)
3888 p = (char *)xmalloc (BASHFUNC_PREFLEN + name_len + BASHFUNC_SUFFLEN + value_len + 2);
3890 memcpy (q, BASHFUNC_PREFIX, BASHFUNC_PREFLEN);
3891 q += BASHFUNC_PREFLEN;
3892 memcpy (q, name, name_len);
3894 memcpy (q, BASHFUNC_SUFFIX, BASHFUNC_SUFFLEN);
3895 q += BASHFUNC_SUFFLEN;
3899 p = (char *)xmalloc (2 + name_len + value_len);
3900 memcpy (p, name, name_len);
3905 if (value && *value)
3906 memcpy (q + 1, value, value_len + 1);
3924 internal_error (_("%s has null exportstr"), v->name);
3927 if (legal_variable_starter ((unsigned char)*s) == 0)
3929 internal_error (_("invalid character %d in exportstr for %s"), *s, v->name);
3932 for (s = v->exportstr + 1; s && *s; s++)
3936 if (legal_variable_char ((unsigned char)*s) == 0)
3938 internal_error (_("invalid character %d in exportstr for %s"), *s, v->name);
3944 internal_error (_("no `=' in exportstr for %s"), v->name);
3952 make_env_array_from_var_list (vars)
3955 register int i, list_index;
3956 register SHELL_VAR *var;
3957 char **list, *value;
3959 list = strvec_create ((1 + strvec_len ((char **)vars)));
3961 #define USE_EXPORTSTR (value == var->exportstr)
3963 for (i = 0, list_index = 0; var = vars[i]; i++)
3965 #if defined (__CYGWIN__)
3966 /* We don't use the exportstr stuff on Cygwin at all. */
3967 INVALIDATE_EXPORTSTR (var);
3970 value = var->exportstr;
3971 else if (function_p (var))
3972 value = named_function_string ((char *)NULL, function_cell (var), 0);
3973 #if defined (ARRAY_VARS)
3974 else if (array_p (var))
3976 value = array_to_assignment_string (array_cell (var));
3978 continue; /* XXX array vars cannot yet be exported */
3979 # endif /* ARRAY_EXPORT */
3980 else if (assoc_p (var))
3982 value = assoc_to_assignment_string (assoc_cell (var));
3984 continue; /* XXX associative array vars cannot yet be exported */
3988 value = value_cell (var);
3992 /* Gee, I'd like to get away with not using savestring() if we're
3993 using the cached exportstr... */
3994 list[list_index] = USE_EXPORTSTR ? savestring (value)
3995 : mk_env_string (var->name, value, function_p (var));
3997 if (USE_EXPORTSTR == 0)
3998 SAVE_EXPORTSTR (var, list[list_index]);
4001 #undef USE_EXPORTSTR
4004 #if defined (ARRAY_VARS)
4005 if (array_p (var) || assoc_p (var))
4012 list[list_index] = (char *)NULL;
4016 /* Make an array of assignment statements from the hash table
4017 HASHED_VARS which contains SHELL_VARs. Only visible, exported
4018 variables are eligible. */
4020 make_var_export_array (vcxt)
4027 vars = map_over (visible_and_exported, vcxt);
4029 vars = map_over (export_environment_candidate, vcxt);
4033 return (char **)NULL;
4035 list = make_env_array_from_var_list (vars);
4042 make_func_export_array ()
4047 vars = map_over_funcs (visible_and_exported);
4049 return (char **)NULL;
4051 list = make_env_array_from_var_list (vars);
4057 /* Add ENVSTR to the end of the exported environment, EXPORT_ENV. */
4058 #define add_to_export_env(envstr,do_alloc) \
4061 if (export_env_index >= (export_env_size - 1)) \
4063 export_env_size += 16; \
4064 export_env = strvec_resize (export_env, export_env_size); \
4065 environ = export_env; \
4067 export_env[export_env_index++] = (do_alloc) ? savestring (envstr) : envstr; \
4068 export_env[export_env_index] = (char *)NULL; \
4071 /* Add ASSIGN to EXPORT_ENV, or supercede a previous assignment in the
4072 array with the same left-hand side. Return the new EXPORT_ENV. */
4074 add_or_supercede_exported_var (assign, do_alloc)
4081 equal_offset = assignment (assign, 0);
4082 if (equal_offset == 0)
4083 return (export_env);
4085 /* If this is a function, then only supersede the function definition.
4086 We do this by including the `=() {' in the comparison, like
4087 initialize_shell_variables does. */
4088 if (assign[equal_offset + 1] == '(' &&
4089 strncmp (assign + equal_offset + 2, ") {", 3) == 0) /* } */
4092 for (i = 0; i < export_env_index; i++)
4094 if (STREQN (assign, export_env[i], equal_offset + 1))
4096 free (export_env[i]);
4097 export_env[i] = do_alloc ? savestring (assign) : assign;
4098 return (export_env);
4101 add_to_export_env (assign, do_alloc);
4102 return (export_env);
4106 add_temp_array_to_env (temp_array, do_alloc, do_supercede)
4108 int do_alloc, do_supercede;
4112 if (temp_array == 0)
4115 for (i = 0; temp_array[i]; i++)
4118 export_env = add_or_supercede_exported_var (temp_array[i], do_alloc);
4120 add_to_export_env (temp_array[i], do_alloc);
4126 /* Make the environment array for the command about to be executed, if the
4127 array needs making. Otherwise, do nothing. If a shell action could
4128 change the array that commands receive for their environment, then the
4129 code should `array_needs_making++'.
4131 The order to add to the array is:
4133 list of var contexts whose head is shell_variables
4136 This is the shell variable lookup order. We add only new variable
4137 names at each step, which allows local variables and variables in
4138 the temporary environments to shadow variables in the global (or
4139 any previous) scope.
4143 n_shell_variables ()
4148 for (n = 0, vc = shell_variables; vc; vc = vc->down)
4149 n += HASH_ENTRIES (vc->table);
4159 v = find_variable (name);
4160 if (v && exported_p (v))
4162 array_needs_making = 1;
4163 maybe_make_export_env ();
4170 maybe_make_export_env ()
4172 register char **temp_array;
4176 if (array_needs_making)
4179 strvec_flush (export_env);
4181 /* Make a guess based on how many shell variables and functions we
4182 have. Since there will always be array variables, and array
4183 variables are not (yet) exported, this will always be big enough
4184 for the exported variables and functions. */
4185 new_size = n_shell_variables () + HASH_ENTRIES (shell_functions) + 1 +
4186 HASH_ENTRIES (temporary_env);
4187 if (new_size > export_env_size)
4189 export_env_size = new_size;
4190 export_env = strvec_resize (export_env, export_env_size);
4191 environ = export_env;
4193 export_env[export_env_index = 0] = (char *)NULL;
4195 /* Make a dummy variable context from the temporary_env, stick it on
4196 the front of shell_variables, call make_var_export_array on the
4197 whole thing to flatten it, and convert the list of SHELL_VAR *s
4198 to the form needed by the environment. */
4201 tcxt = new_var_context ((char *)NULL, 0);
4202 tcxt->table = temporary_env;
4203 tcxt->down = shell_variables;
4206 tcxt = shell_variables;
4208 temp_array = make_var_export_array (tcxt);
4210 add_temp_array_to_env (temp_array, 0, 0);
4212 if (tcxt != shell_variables)
4215 #if defined (RESTRICTED_SHELL)
4216 /* Restricted shells may not export shell functions. */
4217 temp_array = restricted ? (char **)0 : make_func_export_array ();
4219 temp_array = make_func_export_array ();
4222 add_temp_array_to_env (temp_array, 0, 0);
4224 array_needs_making = 0;
4228 /* This is an efficiency hack. PWD and OLDPWD are auto-exported, so
4229 we will need to remake the exported environment every time we
4230 change directories. `_' is always put into the environment for
4231 every external command, so without special treatment it will always
4232 cause the environment to be remade.
4234 If there is no other reason to make the exported environment, we can
4235 just update the variables in place and mark the exported environment
4236 as no longer needing a remake. */
4238 update_export_env_inplace (env_prefix, preflen, value)
4245 evar = (char *)xmalloc (STRLEN (value) + preflen + 1);
4246 strcpy (evar, env_prefix);
4248 strcpy (evar + preflen, value);
4249 export_env = add_or_supercede_exported_var (evar, 0);
4252 /* We always put _ in the environment as the name of this command. */
4254 put_command_name_into_env (command_name)
4257 update_export_env_inplace ("_=", 2, command_name);
4260 /* **************************************************************** */
4262 /* Managing variable contexts */
4264 /* **************************************************************** */
4266 /* Allocate and return a new variable context with NAME and FLAGS.
4267 NAME can be NULL. */
4270 new_var_context (name, flags)
4276 vc = (VAR_CONTEXT *)xmalloc (sizeof (VAR_CONTEXT));
4277 vc->name = name ? savestring (name) : (char *)NULL;
4278 vc->scope = variable_context;
4281 vc->up = vc->down = (VAR_CONTEXT *)NULL;
4282 vc->table = (HASH_TABLE *)NULL;
4287 /* Free a variable context and its data, including the hash table. Dispose
4288 all of the variables. */
4290 dispose_var_context (vc)
4297 delete_all_variables (vc->table);
4298 hash_dispose (vc->table);
4304 /* Set VAR's scope level to the current variable context. */
4309 return (var->context = variable_context);
4312 /* Make a new variable context with NAME and FLAGS and a HASH_TABLE of
4313 temporary variables, and push it onto shell_variables. This is
4314 for shell functions. */
4316 push_var_context (name, flags, tempvars)
4319 HASH_TABLE *tempvars;
4323 vc = new_var_context (name, flags);
4324 vc->table = tempvars;
4327 /* Have to do this because the temp environment was created before
4328 variable_context was incremented. */
4329 flatten (tempvars, set_context, (VARLIST *)NULL, 0);
4330 vc->flags |= VC_HASTMPVAR;
4332 vc->down = shell_variables;
4333 shell_variables->up = vc;
4335 return (shell_variables = vc);
4339 push_func_var (data)
4344 var = (SHELL_VAR *)data;
4346 if (tempvar_p (var) && (posixly_correct || (var->attributes & att_propagate)))
4348 /* Make sure we have a hash table to store the variable in while it is
4349 being propagated down to the global variables table. Create one if
4351 if ((vc_isfuncenv (shell_variables) || vc_istempenv (shell_variables)) && shell_variables->table == 0)
4352 shell_variables->table = hash_create (0);
4353 /* XXX - should we set v->context here? */
4354 v = bind_variable_internal (var->name, value_cell (var), shell_variables->table, 0, 0);
4355 if (shell_variables == global_variables)
4356 var->attributes &= ~(att_tempvar|att_propagate);
4358 shell_variables->flags |= VC_HASTMPVAR;
4359 v->attributes |= var->attributes;
4362 stupidly_hack_special_variables (var->name); /* XXX */
4364 dispose_variable (var);
4367 /* Pop the top context off of VCXT and dispose of it, returning the rest of
4372 VAR_CONTEXT *ret, *vcxt;
4374 vcxt = shell_variables;
4375 if (vc_isfuncenv (vcxt) == 0)
4377 internal_error (_("pop_var_context: head of shell_variables not a function context"));
4381 if (ret = vcxt->down)
4383 ret->up = (VAR_CONTEXT *)NULL;
4384 shell_variables = ret;
4386 hash_flush (vcxt->table, push_func_var);
4387 dispose_var_context (vcxt);
4390 internal_error (_("pop_var_context: no global_variables context"));
4393 /* Delete the HASH_TABLEs for all variable contexts beginning at VCXT, and
4394 all of the VAR_CONTEXTs except GLOBAL_VARIABLES. */
4396 delete_all_contexts (vcxt)
4401 for (v = vcxt; v != global_variables; v = t)
4404 dispose_var_context (v);
4407 delete_all_variables (global_variables->table);
4408 shell_variables = global_variables;
4411 /* **************************************************************** */
4413 /* Pushing and Popping temporary variable scopes */
4415 /* **************************************************************** */
4418 push_scope (flags, tmpvars)
4420 HASH_TABLE *tmpvars;
4422 return (push_var_context ((char *)NULL, flags, tmpvars));
4426 push_exported_var (data)
4431 var = (SHELL_VAR *)data;
4433 /* If a temp var had its export attribute set, or it's marked to be
4434 propagated, bind it in the previous scope before disposing it. */
4435 /* XXX - This isn't exactly right, because all tempenv variables have the
4436 export attribute set. */
4438 if (exported_p (var) || (var->attributes & att_propagate))
4440 if (tempvar_p (var) && exported_p (var) && (var->attributes & att_propagate))
4443 var->attributes &= ~att_tempvar; /* XXX */
4444 v = bind_variable_internal (var->name, value_cell (var), shell_variables->table, 0, 0);
4445 if (shell_variables == global_variables)
4446 var->attributes &= ~att_propagate;
4447 v->attributes |= var->attributes;
4450 stupidly_hack_special_variables (var->name); /* XXX */
4452 dispose_variable (var);
4456 pop_scope (is_special)
4459 VAR_CONTEXT *vcxt, *ret;
4461 vcxt = shell_variables;
4462 if (vc_istempscope (vcxt) == 0)
4464 internal_error (_("pop_scope: head of shell_variables not a temporary environment scope"));
4470 ret->up = (VAR_CONTEXT *)NULL;
4472 shell_variables = ret;
4474 /* Now we can take care of merging variables in VCXT into set of scopes
4475 whose head is RET (shell_variables). */
4480 hash_flush (vcxt->table, push_func_var);
4482 hash_flush (vcxt->table, push_exported_var);
4483 hash_dispose (vcxt->table);
4487 sv_ifs ("IFS"); /* XXX here for now */
4490 /* **************************************************************** */
4492 /* Pushing and Popping function contexts */
4494 /* **************************************************************** */
4496 static WORD_LIST **dollar_arg_stack = (WORD_LIST **)NULL;
4497 static int dollar_arg_stack_slots;
4498 static int dollar_arg_stack_index;
4500 /* XXX - we might want to consider pushing and popping the `getopts' state
4501 when we modify the positional parameters. */
4503 push_context (name, is_subshell, tempvars)
4504 char *name; /* function name */
4506 HASH_TABLE *tempvars;
4508 if (is_subshell == 0)
4509 push_dollar_vars ();
4511 push_var_context (name, VC_FUNCENV, tempvars);
4514 /* Only called when subshell == 0, so we don't need to check, and can
4515 unconditionally pop the dollar vars off the stack. */
4523 sv_ifs ("IFS"); /* XXX here for now */
4526 /* Save the existing positional parameters on a stack. */
4530 if (dollar_arg_stack_index + 2 > dollar_arg_stack_slots)
4532 dollar_arg_stack = (WORD_LIST **)
4533 xrealloc (dollar_arg_stack, (dollar_arg_stack_slots += 10)
4534 * sizeof (WORD_LIST *));
4536 dollar_arg_stack[dollar_arg_stack_index++] = list_rest_of_args ();
4537 dollar_arg_stack[dollar_arg_stack_index] = (WORD_LIST *)NULL;
4540 /* Restore the positional parameters from our stack. */
4544 if (!dollar_arg_stack || dollar_arg_stack_index == 0)
4547 remember_args (dollar_arg_stack[--dollar_arg_stack_index], 1);
4548 dispose_words (dollar_arg_stack[dollar_arg_stack_index]);
4549 dollar_arg_stack[dollar_arg_stack_index] = (WORD_LIST *)NULL;
4550 set_dollar_vars_unchanged ();
4554 dispose_saved_dollar_vars ()
4556 if (!dollar_arg_stack || dollar_arg_stack_index == 0)
4559 dispose_words (dollar_arg_stack[dollar_arg_stack_index]);
4560 dollar_arg_stack[dollar_arg_stack_index] = (WORD_LIST *)NULL;
4563 /* Manipulate the special BASH_ARGV and BASH_ARGC variables. */
4569 #if defined (ARRAY_VARS) && defined (DEBUGGER)
4570 SHELL_VAR *bash_argv_v, *bash_argc_v;
4571 ARRAY *bash_argv_a, *bash_argc_a;
4576 GET_ARRAY_FROM_VAR ("BASH_ARGV", bash_argv_v, bash_argv_a);
4577 GET_ARRAY_FROM_VAR ("BASH_ARGC", bash_argc_v, bash_argc_a);
4579 for (l = list, i = 0; l; l = l->next, i++)
4580 array_push (bash_argv_a, l->word->word);
4583 array_push (bash_argc_a, t);
4585 #endif /* ARRAY_VARS && DEBUGGER */
4588 /* Remove arguments from BASH_ARGV array. Pop top element off BASH_ARGC
4589 array and use that value as the count of elements to remove from
4594 #if defined (ARRAY_VARS) && defined (DEBUGGER)
4595 SHELL_VAR *bash_argv_v, *bash_argc_v;
4596 ARRAY *bash_argv_a, *bash_argc_a;
4600 GET_ARRAY_FROM_VAR ("BASH_ARGV", bash_argv_v, bash_argv_a);
4601 GET_ARRAY_FROM_VAR ("BASH_ARGC", bash_argc_v, bash_argc_a);
4603 ce = array_shift (bash_argc_a, 1, 0);
4604 if (ce == 0 || legal_number (element_value (ce), &i) == 0)
4608 array_pop (bash_argv_a);
4609 array_dispose_element (ce);
4610 #endif /* ARRAY_VARS && DEBUGGER */
4613 /*************************************************
4615 * Functions to manage special variables *
4617 *************************************************/
4619 /* Extern declarations for variables this code has to manage. */
4620 extern int eof_encountered, eof_encountered_limit, ignoreeof;
4622 #if defined (READLINE)
4623 extern int hostname_list_initialized;
4626 /* An alist of name.function for each special variable. Most of the
4627 functions don't do much, and in fact, this would be faster with a
4628 switch statement, but by the end of this file, I am sick of switch
4631 #define SET_INT_VAR(name, intvar) intvar = find_variable (name) != 0
4633 /* This table will be sorted with qsort() the first time it's accessed. */
4634 struct name_and_function {
4636 sh_sv_func_t *function;
4639 static struct name_and_function special_vars[] = {
4640 { "BASH_COMPAT", sv_shcompat },
4641 { "BASH_XTRACEFD", sv_xtracefd },
4643 #if defined (JOB_CONTROL)
4644 { "CHILD_MAX", sv_childmax },
4647 #if defined (READLINE)
4648 # if defined (STRICT_POSIX)
4649 { "COLUMNS", sv_winsize },
4651 { "COMP_WORDBREAKS", sv_comp_wordbreaks },
4654 { "FUNCNEST", sv_funcnest },
4656 { "GLOBIGNORE", sv_globignore },
4658 #if defined (HISTORY)
4659 { "HISTCONTROL", sv_history_control },
4660 { "HISTFILESIZE", sv_histsize },
4661 { "HISTIGNORE", sv_histignore },
4662 { "HISTSIZE", sv_histsize },
4663 { "HISTTIMEFORMAT", sv_histtimefmt },
4666 #if defined (__CYGWIN__)
4667 { "HOME", sv_home },
4670 #if defined (READLINE)
4671 { "HOSTFILE", sv_hostfile },
4675 { "IGNOREEOF", sv_ignoreeof },
4677 { "LANG", sv_locale },
4678 { "LC_ALL", sv_locale },
4679 { "LC_COLLATE", sv_locale },
4680 { "LC_CTYPE", sv_locale },
4681 { "LC_MESSAGES", sv_locale },
4682 { "LC_NUMERIC", sv_locale },
4683 { "LC_TIME", sv_locale },
4685 #if defined (READLINE) && defined (STRICT_POSIX)
4686 { "LINES", sv_winsize },
4689 { "MAIL", sv_mail },
4690 { "MAILCHECK", sv_mail },
4691 { "MAILPATH", sv_mail },
4693 { "OPTERR", sv_opterr },
4694 { "OPTIND", sv_optind },
4696 { "PATH", sv_path },
4697 { "POSIXLY_CORRECT", sv_strict_posix },
4699 #if defined (READLINE)
4700 { "TERM", sv_terminal },
4701 { "TERMCAP", sv_terminal },
4702 { "TERMINFO", sv_terminal },
4703 #endif /* READLINE */
4705 { "TEXTDOMAIN", sv_locale },
4706 { "TEXTDOMAINDIR", sv_locale },
4708 #if defined (HAVE_TZSET)
4712 #if defined (HISTORY) && defined (BANG_HISTORY)
4713 { "histchars", sv_histchars },
4714 #endif /* HISTORY && BANG_HISTORY */
4716 { "ignoreeof", sv_ignoreeof },
4718 { (char *)0, (sh_sv_func_t *)0 }
4721 #define N_SPECIAL_VARS (sizeof (special_vars) / sizeof (special_vars[0]) - 1)
4724 sv_compare (sv1, sv2)
4725 struct name_and_function *sv1, *sv2;
4729 if ((r = sv1->name[0] - sv2->name[0]) == 0)
4730 r = strcmp (sv1->name, sv2->name);
4735 find_special_var (name)
4740 for (i = 0; special_vars[i].name; i++)
4742 r = special_vars[i].name[0] - name[0];
4744 r = strcmp (special_vars[i].name, name);
4748 /* Can't match any of rest of elements in sorted list. Take this out
4749 if it causes problems in certain environments. */
4755 /* The variable in NAME has just had its state changed. Check to see if it
4756 is one of the special ones where something special happens. */
4758 stupidly_hack_special_variables (name)
4761 static int sv_sorted = 0;
4764 if (sv_sorted == 0) /* shouldn't need, but it's fairly cheap. */
4766 qsort (special_vars, N_SPECIAL_VARS, sizeof (special_vars[0]),
4767 (QSFUNC *)sv_compare);
4771 i = find_special_var (name);
4773 (*(special_vars[i].function)) (name);
4776 /* Special variables that need hooks to be run when they are unset as part
4777 of shell reinitialization should have their sv_ functions run here. */
4779 reinit_special_variables ()
4781 #if defined (READLINE)
4782 sv_comp_wordbreaks ("COMP_WORDBREAKS");
4784 sv_globignore ("GLOBIGNORE");
4785 sv_opterr ("OPTERR");
4794 v = find_variable ("IFS");
4798 /* What to do just after the PATH variable has changed. */
4807 /* What to do just after one of the MAILxxxx variables has changed. NAME
4808 is the name of the variable. This is called with NAME set to one of
4809 MAIL, MAILCHECK, or MAILPATH. */
4814 /* If the time interval for checking the files has changed, then
4815 reset the mail timer. Otherwise, one of the pathname vars
4816 to the users mailbox has changed, so rebuild the array of
4818 if (name[4] == 'C') /* if (strcmp (name, "MAILCHECK") == 0) */
4819 reset_mail_timer ();
4823 remember_mail_dates ();
4834 v = find_variable (name);
4837 else if (legal_number (value_cell (v), &num) == 0)
4843 /* What to do when GLOBIGNORE changes. */
4845 sv_globignore (name)
4848 if (privileged_mode == 0)
4849 setup_glob_ignore (name);
4852 #if defined (READLINE)
4854 sv_comp_wordbreaks (name)
4859 sv = find_variable (name);
4861 reset_completer_word_break_chars ();
4864 /* What to do just after one of the TERMxxx variables has changed.
4865 If we are an interactive shell, then try to reset the terminal
4866 information in readline. */
4871 if (interactive_shell && no_line_editing == 0)
4872 rl_reset_terminal (get_string_value ("TERM"));
4881 v = find_variable (name);
4883 clear_hostname_list ();
4885 hostname_list_initialized = 0;
4888 #if defined (STRICT_POSIX)
4889 /* In strict posix mode, we allow assignments to LINES and COLUMNS (and values
4890 found in the initial environment) to override the terminal size reported by
4900 if (posixly_correct == 0 || interactive_shell == 0 || no_line_editing)
4903 v = find_variable (name);
4904 if (v == 0 || var_isnull (v))
4905 rl_reset_screen_size ();
4908 if (legal_number (value_cell (v), &xd) == 0)
4910 winsize_assignment = 1;
4911 d = xd; /* truncate */
4912 if (name[0] == 'L') /* LINES */
4913 rl_set_screen_size (d, -1);
4915 rl_set_screen_size (-1, d);
4916 winsize_assignment = 0;
4919 #endif /* STRICT_POSIX */
4920 #endif /* READLINE */
4922 /* Update the value of HOME in the export environment so tilde expansion will
4924 #if defined (__CYGWIN__)
4928 array_needs_making = 1;
4929 maybe_make_export_env ();
4933 #if defined (HISTORY)
4934 /* What to do after the HISTSIZE or HISTFILESIZE variables change.
4935 If there is a value for this HISTSIZE (and it is numeric), then stifle
4936 the history. Otherwise, if there is NO value for this variable,
4937 unstifle the history. If name is HISTFILESIZE, and its value is
4938 numeric, truncate the history file to hold no more than that many
4948 temp = get_string_value (name);
4952 if (legal_number (temp, &num))
4955 if (hmax < 0 && name[4] == 'S')
4956 unstifle_history (); /* unstifle history if HISTSIZE < 0 */
4957 else if (name[4] == 'S')
4959 stifle_history (hmax);
4960 hmax = where_history ();
4961 if (history_lines_this_session > hmax)
4962 history_lines_this_session = hmax;
4964 else if (hmax >= 0) /* truncate HISTFILE if HISTFILESIZE >= 0 */
4966 history_truncate_file (get_string_value ("HISTFILE"), hmax);
4967 if (hmax <= history_lines_in_file)
4968 history_lines_in_file = hmax;
4972 else if (name[4] == 'S')
4973 unstifle_history ();
4976 /* What to do after the HISTIGNORE variable changes. */
4978 sv_histignore (name)
4981 setup_history_ignore (name);
4984 /* What to do after the HISTCONTROL variable changes. */
4986 sv_history_control (name)
4993 history_control = 0;
4994 temp = get_string_value (name);
4996 if (temp == 0 || *temp == 0)
5000 while (val = extract_colon_unit (temp, &tptr))
5002 if (STREQ (val, "ignorespace"))
5003 history_control |= HC_IGNSPACE;
5004 else if (STREQ (val, "ignoredups"))
5005 history_control |= HC_IGNDUPS;
5006 else if (STREQ (val, "ignoreboth"))
5007 history_control |= HC_IGNBOTH;
5008 else if (STREQ (val, "erasedups"))
5009 history_control |= HC_ERASEDUPS;
5015 #if defined (BANG_HISTORY)
5016 /* Setting/unsetting of the history expansion character. */
5023 temp = get_string_value (name);
5026 history_expansion_char = *temp;
5027 if (temp[0] && temp[1])
5029 history_subst_char = temp[1];
5031 history_comment_char = temp[2];
5036 history_expansion_char = '!';
5037 history_subst_char = '^';
5038 history_comment_char = '#';
5041 #endif /* BANG_HISTORY */
5044 sv_histtimefmt (name)
5049 if (v = find_variable (name))
5051 if (history_comment_char == 0)
5052 history_comment_char = '#';
5054 history_write_timestamps = (v != 0);
5056 #endif /* HISTORY */
5058 #if defined (HAVE_TZSET)
5063 if (chkexport (name))
5068 /* If the variable exists, then the value of it can be the number
5069 of times we actually ignore the EOF. The default is small,
5070 (smaller than csh, anyway). */
5078 eof_encountered = 0;
5080 tmp_var = find_variable (name);
5081 ignoreeof = tmp_var != 0;
5082 temp = tmp_var ? value_cell (tmp_var) : (char *)NULL;
5084 eof_encountered_limit = (*temp && all_digits (temp)) ? atoi (temp) : 10;
5085 set_shellopts (); /* make sure `ignoreeof' is/is not in $SHELLOPTS */
5095 tt = get_string_value ("OPTIND");
5100 /* According to POSIX, setting OPTIND=1 resets the internal state
5102 if (s < 0 || s == 1)
5116 tt = get_string_value ("OPTERR");
5117 sh_opterr = (tt && *tt) ? atoi (tt) : 1;
5121 sv_strict_posix (name)
5124 SET_INT_VAR (name, posixly_correct);
5125 posix_initialize (posixly_correct);
5126 #if defined (READLINE)
5127 if (interactive_shell)
5128 posix_readline_initialize (posixly_correct);
5129 #endif /* READLINE */
5130 set_shellopts (); /* make sure `posix' is/is not in $SHELLOPTS */
5140 v = get_string_value (name);
5141 if (name[0] == 'L' && name[1] == 'A') /* LANG */
5142 r = set_lang (name, v);
5144 r = set_locale_var (name, v); /* LC_*, TEXTDOMAIN* */
5147 if (r == 0 && posixly_correct)
5148 last_command_exit_value = 1;
5152 #if defined (ARRAY_VARS)
5154 set_pipestatus_array (ps, nproc)
5162 char *t, tbuf[INT_STRLEN_BOUND(int) + 1];
5164 v = find_variable ("PIPESTATUS");
5166 v = make_new_array_variable ("PIPESTATUS");
5167 if (array_p (v) == 0)
5168 return; /* Do nothing if not an array variable. */
5171 if (a == 0 || array_num_elements (a) == 0)
5173 for (i = 0; i < nproc; i++) /* was ps[i] != -1, not i < nproc */
5175 t = inttostr (ps[i], tbuf, sizeof (tbuf));
5176 array_insert (a, i, t);
5182 if (array_num_elements (a) == nproc && nproc == 1)
5184 ae = element_forw (a->head);
5185 free (element_value (ae));
5186 ae->value = itos (ps[0]);
5188 else if (array_num_elements (a) <= nproc)
5190 /* modify in array_num_elements members in place, then add */
5192 for (i = 0; i < array_num_elements (a); i++)
5194 ae = element_forw (ae);
5195 free (element_value (ae));
5196 ae->value = itos (ps[i]);
5199 for ( ; i < nproc; i++)
5201 t = inttostr (ps[i], tbuf, sizeof (tbuf));
5202 array_insert (a, i, t);
5207 /* deleting elements. it's faster to rebuild the array. */
5209 for (i = 0; ps[i] != -1; i++)
5211 t = inttostr (ps[i], tbuf, sizeof (tbuf));
5212 array_insert (a, i, t);
5218 save_pipestatus_array ()
5223 v = find_variable ("PIPESTATUS");
5224 if (v == 0 || array_p (v) == 0 || array_cell (v) == 0)
5225 return ((ARRAY *)NULL);
5228 a2 = array_copy (array_cell (v));
5234 restore_pipestatus_array (a)
5240 v = find_variable ("PIPESTATUS");
5241 /* XXX - should we still assign even if existing value is NULL? */
5242 if (v == 0 || array_p (v) == 0 || array_cell (v) == 0)
5245 a2 = array_cell (v);
5246 var_setarray (v, a);
5253 set_pipestatus_from_exit (s)
5256 #if defined (ARRAY_VARS)
5257 static int v[2] = { 0, -1 };
5260 set_pipestatus_array (v, 1);
5273 v = find_variable (name);
5281 if (t == 0 || *t == 0)
5285 fd = (int)strtol (t, &e, 10);
5286 if (e != t && *e == '\0' && sh_validfd (fd))
5288 fp = fdopen (fd, "w");
5290 internal_error (_("%s: %s: cannot open as FILE"), name, value_cell (v));
5292 xtrace_set (fd, fp);
5295 internal_error (_("%s: %s: invalid value for trace file descriptor"), name, value_cell (v));
5299 #define MIN_COMPAT_LEVEL 31
5307 int tens, ones, compatval;
5309 v = find_variable (name);
5312 shell_compatibility_level = DEFAULT_COMPAT_LEVEL;
5313 set_compatibility_opts ();
5316 val = value_cell (v);
5317 if (val == 0 || *val == '\0')
5319 shell_compatibility_level = DEFAULT_COMPAT_LEVEL;
5320 set_compatibility_opts ();
5323 /* Handle decimal-like compatibility version specifications: 4.2 */
5324 if (isdigit (val[0]) && val[1] == '.' && isdigit (val[2]) && val[3] == 0)
5326 tens = val[0] - '0';
5327 ones = val[2] - '0';
5328 compatval = tens*10 + ones;
5330 /* Handle integer-like compatibility version specifications: 42 */
5331 else if (isdigit (val[0]) && isdigit (val[1]) && val[2] == 0)
5333 tens = val[0] - '0';
5334 ones = val[1] - '0';
5335 compatval = tens*10 + ones;
5340 internal_error (_("%s: %s: compatibility value out of range"), name, val);
5341 shell_compatibility_level = DEFAULT_COMPAT_LEVEL;
5342 set_compatibility_opts ();
5346 if (compatval < MIN_COMPAT_LEVEL || compatval > DEFAULT_COMPAT_LEVEL)
5349 shell_compatibility_level = compatval;
5350 set_compatibility_opts ();
5353 #if defined (JOB_CONTROL)
5361 tt = get_string_value (name);
5362 s = (tt && *tt) ? atoi (tt) : 0;