1 /* variables.c -- Functions for hacking shell variables. */
3 /* Copyright (C) 1987-2009 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"
59 #include "builtins/getopt.h"
60 #include "builtins/common.h"
62 #if defined (READLINE)
63 # include "bashline.h"
64 # include <readline/readline.h>
66 # include <tilde/tilde.h>
70 # include "bashhist.h"
71 # include <readline/history.h>
74 #if defined (PROGRAMMABLE_COMPLETION)
75 # include "pcomplete.h"
78 #define TEMPENV_HASH_BUCKETS 4 /* must be power of two */
80 #define ifsname(s) ((s)[0] == 'I' && (s)[1] == 'F' && (s)[2] == 'S' && (s)[3] == '\0')
82 extern char **environ
;
84 /* Variables used here and defined in other files. */
85 extern int posixly_correct
;
86 extern int line_number
;
87 extern int subshell_environment
, indirection_level
, subshell_level
;
88 extern int build_version
, patch_level
;
89 extern int expanding_redir
;
90 extern char *dist_version
, *release_status
;
91 extern char *shell_name
;
92 extern char *primary_prompt
, *secondary_prompt
;
93 extern char *current_host_name
;
94 extern sh_builtin_func_t
*this_shell_builtin
;
95 extern SHELL_VAR
*this_shell_function
;
96 extern char *the_printed_command_except_trap
;
97 extern char *this_command_name
;
98 extern char *command_execution_string
;
99 extern time_t shell_start_time
;
100 extern int assigning_in_environment
;
101 extern int executing_builtin
;
103 #if defined (READLINE)
104 extern int no_line_editing
;
105 extern int perform_hostname_completion
;
108 /* The list of shell variables that the user has created at the global
109 scope, or that came from the environment. */
110 VAR_CONTEXT
*global_variables
= (VAR_CONTEXT
*)NULL
;
112 /* The current list of shell variables, including function scopes */
113 VAR_CONTEXT
*shell_variables
= (VAR_CONTEXT
*)NULL
;
115 /* The list of shell functions that the user has created, or that came from
117 HASH_TABLE
*shell_functions
= (HASH_TABLE
*)NULL
;
119 #if defined (DEBUGGER)
120 /* The table of shell function definitions that the user defined or that
121 came from the environment. */
122 HASH_TABLE
*shell_function_defs
= (HASH_TABLE
*)NULL
;
125 /* The current variable context. This is really a count of how deep into
126 executing functions we are. */
127 int variable_context
= 0;
129 /* The set of shell assignments which are made only in the environment
130 for a single command. */
131 HASH_TABLE
*temporary_env
= (HASH_TABLE
*)NULL
;
133 /* Set to non-zero if an assignment error occurs while putting variables
134 into the temporary environment. */
135 int tempenv_assign_error
;
137 /* Some funky variables which are known about specially. Here is where
138 "$*", "$1", and all the cruft is kept. */
139 char *dollar_vars
[10];
140 WORD_LIST
*rest_of_args
= (WORD_LIST
*)NULL
;
142 /* The value of $$. */
143 pid_t dollar_dollar_pid
;
145 /* Non-zero means that we have to remake EXPORT_ENV. */
146 int array_needs_making
= 1;
148 /* The number of times BASH has been executed. This is set
149 by initialize_variables (). */
152 /* An array which is passed to commands as their environment. It is
153 manufactured from the union of the initial environment and the
154 shell variables that are marked for export. */
155 char **export_env
= (char **)NULL
;
156 static int export_env_index
;
157 static int export_env_size
;
159 #if defined (READLINE)
160 static int winsize_assignment
; /* currently assigning to LINES or COLUMNS */
161 static int winsize_assigned
; /* assigned to LINES or COLUMNS */
164 /* Some forward declarations. */
165 static void create_variable_tables
__P((void));
167 static void set_machine_vars
__P((void));
168 static void set_home_var
__P((void));
169 static void set_shell_var
__P((void));
170 static char *get_bash_name
__P((void));
171 static void initialize_shell_level
__P((void));
172 static void uidset
__P((void));
173 #if defined (ARRAY_VARS)
174 static void make_vers_array
__P((void));
177 static SHELL_VAR
*null_assign
__P((SHELL_VAR
*, char *, arrayind_t
, char *));
178 #if defined (ARRAY_VARS)
179 static SHELL_VAR
*null_array_assign
__P((SHELL_VAR
*, char *, arrayind_t
, char *));
181 static SHELL_VAR
*get_self
__P((SHELL_VAR
*));
183 #if defined (ARRAY_VARS)
184 static SHELL_VAR
*init_dynamic_array_var
__P((char *, sh_var_value_func_t
*, sh_var_assign_func_t
*, int));
185 static SHELL_VAR
*init_dynamic_assoc_var
__P((char *, sh_var_value_func_t
*, sh_var_assign_func_t
*, int));
188 static SHELL_VAR
*assign_seconds
__P((SHELL_VAR
*, char *, arrayind_t
, char *));
189 static SHELL_VAR
*get_seconds
__P((SHELL_VAR
*));
190 static SHELL_VAR
*init_seconds_var
__P((void));
192 static int brand
__P((void));
193 static void sbrand
__P((unsigned long)); /* set bash random number generator. */
194 static void seedrand
__P((void)); /* seed generator randomly */
195 static SHELL_VAR
*assign_random
__P((SHELL_VAR
*, char *, arrayind_t
, char *));
196 static SHELL_VAR
*get_random
__P((SHELL_VAR
*));
198 static SHELL_VAR
*assign_lineno
__P((SHELL_VAR
*, char *, arrayind_t
, char *));
199 static SHELL_VAR
*get_lineno
__P((SHELL_VAR
*));
201 static SHELL_VAR
*assign_subshell
__P((SHELL_VAR
*, char *, arrayind_t
, char *));
202 static SHELL_VAR
*get_subshell
__P((SHELL_VAR
*));
204 static SHELL_VAR
*get_bashpid
__P((SHELL_VAR
*));
206 #if defined (HISTORY)
207 static SHELL_VAR
*get_histcmd
__P((SHELL_VAR
*));
210 #if defined (READLINE)
211 static SHELL_VAR
*get_comp_wordbreaks
__P((SHELL_VAR
*));
212 static SHELL_VAR
*assign_comp_wordbreaks
__P((SHELL_VAR
*, char *, arrayind_t
, char *));
215 #if defined (PUSHD_AND_POPD) && defined (ARRAY_VARS)
216 static SHELL_VAR
*assign_dirstack
__P((SHELL_VAR
*, char *, arrayind_t
, char *));
217 static SHELL_VAR
*get_dirstack
__P((SHELL_VAR
*));
220 #if defined (ARRAY_VARS)
221 static SHELL_VAR
*get_groupset
__P((SHELL_VAR
*));
223 static SHELL_VAR
*build_hashcmd
__P((SHELL_VAR
*));
224 static SHELL_VAR
*get_hashcmd
__P((SHELL_VAR
*));
225 static SHELL_VAR
*assign_hashcmd
__P((SHELL_VAR
*, char *, arrayind_t
, char *));
227 static SHELL_VAR
*build_aliasvar
__P((SHELL_VAR
*));
228 static SHELL_VAR
*get_aliasvar
__P((SHELL_VAR
*));
229 static SHELL_VAR
*assign_aliasvar
__P((SHELL_VAR
*, char *, arrayind_t
, char *));
233 static SHELL_VAR
*get_funcname
__P((SHELL_VAR
*));
234 static SHELL_VAR
*init_funcname_var
__P((void));
236 static void initialize_dynamic_variables
__P((void));
238 static SHELL_VAR
*hash_lookup
__P((const char *, HASH_TABLE
*));
239 static SHELL_VAR
*new_shell_variable
__P((const char *));
240 static SHELL_VAR
*make_new_variable
__P((const char *, HASH_TABLE
*));
241 static SHELL_VAR
*bind_variable_internal
__P((const char *, char *, HASH_TABLE
*, int, int));
243 static void dispose_variable_value
__P((SHELL_VAR
*));
244 static void free_variable_hash_data
__P((PTR_T
));
246 static VARLIST
*vlist_alloc
__P((int));
247 static VARLIST
*vlist_realloc
__P((VARLIST
*, int));
248 static void vlist_add
__P((VARLIST
*, SHELL_VAR
*, int));
250 static void flatten
__P((HASH_TABLE
*, sh_var_map_func_t
*, VARLIST
*, int));
252 static int qsort_var_comp
__P((SHELL_VAR
**, SHELL_VAR
**));
254 static SHELL_VAR
**vapply
__P((sh_var_map_func_t
*));
255 static SHELL_VAR
**fapply
__P((sh_var_map_func_t
*));
257 static int visible_var
__P((SHELL_VAR
*));
258 static int visible_and_exported
__P((SHELL_VAR
*));
259 static int export_environment_candidate
__P((SHELL_VAR
*));
260 static int local_and_exported
__P((SHELL_VAR
*));
261 static int variable_in_context
__P((SHELL_VAR
*));
262 #if defined (ARRAY_VARS)
263 static int visible_array_vars
__P((SHELL_VAR
*));
266 static SHELL_VAR
*bind_tempenv_variable
__P((const char *, char *));
267 static void push_temp_var
__P((PTR_T
));
268 static void propagate_temp_var
__P((PTR_T
));
269 static void dispose_temporary_env
__P((sh_free_func_t
*));
271 static inline char *mk_env_string
__P((const char *, const char *));
272 static char **make_env_array_from_var_list
__P((SHELL_VAR
**));
273 static char **make_var_export_array
__P((VAR_CONTEXT
*));
274 static char **make_func_export_array
__P((void));
275 static void add_temp_array_to_env
__P((char **, int, int));
277 static int n_shell_variables
__P((void));
278 static int set_context
__P((SHELL_VAR
*));
280 static void push_func_var
__P((PTR_T
));
281 static void push_exported_var
__P((PTR_T
));
283 static inline int find_special_var
__P((const char *));
286 create_variable_tables ()
288 if (shell_variables
== 0)
290 shell_variables
= global_variables
= new_var_context ((char *)NULL
, 0);
291 shell_variables
->scope
= 0;
292 shell_variables
->table
= hash_create (0);
295 if (shell_functions
== 0)
296 shell_functions
= hash_create (0);
298 #if defined (DEBUGGER)
299 if (shell_function_defs
== 0)
300 shell_function_defs
= hash_create (0);
304 /* Initialize the shell variables from the current environment.
305 If PRIVMODE is nonzero, don't import functions from ENV or
308 initialize_shell_variables (env
, privmode
)
312 char *name
, *string
, *temp_string
;
313 int c
, char_index
, string_index
, string_length
;
316 create_variable_tables ();
318 for (string_index
= 0; string
= env
[string_index
++]; )
322 while ((c
= *string
++) && c
!= '=')
324 if (string
[-1] == '=')
325 char_index
= string
- name
- 1;
327 /* If there are weird things in the environment, like `=xxx' or a
328 string without an `=', just skip them. */
332 /* ASSERT(name[char_index] == '=') */
333 name
[char_index
] = '\0';
334 /* Now, name = env variable name, string = env variable value, and
335 char_index == strlen (name) */
337 temp_var
= (SHELL_VAR
*)NULL
;
339 /* If exported function, define it now. Don't import functions from
340 the environment in privileged mode. */
341 if (privmode
== 0 && read_but_dont_execute
== 0 && STREQN ("() {", string
, 4))
343 string_length
= strlen (string
);
344 temp_string
= (char *)xmalloc (3 + string_length
+ char_index
);
346 strcpy (temp_string
, name
);
347 temp_string
[char_index
] = ' ';
348 strcpy (temp_string
+ char_index
+ 1, string
);
350 parse_and_execute (temp_string
, name
, SEVAL_NONINT
|SEVAL_NOHIST
);
352 /* Ancient backwards compatibility. Old versions of bash exported
353 functions like name()=() {...} */
354 if (name
[char_index
- 1] == ')' && name
[char_index
- 2] == '(')
355 name
[char_index
- 2] = '\0';
357 if (temp_var
= find_function (name
))
359 VSETATTR (temp_var
, (att_exported
|att_imported
));
360 array_needs_making
= 1;
363 report_error (_("error importing function definition for `%s'"), name
);
366 if (name
[char_index
- 1] == ')' && name
[char_index
- 2] == '\0')
367 name
[char_index
- 2] = '('; /* ) */
369 #if defined (ARRAY_VARS)
371 /* Array variables may not yet be exported. */
372 else if (*string
== '(' && string
[1] == '[' && string
[strlen (string
) - 1] == ')')
375 temp_string
= extract_array_assignment_list (string
, &string_length
);
376 temp_var
= assign_array_from_string (name
, temp_string
);
378 VSETATTR (temp_var
, (att_exported
| att_imported
));
379 array_needs_making
= 1;
384 else if (legal_identifier (name
))
389 temp_var
= bind_variable (name
, string
, 0);
390 if (legal_identifier (name
))
391 VSETATTR (temp_var
, (att_exported
| att_imported
));
393 VSETATTR (temp_var
, (att_exported
| att_imported
| att_invisible
));
394 array_needs_making
= 1;
397 name
[char_index
] = '=';
398 /* temp_var can be NULL if it was an exported function with a syntax
399 error (a different bug, but it still shouldn't dump core). */
400 if (temp_var
&& function_p (temp_var
) == 0) /* XXX not yet */
402 CACHE_IMPORTSTR (temp_var
, name
);
408 /* Set up initial value of $_ */
409 temp_var
= set_if_not ("_", dollar_vars
[0]);
411 /* Remember this pid. */
412 dollar_dollar_pid
= getpid ();
414 /* Now make our own defaults in case the vars that we think are
415 important are missing. */
416 temp_var
= set_if_not ("PATH", DEFAULT_PATH_VALUE
);
418 set_auto_export (temp_var
); /* XXX */
421 temp_var
= set_if_not ("TERM", "dumb");
423 set_auto_export (temp_var
); /* XXX */
426 #if defined (__QNX__)
427 /* set node id -- don't import it from the environment */
430 # if defined (__QNXNTO__)
431 netmgr_ndtostr(ND2S_LOCAL_STR
, ND_LOCAL_NODE
, node_name
, sizeof(node_name
));
433 qnx_nidtostr (getnid (), node_name
, sizeof (node_name
));
435 temp_var
= bind_variable ("NODE", node_name
, 0);
436 set_auto_export (temp_var
);
440 /* set up the prompts. */
441 if (interactive_shell
)
443 #if defined (PROMPT_STRING_DECODE)
444 set_if_not ("PS1", primary_prompt
);
446 if (current_user
.uid
== -1)
447 get_current_user_info ();
448 set_if_not ("PS1", current_user
.euid
== 0 ? "# " : primary_prompt
);
450 set_if_not ("PS2", secondary_prompt
);
452 set_if_not ("PS4", "+ ");
454 /* Don't allow IFS to be imported from the environment. */
455 temp_var
= bind_variable ("IFS", " \t\n", 0);
458 /* Magic machine types. Pretty convenient. */
461 /* Default MAILCHECK for interactive shells. Defer the creation of a
462 default MAILPATH until the startup files are read, because MAIL
463 names a mail file if MAILPATH is not set, and we should provide a
464 default only if neither is set. */
465 if (interactive_shell
)
467 temp_var
= set_if_not ("MAILCHECK", posixly_correct
? "600" : "60");
468 VSETATTR (temp_var
, att_integer
);
471 /* Do some things with shell level. */
472 initialize_shell_level ();
476 /* Initialize the `getopts' stuff. */
477 temp_var
= bind_variable ("OPTIND", "1", 0);
478 VSETATTR (temp_var
, att_integer
);
480 bind_variable ("OPTERR", "1", 0);
483 if (login_shell
== 1 && posixly_correct
== 0)
486 /* Get the full pathname to THIS shell, and set the BASH variable
488 name
= get_bash_name ();
489 temp_var
= bind_variable ("BASH", name
, 0);
492 /* Make the exported environment variable SHELL be the user's login
493 shell. Note that the `tset' command looks at this variable
494 to determine what style of commands to output; if it ends in "csh",
495 then C-shell commands are output, else Bourne shell commands. */
498 /* Make a variable called BASH_VERSION which contains the version info. */
499 bind_variable ("BASH_VERSION", shell_version_string (), 0);
500 #if defined (ARRAY_VARS)
504 if (command_execution_string
)
505 bind_variable ("BASH_EXECUTION_STRING", command_execution_string
, 0);
507 /* Find out if we're supposed to be in Posix.2 mode via an
508 environment variable. */
509 temp_var
= find_variable ("POSIXLY_CORRECT");
511 temp_var
= find_variable ("POSIX_PEDANTIC");
512 if (temp_var
&& imported_p (temp_var
))
513 sv_strict_posix (temp_var
->name
);
515 #if defined (HISTORY)
516 /* Set history variables to defaults, and then do whatever we would
517 do if the variable had just been set. Do this only in the case
518 that we are remembering commands on the history list. */
519 if (remember_on_history
)
521 name
= bash_tilde_expand (posixly_correct
? "~/.sh_history" : "~/.bash_history", 0);
523 set_if_not ("HISTFILE", name
);
527 set_if_not ("HISTSIZE", "500");
528 sv_histsize ("HISTSIZE");
533 /* Seed the random number generator. */
536 /* Handle some "special" variables that we may have inherited from a
538 if (interactive_shell
)
540 temp_var
= find_variable ("IGNOREEOF");
542 temp_var
= find_variable ("ignoreeof");
543 if (temp_var
&& imported_p (temp_var
))
544 sv_ignoreeof (temp_var
->name
);
547 #if defined (HISTORY)
548 if (interactive_shell
&& remember_on_history
)
550 sv_history_control ("HISTCONTROL");
551 sv_histignore ("HISTIGNORE");
552 sv_histtimefmt ("HISTTIMEFORMAT");
556 #if defined (READLINE) && defined (STRICT_POSIX)
557 /* POSIXLY_CORRECT will only be 1 here if the shell was compiled
559 if (interactive_shell
&& posixly_correct
&& no_line_editing
== 0)
560 rl_prefer_env_winsize
= 1;
561 #endif /* READLINE && STRICT_POSIX */
566 * I'm tired of the arguing and bug reports. Bash now leaves SSH_CLIENT
567 * and SSH2_CLIENT alone. I'm going to rely on the shell_level check in
568 * isnetconn() to avoid running the startup files more often than wanted.
569 * That will, of course, only work if the user's login shell is bash, so
570 * I've made that behavior conditional on SSH_SOURCE_BASHRC being defined
574 temp_var
= find_variable ("SSH_CLIENT");
575 if (temp_var
&& imported_p (temp_var
))
577 VUNSETATTR (temp_var
, att_exported
);
578 array_needs_making
= 1;
580 temp_var
= find_variable ("SSH2_CLIENT");
581 if (temp_var
&& imported_p (temp_var
))
583 VUNSETATTR (temp_var
, att_exported
);
584 array_needs_making
= 1;
588 /* Get the user's real and effective user ids. */
591 /* Initialize the dynamic variables, and seed their values. */
592 initialize_dynamic_variables ();
595 /* **************************************************************** */
597 /* Setting values for special shell variables */
599 /* **************************************************************** */
606 temp_var
= set_if_not ("HOSTTYPE", HOSTTYPE
);
607 temp_var
= set_if_not ("OSTYPE", OSTYPE
);
608 temp_var
= set_if_not ("MACHTYPE", MACHTYPE
);
610 temp_var
= set_if_not ("HOSTNAME", current_host_name
);
613 /* Set $HOME to the information in the password file if we didn't get
614 it from the environment. */
616 /* This function is not static so the tilde and readline libraries can
621 if (current_user
.home_dir
== 0)
622 get_current_user_info ();
623 return current_user
.home_dir
;
631 temp_var
= find_variable ("HOME");
633 temp_var
= bind_variable ("HOME", sh_get_home_dir (), 0);
635 VSETATTR (temp_var
, att_exported
);
639 /* Set $SHELL to the user's login shell if it is not already set. Call
640 get_current_user_info if we haven't already fetched the shell. */
646 temp_var
= find_variable ("SHELL");
649 if (current_user
.shell
== 0)
650 get_current_user_info ();
651 temp_var
= bind_variable ("SHELL", current_user
.shell
, 0);
654 VSETATTR (temp_var
, att_exported
);
663 if ((login_shell
== 1) && RELPATH(shell_name
))
665 if (current_user
.shell
== 0)
666 get_current_user_info ();
667 name
= savestring (current_user
.shell
);
669 else if (ABSPATH(shell_name
))
670 name
= savestring (shell_name
);
671 else if (shell_name
[0] == '.' && shell_name
[1] == '/')
673 /* Fast path for common case. */
677 cdir
= get_string_value ("PWD");
681 name
= (char *)xmalloc (len
+ strlen (shell_name
) + 1);
683 strcpy (name
+ len
, shell_name
+ 1);
686 name
= savestring (shell_name
);
693 tname
= find_user_command (shell_name
);
697 /* Try the current directory. If there is not an executable
698 there, just punt and use the login shell. */
699 s
= file_status (shell_name
);
702 tname
= make_absolute (shell_name
, get_string_value ("PWD"));
703 if (*shell_name
== '.')
705 name
= sh_canonpath (tname
, PATH_CHECKDOTDOT
|PATH_CHECKEXISTS
);
716 if (current_user
.shell
== 0)
717 get_current_user_info ();
718 name
= savestring (current_user
.shell
);
723 name
= full_pathname (tname
);
732 adjust_shell_level (change
)
735 char new_level
[5], *old_SHLVL
;
739 old_SHLVL
= get_string_value ("SHLVL");
740 if (old_SHLVL
== 0 || *old_SHLVL
== '\0' || legal_number (old_SHLVL
, &old_level
) == 0)
743 shell_level
= old_level
+ change
;
746 else if (shell_level
> 1000)
748 internal_warning (_("shell level (%d) too high, resetting to 1"), shell_level
);
752 /* We don't need the full generality of itos here. */
753 if (shell_level
< 10)
755 new_level
[0] = shell_level
+ '0';
758 else if (shell_level
< 100)
760 new_level
[0] = (shell_level
/ 10) + '0';
761 new_level
[1] = (shell_level
% 10) + '0';
764 else if (shell_level
< 1000)
766 new_level
[0] = (shell_level
/ 100) + '0';
767 old_level
= shell_level
% 100;
768 new_level
[1] = (old_level
/ 10) + '0';
769 new_level
[2] = (old_level
% 10) + '0';
773 temp_var
= bind_variable ("SHLVL", new_level
, 0);
774 set_auto_export (temp_var
);
778 initialize_shell_level ()
780 adjust_shell_level (1);
783 /* If we got PWD from the environment, update our idea of the current
784 working directory. In any case, make sure that PWD exists before
785 checking it. It is possible for getcwd () to fail on shell startup,
786 and in that case, PWD would be undefined. If this is an interactive
787 login shell, see if $HOME is the current working directory, and if
788 that's not the same string as $PWD, set PWD=$HOME. */
793 SHELL_VAR
*temp_var
, *home_var
;
794 char *temp_string
, *home_string
;
796 home_var
= find_variable ("HOME");
797 home_string
= home_var
? value_cell (home_var
) : (char *)NULL
;
799 temp_var
= find_variable ("PWD");
800 if (temp_var
&& imported_p (temp_var
) &&
801 (temp_string
= value_cell (temp_var
)) &&
802 same_file (temp_string
, ".", (struct stat
*)NULL
, (struct stat
*)NULL
))
803 set_working_directory (temp_string
);
804 else if (home_string
&& interactive_shell
&& login_shell
&&
805 same_file (home_string
, ".", (struct stat
*)NULL
, (struct stat
*)NULL
))
807 set_working_directory (home_string
);
808 temp_var
= bind_variable ("PWD", home_string
, 0);
809 set_auto_export (temp_var
);
813 temp_string
= get_working_directory ("shell-init");
816 temp_var
= bind_variable ("PWD", temp_string
, 0);
817 set_auto_export (temp_var
);
822 /* According to the Single Unix Specification, v2, $OLDPWD is an
823 `environment variable' and therefore should be auto-exported.
824 Make a dummy invisible variable for OLDPWD, and mark it as exported. */
825 temp_var
= bind_variable ("OLDPWD", (char *)NULL
, 0);
826 VSETATTR (temp_var
, (att_exported
| att_invisible
));
829 /* Make a variable $PPID, which holds the pid of the shell's parent. */
833 char namebuf
[INT_STRLEN_BOUND(pid_t
) + 1], *name
;
836 name
= inttostr (getppid (), namebuf
, sizeof(namebuf
));
837 temp_var
= find_variable ("PPID");
839 VUNSETATTR (temp_var
, (att_readonly
| att_exported
));
840 temp_var
= bind_variable ("PPID", name
, 0);
841 VSETATTR (temp_var
, (att_readonly
| att_integer
));
847 char buff
[INT_STRLEN_BOUND(uid_t
) + 1], *b
;
848 register SHELL_VAR
*v
;
850 b
= inttostr (current_user
.uid
, buff
, sizeof (buff
));
851 v
= find_variable ("UID");
854 v
= bind_variable ("UID", b
, 0);
855 VSETATTR (v
, (att_readonly
| att_integer
));
858 if (current_user
.euid
!= current_user
.uid
)
859 b
= inttostr (current_user
.euid
, buff
, sizeof (buff
));
861 v
= find_variable ("EUID");
864 v
= bind_variable ("EUID", b
, 0);
865 VSETATTR (v
, (att_readonly
| att_integer
));
869 #if defined (ARRAY_VARS)
875 char *s
, d
[32], b
[INT_STRLEN_BOUND(int) + 1];
877 unbind_variable ("BASH_VERSINFO");
879 vv
= make_new_array_variable ("BASH_VERSINFO");
880 av
= array_cell (vv
);
881 strcpy (d
, dist_version
);
885 array_insert (av
, 0, d
);
886 array_insert (av
, 1, s
);
887 s
= inttostr (patch_level
, b
, sizeof (b
));
888 array_insert (av
, 2, s
);
889 s
= inttostr (build_version
, b
, sizeof (b
));
890 array_insert (av
, 3, s
);
891 array_insert (av
, 4, release_status
);
892 array_insert (av
, 5, MACHTYPE
);
894 VSETATTR (vv
, att_readonly
);
896 #endif /* ARRAY_VARS */
898 /* Set the environment variables $LINES and $COLUMNS in response to
899 a window size change. */
901 sh_set_lines_and_columns (lines
, cols
)
904 char val
[INT_STRLEN_BOUND(int) + 1], *v
;
906 #if defined (READLINE)
907 /* If we are currently assigning to LINES or COLUMNS, don't do anything. */
908 if (winsize_assignment
)
912 v
= inttostr (lines
, val
, sizeof (val
));
913 bind_variable ("LINES", v
, 0);
915 v
= inttostr (cols
, val
, sizeof (val
));
916 bind_variable ("COLUMNS", v
, 0);
919 /* **************************************************************** */
921 /* Printing variables and values */
923 /* **************************************************************** */
925 /* Print LIST (a list of shell variables) to stdout in such a way that
926 they can be read back in. */
928 print_var_list (list
)
929 register SHELL_VAR
**list
;
932 register SHELL_VAR
*var
;
934 for (i
= 0; list
&& (var
= list
[i
]); i
++)
935 if (invisible_p (var
) == 0)
936 print_assignment (var
);
939 /* Print LIST (a list of shell functions) to stdout in such a way that
940 they can be read back in. */
942 print_func_list (list
)
943 register SHELL_VAR
**list
;
946 register SHELL_VAR
*var
;
948 for (i
= 0; list
&& (var
= list
[i
]); i
++)
950 printf ("%s ", var
->name
);
951 print_var_function (var
);
956 /* Print the value of a single SHELL_VAR. No newline is
957 output, but the variable is printed in such a way that
958 it can be read back in. */
960 print_assignment (var
)
963 if (var_isset (var
) == 0)
966 if (function_p (var
))
968 printf ("%s", var
->name
);
969 print_var_function (var
);
972 #if defined (ARRAY_VARS)
973 else if (array_p (var
))
974 print_array_assignment (var
, 0);
975 else if (assoc_p (var
))
976 print_assoc_assignment (var
, 0);
977 #endif /* ARRAY_VARS */
980 printf ("%s=", var
->name
);
981 print_var_value (var
, 1);
986 /* Print the value cell of VAR, a shell variable. Do not print
987 the name, nor leading/trailing newline. If QUOTE is non-zero,
988 and the value contains shell metacharacters, quote the value
989 in such a way that it can be read back in. */
991 print_var_value (var
, quote
)
997 if (var_isset (var
) == 0)
1000 if (quote
&& posixly_correct
== 0 && ansic_shouldquote (value_cell (var
)))
1002 t
= ansic_quote (value_cell (var
), 0, (int *)0);
1006 else if (quote
&& sh_contains_shell_metas (value_cell (var
)))
1008 t
= sh_single_quote (value_cell (var
));
1013 printf ("%s", value_cell (var
));
1016 /* Print the function cell of VAR, a shell variable. Do not
1017 print the name, nor leading/trailing newline. */
1019 print_var_function (var
)
1024 if (function_p (var
) && var_isset (var
))
1026 x
= named_function_string ((char *)NULL
, function_cell(var
), FUNC_MULTILINE
|FUNC_EXTERNAL
);
1031 /* **************************************************************** */
1033 /* Dynamic Variables */
1035 /* **************************************************************** */
1037 /* DYNAMIC VARIABLES
1039 These are variables whose values are generated anew each time they are
1040 referenced. These are implemented using a pair of function pointers
1041 in the struct variable: assign_func, which is called from bind_variable
1042 and, if arrays are compiled into the shell, some of the functions in
1043 arrayfunc.c, and dynamic_value, which is called from find_variable.
1045 assign_func is called from bind_variable_internal, if
1046 bind_variable_internal discovers that the variable being assigned to
1047 has such a function. The function is called as
1048 SHELL_VAR *temp = (*(entry->assign_func)) (entry, value, ind)
1049 and the (SHELL_VAR *)temp is returned as the value of bind_variable. It
1050 is usually ENTRY (self). IND is an index for an array variable, and
1053 dynamic_value is called from find_variable_internal to return a `new'
1054 value for the specified dynamic varible. If this function is NULL,
1055 the variable is treated as a `normal' shell variable. If it is not,
1056 however, then this function is called like this:
1057 tempvar = (*(var->dynamic_value)) (var);
1059 Sometimes `tempvar' will replace the value of `var'. Other times, the
1060 shell will simply use the string value. Pretty object-oriented, huh?
1062 Be warned, though: if you `unset' a special variable, it loses its
1063 special meaning, even if you subsequently set it.
1065 The special assignment code would probably have been better put in
1066 subst.c: do_assignment_internal, in the same style as
1067 stupidly_hack_special_variables, but I wanted the changes as
1068 localized as possible. */
1070 #define INIT_DYNAMIC_VAR(var, val, gfunc, afunc) \
1073 v = bind_variable (var, (val), 0); \
1074 v->dynamic_value = gfunc; \
1075 v->assign_func = afunc; \
1079 #define INIT_DYNAMIC_ARRAY_VAR(var, gfunc, afunc) \
1082 v = make_new_array_variable (var); \
1083 v->dynamic_value = gfunc; \
1084 v->assign_func = afunc; \
1088 #define INIT_DYNAMIC_ASSOC_VAR(var, gfunc, afunc) \
1091 v = make_new_assoc_variable (var); \
1092 v->dynamic_value = gfunc; \
1093 v->assign_func = afunc; \
1098 null_assign (self
, value
, unused
, key
)
1107 #if defined (ARRAY_VARS)
1109 null_array_assign (self
, value
, ind
, key
)
1119 /* Degenerate `dynamic_value' function; just returns what's passed without
1128 #if defined (ARRAY_VARS)
1129 /* A generic dynamic array variable initializer. Intialize array variable
1130 NAME with dynamic value function GETFUNC and assignment function SETFUNC. */
1132 init_dynamic_array_var (name
, getfunc
, setfunc
, attrs
)
1134 sh_var_value_func_t
*getfunc
;
1135 sh_var_assign_func_t
*setfunc
;
1140 v
= find_variable (name
);
1143 INIT_DYNAMIC_ARRAY_VAR (name
, getfunc
, setfunc
);
1145 VSETATTR (v
, attrs
);
1150 init_dynamic_assoc_var (name
, getfunc
, setfunc
, attrs
)
1152 sh_var_value_func_t
*getfunc
;
1153 sh_var_assign_func_t
*setfunc
;
1158 v
= find_variable (name
);
1161 INIT_DYNAMIC_ASSOC_VAR (name
, getfunc
, setfunc
);
1163 VSETATTR (v
, attrs
);
1168 /* The value of $SECONDS. This is the number of seconds since shell
1169 invocation, or, the number of seconds since the last assignment + the
1170 value of the last assignment. */
1171 static intmax_t seconds_value_assigned
;
1174 assign_seconds (self
, value
, unused
, key
)
1180 if (legal_number (value
, &seconds_value_assigned
) == 0)
1181 seconds_value_assigned
= 0;
1182 shell_start_time
= NOW
;
1190 time_t time_since_start
;
1193 time_since_start
= NOW
- shell_start_time
;
1194 p
= itos(seconds_value_assigned
+ time_since_start
);
1196 FREE (value_cell (var
));
1198 VSETATTR (var
, att_integer
);
1199 var_setvalue (var
, p
);
1208 v
= find_variable ("SECONDS");
1211 if (legal_number (value_cell(v
), &seconds_value_assigned
) == 0)
1212 seconds_value_assigned
= 0;
1214 INIT_DYNAMIC_VAR ("SECONDS", (v
? value_cell (v
) : (char *)NULL
), get_seconds
, assign_seconds
);
1218 /* The random number seed. You can change this by setting RANDOM. */
1219 static unsigned long rseed
= 1;
1220 static int last_random_value
;
1221 static int seeded_subshell
= 0;
1223 /* A linear congruential random number generator based on the example
1224 one in the ANSI C standard. This one isn't very good, but a more
1225 complicated one is overkill. */
1227 /* Returns a pseudo-random number between 0 and 32767. */
1232 rseed
= rseed
* 1103515245 + 12345;
1233 return ((unsigned int)((rseed
>> 16) & 32767)); /* was % 32768 */
1235 /* From "Random number generators: good ones are hard to find",
1236 Park and Miller, Communications of the ACM, vol. 31, no. 10,
1237 October 1988, p. 1195. filtered through FreeBSD */
1244 rseed
= 16807 * l
- 2836 * h
;
1247 rseed
+= 0x7fffffff;
1249 return ((unsigned int)(rseed
& 32767)); /* was % 32768 */
1253 /* Set the random number generator seed to SEED. */
1259 last_random_value
= 0;
1267 gettimeofday (&tv
, NULL
);
1268 sbrand (tv
.tv_sec
^ tv
.tv_usec
^ getpid ());
1272 assign_random (self
, value
, unused
, key
)
1278 sbrand (strtoul (value
, (char **)NULL
, 10));
1279 if (subshell_environment
)
1280 seeded_subshell
= getpid ();
1285 get_random_number ()
1289 /* Reset for command and process substitution. */
1291 if (subshell_environment
&& seeded_subshell
!= pid
)
1294 seeded_subshell
= pid
;
1299 while (rv
== last_random_value
);
1310 rv
= get_random_number ();
1311 last_random_value
= rv
;
1312 fprintf(stderr
, "get_random: rv = %d\n", rv
);
1315 FREE (value_cell (var
));
1317 VSETATTR (var
, att_integer
);
1318 var_setvalue (var
, p
);
1323 assign_lineno (var
, value
, unused
, key
)
1331 if (value
== 0 || *value
== '\0' || legal_number (value
, &new_value
) == 0)
1333 line_number
= new_value
;
1337 /* Function which returns the current line number. */
1345 ln
= executing_line_number ();
1347 FREE (value_cell (var
));
1348 var_setvalue (var
, p
);
1353 assign_subshell (var
, value
, unused
, key
)
1361 if (value
== 0 || *value
== '\0' || legal_number (value
, &new_value
) == 0)
1363 subshell_level
= new_value
;
1373 p
= itos (subshell_level
);
1374 FREE (value_cell (var
));
1375 var_setvalue (var
, p
);
1389 FREE (value_cell (var
));
1390 VSETATTR (var
, att_integer
|att_readonly
);
1391 var_setvalue (var
, p
);
1396 get_bash_command (var
)
1401 if (the_printed_command_except_trap
)
1402 p
= savestring (the_printed_command_except_trap
);
1405 p
= (char *)xmalloc (1);
1408 FREE (value_cell (var
));
1409 var_setvalue (var
, p
);
1413 #if defined (HISTORY)
1420 p
= itos (history_number ());
1421 FREE (value_cell (var
));
1422 var_setvalue (var
, p
);
1427 #if defined (READLINE)
1428 /* When this function returns, VAR->value points to malloced memory. */
1430 get_comp_wordbreaks (var
)
1433 /* If we don't have anything yet, assign a default value. */
1434 if (rl_completer_word_break_characters
== 0 && bash_readline_initialized
== 0)
1435 enable_hostname_completion (perform_hostname_completion
);
1437 FREE (value_cell (var
));
1438 var_setvalue (var
, savestring (rl_completer_word_break_characters
));
1443 /* When this function returns, rl_completer_word_break_characters points to
1446 assign_comp_wordbreaks (self
, value
, unused
, key
)
1452 if (rl_completer_word_break_characters
&&
1453 rl_completer_word_break_characters
!= rl_basic_word_break_characters
)
1454 free (rl_completer_word_break_characters
);
1456 rl_completer_word_break_characters
= savestring (value
);
1459 #endif /* READLINE */
1461 #if defined (PUSHD_AND_POPD) && defined (ARRAY_VARS)
1463 assign_dirstack (self
, value
, ind
, key
)
1469 set_dirstack_element (ind
, 1, value
);
1480 l
= get_directory_stack (0);
1481 a
= array_from_word_list (l
);
1482 array_dispose (array_cell (self
));
1484 var_setarray (self
, a
);
1487 #endif /* PUSHD AND POPD && ARRAY_VARS */
1489 #if defined (ARRAY_VARS)
1490 /* We don't want to initialize the group set with a call to getgroups()
1491 unless we're asked to, but we only want to do it once. */
1499 static char **group_set
= (char **)NULL
;
1503 group_set
= get_group_list (&ng
);
1504 a
= array_cell (self
);
1505 for (i
= 0; i
< ng
; i
++)
1506 array_insert (a
, i
, group_set
[i
]);
1512 build_hashcmd (self
)
1518 BUCKET_CONTENTS
*item
;
1520 h
= assoc_cell (self
);
1524 if (hashed_filenames
== 0 || HASH_ENTRIES (hashed_filenames
) == 0)
1526 var_setvalue (self
, (char *)NULL
);
1530 h
= assoc_create (hashed_filenames
->nbuckets
);
1531 for (i
= 0; i
< hashed_filenames
->nbuckets
; i
++)
1533 for (item
= hash_items (i
, hashed_filenames
); item
; item
= item
->next
)
1535 k
= savestring (item
->key
);
1536 v
= pathdata(item
)->path
;
1537 assoc_insert (h
, k
, v
);
1541 var_setvalue (self
, (char *)h
);
1549 build_hashcmd (self
);
1554 assign_hashcmd (self
, value
, ind
, key
)
1560 phash_insert (key
, value
, 0, 0);
1561 return (build_hashcmd (self
));
1566 build_aliasvar (self
)
1572 BUCKET_CONTENTS
*item
;
1574 h
= assoc_cell (self
);
1578 if (aliases
== 0 || HASH_ENTRIES (aliases
) == 0)
1580 var_setvalue (self
, (char *)NULL
);
1584 h
= assoc_create (aliases
->nbuckets
);
1585 for (i
= 0; i
< aliases
->nbuckets
; i
++)
1587 for (item
= hash_items (i
, aliases
); item
; item
= item
->next
)
1589 k
= savestring (item
->key
);
1590 v
= ((alias_t
*)(item
->data
))->value
;
1591 assoc_insert (h
, k
, v
);
1595 var_setvalue (self
, (char *)h
);
1603 build_aliasvar (self
);
1608 assign_aliasvar (self
, value
, ind
, key
)
1614 add_alias (key
, value
);
1615 return (build_aliasvar (self
));
1619 #endif /* ARRAY_VARS */
1621 /* If ARRAY_VARS is not defined, this just returns the name of any
1622 currently-executing function. If we have arrays, it's a call stack. */
1627 #if ! defined (ARRAY_VARS)
1629 if (variable_context
&& this_shell_function
)
1631 FREE (value_cell (self
));
1632 t
= savestring (this_shell_function
->name
);
1633 var_setvalue (self
, t
);
1640 make_funcname_visible (on_or_off
)
1645 v
= find_variable ("FUNCNAME");
1646 if (v
== 0 || v
->dynamic_value
== 0)
1650 VUNSETATTR (v
, att_invisible
);
1652 VSETATTR (v
, att_invisible
);
1656 init_funcname_var ()
1660 v
= find_variable ("FUNCNAME");
1663 #if defined (ARRAY_VARS)
1664 INIT_DYNAMIC_ARRAY_VAR ("FUNCNAME", get_funcname
, null_array_assign
);
1666 INIT_DYNAMIC_VAR ("FUNCNAME", (char *)NULL
, get_funcname
, null_assign
);
1668 VSETATTR (v
, att_invisible
|att_noassign
);
1673 initialize_dynamic_variables ()
1677 v
= init_seconds_var ();
1679 INIT_DYNAMIC_VAR ("BASH_COMMAND", (char *)NULL
, get_bash_command
, (sh_var_assign_func_t
*)NULL
);
1680 INIT_DYNAMIC_VAR ("BASH_SUBSHELL", (char *)NULL
, get_subshell
, assign_subshell
);
1682 INIT_DYNAMIC_VAR ("RANDOM", (char *)NULL
, get_random
, assign_random
);
1683 VSETATTR (v
, att_integer
);
1684 INIT_DYNAMIC_VAR ("LINENO", (char *)NULL
, get_lineno
, assign_lineno
);
1685 VSETATTR (v
, att_integer
);
1687 INIT_DYNAMIC_VAR ("BASHPID", (char *)NULL
, get_bashpid
, null_assign
);
1688 VSETATTR (v
, att_integer
|att_readonly
);
1690 #if defined (HISTORY)
1691 INIT_DYNAMIC_VAR ("HISTCMD", (char *)NULL
, get_histcmd
, (sh_var_assign_func_t
*)NULL
);
1692 VSETATTR (v
, att_integer
);
1695 #if defined (READLINE)
1696 INIT_DYNAMIC_VAR ("COMP_WORDBREAKS", (char *)NULL
, get_comp_wordbreaks
, assign_comp_wordbreaks
);
1699 #if defined (PUSHD_AND_POPD) && defined (ARRAY_VARS)
1700 v
= init_dynamic_array_var ("DIRSTACK", get_dirstack
, assign_dirstack
, 0);
1701 #endif /* PUSHD_AND_POPD && ARRAY_VARS */
1703 #if defined (ARRAY_VARS)
1704 v
= init_dynamic_array_var ("GROUPS", get_groupset
, null_array_assign
, att_noassign
);
1706 # if defined (DEBUGGER)
1707 v
= init_dynamic_array_var ("BASH_ARGC", get_self
, null_array_assign
, att_noassign
|att_nounset
);
1708 v
= init_dynamic_array_var ("BASH_ARGV", get_self
, null_array_assign
, att_noassign
|att_nounset
);
1709 # endif /* DEBUGGER */
1710 v
= init_dynamic_array_var ("BASH_SOURCE", get_self
, null_array_assign
, att_noassign
|att_nounset
);
1711 v
= init_dynamic_array_var ("BASH_LINENO", get_self
, null_array_assign
, att_noassign
|att_nounset
);
1713 v
= init_dynamic_assoc_var ("BASH_CMDS", get_hashcmd
, assign_hashcmd
, att_nofree
);
1714 # if defined (ALIAS)
1715 v
= init_dynamic_assoc_var ("BASH_ALIASES", get_aliasvar
, assign_aliasvar
, att_nofree
);
1719 v
= init_funcname_var ();
1722 /* **************************************************************** */
1724 /* Retrieving variables and values */
1726 /* **************************************************************** */
1728 /* How to get a pointer to the shell variable or function named NAME.
1729 HASHED_VARS is a pointer to the hash table containing the list
1730 of interest (either variables or functions). */
1733 hash_lookup (name
, hashed_vars
)
1735 HASH_TABLE
*hashed_vars
;
1737 BUCKET_CONTENTS
*bucket
;
1739 bucket
= hash_search (name
, hashed_vars
, 0);
1740 return (bucket
? (SHELL_VAR
*)bucket
->data
: (SHELL_VAR
*)NULL
);
1744 var_lookup (name
, vcontext
)
1746 VAR_CONTEXT
*vcontext
;
1751 v
= (SHELL_VAR
*)NULL
;
1752 for (vc
= vcontext
; vc
; vc
= vc
->down
)
1753 if (v
= hash_lookup (name
, vc
->table
))
1759 /* Look up the variable entry named NAME. If SEARCH_TEMPENV is non-zero,
1760 then also search the temporarily built list of exported variables.
1761 The lookup order is:
1763 shell_variables list
1767 find_variable_internal (name
, force_tempenv
)
1774 var
= (SHELL_VAR
*)NULL
;
1776 /* If explicitly requested, first look in the temporary environment for
1777 the variable. This allows constructs such as "foo=x eval 'echo $foo'"
1778 to get the `exported' value of $foo. This happens if we are executing
1779 a function or builtin, or if we are looking up a variable in a
1780 "subshell environment". */
1781 search_tempenv
= force_tempenv
|| (expanding_redir
== 0 && subshell_environment
);
1783 if (search_tempenv
&& temporary_env
)
1784 var
= hash_lookup (name
, temporary_env
);
1787 var
= var_lookup (name
, shell_variables
);
1790 return ((SHELL_VAR
*)NULL
);
1792 return (var
->dynamic_value
? (*(var
->dynamic_value
)) (var
) : var
);
1795 /* Look up the variable entry named NAME. Returns the entry or NULL. */
1797 find_variable (name
)
1800 return (find_variable_internal (name
, (expanding_redir
== 0 && (assigning_in_environment
|| executing_builtin
))));
1803 /* Look up the function entry whose name matches STRING.
1804 Returns the entry or NULL. */
1806 find_function (name
)
1809 return (hash_lookup (name
, shell_functions
));
1812 /* Find the function definition for the shell function named NAME. Returns
1813 the entry or NULL. */
1815 find_function_def (name
)
1818 #if defined (DEBUGGER)
1819 return ((FUNCTION_DEF
*)hash_lookup (name
, shell_function_defs
));
1821 return ((FUNCTION_DEF
*)0);
1825 /* Return the value of VAR. VAR is assumed to have been the result of a
1826 lookup without any subscript, if arrays are compiled into the shell. */
1828 get_variable_value (var
)
1832 return ((char *)NULL
);
1833 #if defined (ARRAY_VARS)
1834 else if (array_p (var
))
1835 return (array_reference (array_cell (var
), 0));
1836 else if (assoc_p (var
))
1837 return (assoc_reference (assoc_cell (var
), "0"));
1840 return (value_cell (var
));
1843 /* Return the string value of a variable. Return NULL if the variable
1844 doesn't exist. Don't cons a new string. This is a potential memory
1845 leak if the variable is found in the temporary environment. Since
1846 functions and variables have separate name spaces, returns NULL if
1847 var_name is a shell function only. */
1849 get_string_value (var_name
)
1850 const char *var_name
;
1854 var
= find_variable (var_name
);
1855 return ((var
) ? get_variable_value (var
) : (char *)NULL
);
1858 /* This is present for use by the tilde and readline libraries. */
1860 sh_get_env_value (v
)
1863 return get_string_value (v
);
1866 /* **************************************************************** */
1868 /* Creating and setting variables */
1870 /* **************************************************************** */
1872 /* Set NAME to VALUE if NAME has no value. */
1874 set_if_not (name
, value
)
1879 if (shell_variables
== 0)
1880 create_variable_tables ();
1882 v
= find_variable (name
);
1884 v
= bind_variable_internal (name
, value
, global_variables
->table
, HASH_NOSRCH
, 0);
1888 /* Create a local variable referenced by NAME. */
1890 make_local_variable (name
)
1893 SHELL_VAR
*new_var
, *old_var
;
1898 /* local foo; local foo; is a no-op. */
1899 old_var
= find_variable (name
);
1900 if (old_var
&& local_p (old_var
) && old_var
->context
== variable_context
)
1902 VUNSETATTR (old_var
, att_invisible
);
1906 was_tmpvar
= old_var
&& tempvar_p (old_var
);
1908 tmp_value
= value_cell (old_var
);
1910 for (vc
= shell_variables
; vc
; vc
= vc
->down
)
1911 if (vc_isfuncenv (vc
) && vc
->scope
== variable_context
)
1916 internal_error (_("make_local_variable: no function context at current scope"));
1917 return ((SHELL_VAR
*)NULL
);
1919 else if (vc
->table
== 0)
1920 vc
->table
= hash_create (TEMPENV_HASH_BUCKETS
);
1922 /* Since this is called only from the local/declare/typeset code, we can
1923 call builtin_error here without worry (of course, it will also work
1924 for anything that sets this_command_name). Variables with the `noassign'
1925 attribute may not be made local. The test against old_var's context
1926 level is to disallow local copies of readonly global variables (since I
1927 believe that this could be a security hole). Readonly copies of calling
1928 function local variables are OK. */
1929 if (old_var
&& (noassign_p (old_var
) ||
1930 (readonly_p (old_var
) && old_var
->context
== 0)))
1932 if (readonly_p (old_var
))
1934 return ((SHELL_VAR
*)NULL
);
1938 new_var
= make_new_variable (name
, vc
->table
);
1941 new_var
= make_new_variable (name
, vc
->table
);
1943 /* If we found this variable in one of the temporary environments,
1944 inherit its value. Watch to see if this causes problems with
1945 things like `x=4 local x'. */
1947 var_setvalue (new_var
, savestring (tmp_value
));
1949 new_var
->attributes
= exported_p (old_var
) ? att_exported
: 0;
1952 vc
->flags
|= VC_HASLOCAL
;
1954 new_var
->context
= variable_context
;
1955 VSETATTR (new_var
, att_local
);
1963 /* Create a new shell variable with name NAME. */
1965 new_shell_variable (name
)
1970 entry
= (SHELL_VAR
*)xmalloc (sizeof (SHELL_VAR
));
1972 entry
->name
= savestring (name
);
1973 var_setvalue (entry
, (char *)NULL
);
1974 CLEAR_EXPORTSTR (entry
);
1976 entry
->dynamic_value
= (sh_var_value_func_t
*)NULL
;
1977 entry
->assign_func
= (sh_var_assign_func_t
*)NULL
;
1979 entry
->attributes
= 0;
1981 /* Always assume variables are to be made at toplevel!
1982 make_local_variable has the responsibilty of changing the
1983 variable context. */
1989 /* Create a new shell variable with name NAME and add it to the hash table
1992 make_new_variable (name
, table
)
1997 BUCKET_CONTENTS
*elt
;
1999 entry
= new_shell_variable (name
);
2001 /* Make sure we have a shell_variables hash table to add to. */
2002 if (shell_variables
== 0)
2003 create_variable_tables ();
2005 elt
= hash_insert (savestring (name
), table
, HASH_NOSRCH
);
2006 elt
->data
= (PTR_T
)entry
;
2011 #if defined (ARRAY_VARS)
2013 make_new_array_variable (name
)
2019 entry
= make_new_variable (name
, global_variables
->table
);
2020 array
= array_create ();
2022 var_setarray (entry
, array
);
2023 VSETATTR (entry
, att_array
);
2028 make_local_array_variable (name
)
2034 var
= make_local_variable (name
);
2035 if (var
== 0 || array_p (var
))
2038 array
= array_create ();
2040 dispose_variable_value (var
);
2041 var_setarray (var
, array
);
2042 VSETATTR (var
, att_array
);
2047 make_new_assoc_variable (name
)
2053 entry
= make_new_variable (name
, global_variables
->table
);
2054 hash
= assoc_create (0);
2056 var_setassoc (entry
, hash
);
2057 VSETATTR (entry
, att_assoc
);
2062 make_local_assoc_variable (name
)
2068 var
= make_local_variable (name
);
2069 if (var
== 0 || assoc_p (var
))
2072 dispose_variable_value (var
);
2073 hash
= assoc_create (0);
2075 var_setassoc (var
, hash
);
2076 VSETATTR (var
, att_assoc
);
2082 make_variable_value (var
, value
, flags
)
2087 char *retval
, *oval
;
2088 intmax_t lval
, rval
;
2089 int expok
, olen
, op
;
2091 /* If this variable has had its type set to integer (via `declare -i'),
2092 then do expression evaluation on it and store the result. The
2093 functions in expr.c (evalexp()) and bind_int_variable() are responsible
2094 for turning off the integer flag if they don't want further
2096 if (integer_p (var
))
2098 if (flags
& ASS_APPEND
)
2100 oval
= value_cell (var
);
2101 lval
= evalexp (oval
, &expok
); /* ksh93 seems to do this */
2104 top_level_cleanup ();
2105 jump_to_top_level (DISCARD
);
2108 rval
= evalexp (value
, &expok
);
2111 top_level_cleanup ();
2112 jump_to_top_level (DISCARD
);
2114 if (flags
& ASS_APPEND
)
2116 retval
= itos (rval
);
2118 #if defined (CASEMOD_ATTRS)
2119 else if (capcase_p (var
) || uppercase_p (var
) || lowercase_p (var
))
2121 if (flags
& ASS_APPEND
)
2123 oval
= get_variable_value (var
);
2124 if (oval
== 0) /* paranoia */
2126 olen
= STRLEN (oval
);
2127 retval
= (char *)xmalloc (olen
+ (value
? STRLEN (value
) : 0) + 1);
2128 strcpy (retval
, oval
);
2130 strcpy (retval
+olen
, value
);
2133 retval
= savestring (value
);
2136 retval
= (char *)xmalloc (1);
2139 op
= capcase_p (var
) ? CASE_CAPITALIZE
2140 : (uppercase_p (var
) ? CASE_UPPER
: CASE_LOWER
);
2141 oval
= sh_modcase (retval
, (char *)0, op
);
2145 #endif /* CASEMOD_ATTRS */
2148 if (flags
& ASS_APPEND
)
2150 oval
= get_variable_value (var
);
2151 if (oval
== 0) /* paranoia */
2153 olen
= STRLEN (oval
);
2154 retval
= (char *)xmalloc (olen
+ (value
? STRLEN (value
) : 0) + 1);
2155 strcpy (retval
, oval
);
2157 strcpy (retval
+olen
, value
);
2160 retval
= savestring (value
);
2163 retval
= (char *)xmalloc (1);
2168 retval
= (char *)NULL
;
2173 /* Bind a variable NAME to VALUE in the HASH_TABLE TABLE, which may be the
2174 temporary environment (but usually is not). */
2176 bind_variable_internal (name
, value
, table
, hflags
, aflags
)
2185 entry
= (hflags
& HASH_NOSRCH
) ? (SHELL_VAR
*)NULL
: hash_lookup (name
, table
);
2189 entry
= make_new_variable (name
, table
);
2190 var_setvalue (entry
, make_variable_value (entry
, value
, 0)); /* XXX */
2192 else if (entry
->assign_func
) /* array vars have assign functions now */
2194 INVALIDATE_EXPORTSTR (entry
);
2195 newval
= (aflags
& ASS_APPEND
) ? make_variable_value (entry
, value
, aflags
) : value
;
2196 if (assoc_p (entry
))
2197 entry
= (*(entry
->assign_func
)) (entry
, newval
, -1, savestring ("0"));
2198 else if (array_p (entry
))
2199 entry
= (*(entry
->assign_func
)) (entry
, newval
, 0, 0);
2201 entry
= (*(entry
->assign_func
)) (entry
, newval
, -1, 0);
2202 if (newval
!= value
)
2208 if (readonly_p (entry
) || noassign_p (entry
))
2210 if (readonly_p (entry
))
2211 err_readonly (name
);
2215 /* Variables which are bound are visible. */
2216 VUNSETATTR (entry
, att_invisible
);
2218 newval
= make_variable_value (entry
, value
, aflags
); /* XXX */
2220 /* Invalidate any cached export string */
2221 INVALIDATE_EXPORTSTR (entry
);
2223 #if defined (ARRAY_VARS)
2224 /* XXX -- this bears looking at again -- XXX */
2225 /* If an existing array variable x is being assigned to with x=b or
2226 `read x' or something of that nature, silently convert it to
2227 x[0]=b or `read x[0]'. */
2228 if (array_p (entry
))
2230 array_insert (array_cell (entry
), 0, newval
);
2233 else if (assoc_p (entry
))
2235 assoc_insert (assoc_cell (entry
), savestring ("0"), newval
);
2241 FREE (value_cell (entry
));
2242 var_setvalue (entry
, newval
);
2246 if (mark_modified_vars
)
2247 VSETATTR (entry
, att_exported
);
2249 if (exported_p (entry
))
2250 array_needs_making
= 1;
2255 /* Bind a variable NAME to VALUE. This conses up the name
2256 and value strings. If we have a temporary environment, we bind there
2257 first, then we bind into shell_variables. */
2260 bind_variable (name
, value
, flags
)
2268 if (shell_variables
== 0)
2269 create_variable_tables ();
2271 /* If we have a temporary environment, look there first for the variable,
2272 and, if found, modify the value there before modifying it in the
2273 shell_variables table. This allows sourced scripts to modify values
2274 given to them in a temporary environment while modifying the variable
2275 value that the caller sees. */
2277 bind_tempenv_variable (name
, value
);
2279 /* XXX -- handle local variables here. */
2280 for (vc
= shell_variables
; vc
; vc
= vc
->down
)
2282 if (vc_isfuncenv (vc
) || vc_isbltnenv (vc
))
2284 v
= hash_lookup (name
, vc
->table
);
2286 return (bind_variable_internal (name
, value
, vc
->table
, 0, flags
));
2289 return (bind_variable_internal (name
, value
, global_variables
->table
, 0, flags
));
2292 /* Make VAR, a simple shell variable, have value VALUE. Once assigned a
2293 value, variables are no longer invisible. This is a duplicate of part
2294 of the internals of bind_variable. If the variable is exported, or
2295 all modified variables should be exported, mark the variable for export
2296 and note that the export environment needs to be recreated. */
2298 bind_variable_value (var
, value
, aflags
)
2305 VUNSETATTR (var
, att_invisible
);
2307 if (var
->assign_func
)
2309 /* If we're appending, we need the old value, so use
2310 make_variable_value */
2311 t
= (aflags
& ASS_APPEND
) ? make_variable_value (var
, value
, aflags
) : value
;
2312 (*(var
->assign_func
)) (var
, t
, -1, 0);
2313 if (t
!= value
&& t
)
2318 t
= make_variable_value (var
, value
, aflags
);
2319 FREE (value_cell (var
));
2320 var_setvalue (var
, t
);
2323 INVALIDATE_EXPORTSTR (var
);
2325 if (mark_modified_vars
)
2326 VSETATTR (var
, att_exported
);
2328 if (exported_p (var
))
2329 array_needs_making
= 1;
2334 /* Bind/create a shell variable with the name LHS to the RHS.
2335 This creates or modifies a variable such that it is an integer.
2337 This used to be in expr.c, but it is here so that all of the
2338 variable binding stuff is localized. Since we don't want any
2339 recursive evaluation from bind_variable() (possible without this code,
2340 since bind_variable() calls the evaluator for variables with the integer
2341 attribute set), we temporarily turn off the integer attribute for each
2342 variable we set here, then turn it back on after binding as necessary. */
2345 bind_int_variable (lhs
, rhs
)
2348 register SHELL_VAR
*v
;
2352 #if defined (ARRAY_VARS)
2353 if (valid_array_reference (lhs
))
2356 v
= array_variable_part (lhs
, (char **)0, (int *)0);
2360 v
= find_variable (lhs
);
2364 isint
= integer_p (v
);
2365 VUNSETATTR (v
, att_integer
);
2368 #if defined (ARRAY_VARS)
2370 v
= assign_array_element (lhs
, rhs
, 0);
2373 v
= bind_variable (lhs
, rhs
, 0);
2376 VSETATTR (v
, att_integer
);
2382 bind_var_to_int (var
, val
)
2386 char ibuf
[INT_STRLEN_BOUND (intmax_t) + 1], *p
;
2388 p
= fmtulong (val
, 10, ibuf
, sizeof (ibuf
), 0);
2389 return (bind_int_variable (var
, p
));
2392 /* Do a function binding to a variable. You pass the name and
2393 the command to bind to. This conses the name and command. */
2395 bind_function (name
, value
)
2401 entry
= find_function (name
);
2404 BUCKET_CONTENTS
*elt
;
2406 elt
= hash_insert (savestring (name
), shell_functions
, HASH_NOSRCH
);
2407 entry
= new_shell_variable (name
);
2408 elt
->data
= (PTR_T
)entry
;
2411 INVALIDATE_EXPORTSTR (entry
);
2413 if (var_isset (entry
))
2414 dispose_command (function_cell (entry
));
2417 var_setfunc (entry
, copy_command (value
));
2419 var_setfunc (entry
, 0);
2421 VSETATTR (entry
, att_function
);
2423 if (mark_modified_vars
)
2424 VSETATTR (entry
, att_exported
);
2426 VUNSETATTR (entry
, att_invisible
); /* Just to be sure */
2428 if (exported_p (entry
))
2429 array_needs_making
= 1;
2431 #if defined (PROGRAMMABLE_COMPLETION)
2432 set_itemlist_dirty (&it_functions
);
2438 #if defined (DEBUGGER)
2439 /* Bind a function definition, which includes source file and line number
2440 information in addition to the command, into the FUNCTION_DEF hash table.*/
2442 bind_function_def (name
, value
)
2444 FUNCTION_DEF
*value
;
2446 FUNCTION_DEF
*entry
;
2447 BUCKET_CONTENTS
*elt
;
2450 entry
= find_function_def (name
);
2453 dispose_function_def_contents (entry
);
2454 entry
= copy_function_def_contents (value
, entry
);
2458 cmd
= value
->command
;
2460 entry
= copy_function_def (value
);
2461 value
->command
= cmd
;
2463 elt
= hash_insert (savestring (name
), shell_function_defs
, HASH_NOSRCH
);
2464 elt
->data
= (PTR_T
*)entry
;
2467 #endif /* DEBUGGER */
2469 /* Add STRING, which is of the form foo=bar, to the temporary environment
2470 HASH_TABLE (temporary_env). The functions in execute_cmd.c are
2471 responsible for moving the main temporary env to one of the other
2472 temporary environments. The expansion code in subst.c calls this. */
2474 assign_in_env (word
)
2478 char *name
, *temp
, *value
;
2482 string
= word
->word
;
2484 offset
= assignment (string
, 0);
2485 name
= savestring (string
);
2486 value
= (char *)NULL
;
2488 if (name
[offset
] == '=')
2492 /* ignore the `+' when assigning temporary environment */
2493 if (name
[offset
- 1] == '+')
2494 name
[offset
- 1] = '\0';
2496 var
= find_variable (name
);
2497 if (var
&& (readonly_p (var
) || noassign_p (var
)))
2499 if (readonly_p (var
))
2500 err_readonly (name
);
2505 temp
= name
+ offset
+ 1;
2506 value
= expand_assignment_string_to_string (temp
, 0);
2509 if (temporary_env
== 0)
2510 temporary_env
= hash_create (TEMPENV_HASH_BUCKETS
);
2512 var
= hash_lookup (name
, temporary_env
);
2514 var
= make_new_variable (name
, temporary_env
);
2516 FREE (value_cell (var
));
2520 value
= (char *)xmalloc (1); /* like do_assignment_internal */
2524 var_setvalue (var
, value
);
2525 var
->attributes
|= (att_exported
|att_tempvar
);
2526 var
->context
= variable_context
; /* XXX */
2528 INVALIDATE_EXPORTSTR (var
);
2529 var
->exportstr
= mk_env_string (name
, value
);
2531 array_needs_making
= 1;
2536 if (echo_command_at_execute
)
2537 /* The Korn shell prints the `+ ' in front of assignment statements,
2539 xtrace_print_assignment (name
, value
, 0, 1);
2545 /* **************************************************************** */
2547 /* Copying variables */
2549 /* **************************************************************** */
2551 #ifdef INCLUDE_UNUSED
2552 /* Copy VAR to a new data structure and return that structure. */
2557 SHELL_VAR
*copy
= (SHELL_VAR
*)NULL
;
2561 copy
= (SHELL_VAR
*)xmalloc (sizeof (SHELL_VAR
));
2563 copy
->attributes
= var
->attributes
;
2564 copy
->name
= savestring (var
->name
);
2566 if (function_p (var
))
2567 var_setfunc (copy
, copy_command (function_cell (var
)));
2568 #if defined (ARRAY_VARS)
2569 else if (array_p (var
))
2570 var_setarray (copy
, array_copy (array_cell (var
)));
2571 else if (assoc_p (var
))
2572 var_setassoc (copy
, assoc_copy (assoc_cell (var
)));
2574 else if (value_cell (var
))
2575 var_setvalue (copy
, savestring (value_cell (var
)));
2577 var_setvalue (copy
, (char *)NULL
);
2579 copy
->dynamic_value
= var
->dynamic_value
;
2580 copy
->assign_func
= var
->assign_func
;
2582 copy
->exportstr
= COPY_EXPORTSTR (var
);
2584 copy
->context
= var
->context
;
2590 /* **************************************************************** */
2592 /* Deleting and unsetting variables */
2594 /* **************************************************************** */
2596 /* Dispose of the information attached to VAR. */
2598 dispose_variable_value (var
)
2601 if (function_p (var
))
2602 dispose_command (function_cell (var
));
2603 #if defined (ARRAY_VARS)
2604 else if (array_p (var
))
2605 array_dispose (array_cell (var
));
2606 else if (assoc_p (var
))
2607 assoc_dispose (assoc_cell (var
));
2610 FREE (value_cell (var
));
2614 dispose_variable (var
)
2620 if (nofree_p (var
) == 0)
2621 dispose_variable_value (var
);
2623 FREE_EXPORTSTR (var
);
2627 if (exported_p (var
))
2628 array_needs_making
= 1;
2633 /* Unset the shell variable referenced by NAME. */
2635 unbind_variable (name
)
2638 return makunbound (name
, shell_variables
);
2641 /* Unset the shell function named NAME. */
2646 BUCKET_CONTENTS
*elt
;
2649 elt
= hash_remove (name
, shell_functions
, 0);
2654 #if defined (PROGRAMMABLE_COMPLETION)
2655 set_itemlist_dirty (&it_functions
);
2658 func
= (SHELL_VAR
*)elt
->data
;
2661 if (exported_p (func
))
2662 array_needs_making
++;
2663 dispose_variable (func
);
2672 #if defined (DEBUGGER)
2674 unbind_function_def (name
)
2677 BUCKET_CONTENTS
*elt
;
2678 FUNCTION_DEF
*funcdef
;
2680 elt
= hash_remove (name
, shell_function_defs
, 0);
2685 funcdef
= (FUNCTION_DEF
*)elt
->data
;
2687 dispose_function_def (funcdef
);
2694 #endif /* DEBUGGER */
2696 /* Make the variable associated with NAME go away. HASH_LIST is the
2697 hash table from which this variable should be deleted (either
2698 shell_variables or shell_functions).
2699 Returns non-zero if the variable couldn't be found. */
2701 makunbound (name
, vc
)
2705 BUCKET_CONTENTS
*elt
, *new_elt
;
2710 for (elt
= (BUCKET_CONTENTS
*)NULL
, v
= vc
; v
; v
= v
->down
)
2711 if (elt
= hash_remove (name
, v
->table
, 0))
2717 old_var
= (SHELL_VAR
*)elt
->data
;
2719 if (old_var
&& exported_p (old_var
))
2720 array_needs_making
++;
2722 /* If we're unsetting a local variable and we're still executing inside
2723 the function, just mark the variable as invisible. The function
2724 eventually called by pop_var_context() will clean it up later. This
2725 must be done so that if the variable is subsequently assigned a new
2726 value inside the function, the `local' attribute is still present.
2727 We also need to add it back into the correct hash table. */
2728 if (old_var
&& local_p (old_var
) && variable_context
== old_var
->context
)
2730 if (nofree_p (old_var
))
2731 var_setvalue (old_var
, (char *)NULL
);
2732 #if defined (ARRAY_VARS)
2733 else if (array_p (old_var
))
2734 array_dispose (array_cell (old_var
));
2735 else if (assoc_p (old_var
))
2736 assoc_dispose (assoc_cell (old_var
));
2739 FREE (value_cell (old_var
));
2740 /* Reset the attributes. Preserve the export attribute if the variable
2741 came from a temporary environment. Make sure it stays local, and
2742 make it invisible. */
2743 old_var
->attributes
= (exported_p (old_var
) && tempvar_p (old_var
)) ? att_exported
: 0;
2744 VSETATTR (old_var
, att_local
);
2745 VSETATTR (old_var
, att_invisible
);
2746 var_setvalue (old_var
, (char *)NULL
);
2747 INVALIDATE_EXPORTSTR (old_var
);
2749 new_elt
= hash_insert (savestring (old_var
->name
), v
->table
, 0);
2750 new_elt
->data
= (PTR_T
)old_var
;
2751 stupidly_hack_special_variables (old_var
->name
);
2758 /* Have to save a copy of name here, because it might refer to
2759 old_var->name. If so, stupidly_hack_special_variables will
2760 reference freed memory. */
2761 t
= savestring (name
);
2766 dispose_variable (old_var
);
2767 stupidly_hack_special_variables (t
);
2773 /* Get rid of all of the variables in the current context. */
2775 kill_all_local_variables ()
2779 for (vc
= shell_variables
; vc
; vc
= vc
->down
)
2780 if (vc_isfuncenv (vc
) && vc
->scope
== variable_context
)
2785 if (vc
->table
&& vc_haslocals (vc
))
2787 delete_all_variables (vc
->table
);
2788 hash_dispose (vc
->table
);
2790 vc
->table
= (HASH_TABLE
*)NULL
;
2794 free_variable_hash_data (data
)
2799 var
= (SHELL_VAR
*)data
;
2800 dispose_variable (var
);
2803 /* Delete the entire contents of the hash table. */
2805 delete_all_variables (hashed_vars
)
2806 HASH_TABLE
*hashed_vars
;
2808 hash_flush (hashed_vars
, free_variable_hash_data
);
2811 /* **************************************************************** */
2813 /* Setting variable attributes */
2815 /* **************************************************************** */
2817 #define FIND_OR_MAKE_VARIABLE(name, entry) \
2820 entry = find_variable (name); \
2823 entry = bind_variable (name, "", 0); \
2824 if (!no_invisible_vars) entry->attributes |= att_invisible; \
2829 /* Make the variable associated with NAME be readonly.
2830 If NAME does not exist yet, create it. */
2832 set_var_read_only (name
)
2837 FIND_OR_MAKE_VARIABLE (name
, entry
);
2838 VSETATTR (entry
, att_readonly
);
2841 #ifdef INCLUDE_UNUSED
2842 /* Make the function associated with NAME be readonly.
2843 If NAME does not exist, we just punt, like auto_export code below. */
2845 set_func_read_only (name
)
2850 entry
= find_function (name
);
2852 VSETATTR (entry
, att_readonly
);
2855 /* Make the variable associated with NAME be auto-exported.
2856 If NAME does not exist yet, create it. */
2858 set_var_auto_export (name
)
2863 FIND_OR_MAKE_VARIABLE (name
, entry
);
2864 set_auto_export (entry
);
2867 /* Make the function associated with NAME be auto-exported. */
2869 set_func_auto_export (name
)
2874 entry
= find_function (name
);
2876 set_auto_export (entry
);
2880 /* **************************************************************** */
2882 /* Creating lists of variables */
2884 /* **************************************************************** */
2887 vlist_alloc (nentries
)
2892 vlist
= (VARLIST
*)xmalloc (sizeof (VARLIST
));
2893 vlist
->list
= (SHELL_VAR
**)xmalloc ((nentries
+ 1) * sizeof (SHELL_VAR
*));
2894 vlist
->list_size
= nentries
;
2895 vlist
->list_len
= 0;
2896 vlist
->list
[0] = (SHELL_VAR
*)NULL
;
2902 vlist_realloc (vlist
, n
)
2907 return (vlist
= vlist_alloc (n
));
2908 if (n
> vlist
->list_size
)
2910 vlist
->list_size
= n
;
2911 vlist
->list
= (SHELL_VAR
**)xrealloc (vlist
->list
, (vlist
->list_size
+ 1) * sizeof (SHELL_VAR
*));
2917 vlist_add (vlist
, var
, flags
)
2924 for (i
= 0; i
< vlist
->list_len
; i
++)
2925 if (STREQ (var
->name
, vlist
->list
[i
]->name
))
2927 if (i
< vlist
->list_len
)
2930 if (i
>= vlist
->list_size
)
2931 vlist
= vlist_realloc (vlist
, vlist
->list_size
+ 16);
2933 vlist
->list
[vlist
->list_len
++] = var
;
2934 vlist
->list
[vlist
->list_len
] = (SHELL_VAR
*)NULL
;
2937 /* Map FUNCTION over the variables in VAR_HASH_TABLE. Return an array of the
2938 variables for which FUNCTION returns a non-zero value. A NULL value
2939 for FUNCTION means to use all variables. */
2941 map_over (function
, vc
)
2942 sh_var_map_func_t
*function
;
2950 for (nentries
= 0, v
= vc
; v
; v
= v
->down
)
2951 nentries
+= HASH_ENTRIES (v
->table
);
2954 return (SHELL_VAR
**)NULL
;
2956 vlist
= vlist_alloc (nentries
);
2958 for (v
= vc
; v
; v
= v
->down
)
2959 flatten (v
->table
, function
, vlist
, 0);
2967 map_over_funcs (function
)
2968 sh_var_map_func_t
*function
;
2973 if (shell_functions
== 0 || HASH_ENTRIES (shell_functions
) == 0)
2974 return ((SHELL_VAR
**)NULL
);
2976 vlist
= vlist_alloc (HASH_ENTRIES (shell_functions
));
2978 flatten (shell_functions
, function
, vlist
, 0);
2985 /* Flatten VAR_HASH_TABLE, applying FUNC to each member and adding those
2986 elements for which FUNC succeeds to VLIST->list. FLAGS is reserved
2987 for future use. Only unique names are added to VLIST. If FUNC is
2988 NULL, each variable in VAR_HASH_TABLE is added to VLIST. If VLIST is
2989 NULL, FUNC is applied to each SHELL_VAR in VAR_HASH_TABLE. If VLIST
2990 and FUNC are both NULL, nothing happens. */
2992 flatten (var_hash_table
, func
, vlist
, flags
)
2993 HASH_TABLE
*var_hash_table
;
2994 sh_var_map_func_t
*func
;
2999 register BUCKET_CONTENTS
*tlist
;
3003 if (var_hash_table
== 0 || (HASH_ENTRIES (var_hash_table
) == 0) || (vlist
== 0 && func
== 0))
3006 for (i
= 0; i
< var_hash_table
->nbuckets
; i
++)
3008 for (tlist
= hash_items (i
, var_hash_table
); tlist
; tlist
= tlist
->next
)
3010 var
= (SHELL_VAR
*)tlist
->data
;
3012 r
= func
? (*func
) (var
) : 1;
3014 vlist_add (vlist
, var
, flags
);
3020 sort_variables (array
)
3023 qsort (array
, strvec_len ((char **)array
), sizeof (SHELL_VAR
*), (QSFUNC
*)qsort_var_comp
);
3027 qsort_var_comp (var1
, var2
)
3028 SHELL_VAR
**var1
, **var2
;
3032 if ((result
= (*var1
)->name
[0] - (*var2
)->name
[0]) == 0)
3033 result
= strcmp ((*var1
)->name
, (*var2
)->name
);
3038 /* Apply FUNC to each variable in SHELL_VARIABLES, adding each one for
3039 which FUNC succeeds to an array of SHELL_VAR *s. Returns the array. */
3042 sh_var_map_func_t
*func
;
3046 list
= map_over (func
, shell_variables
);
3047 if (list
/* && posixly_correct */)
3048 sort_variables (list
);
3052 /* Apply FUNC to each variable in SHELL_FUNCTIONS, adding each one for
3053 which FUNC succeeds to an array of SHELL_VAR *s. Returns the array. */
3056 sh_var_map_func_t
*func
;
3060 list
= map_over_funcs (func
);
3061 if (list
/* && posixly_correct */)
3062 sort_variables (list
);
3066 /* Create a NULL terminated array of all the shell variables. */
3068 all_shell_variables ()
3070 return (vapply ((sh_var_map_func_t
*)NULL
));
3073 /* Create a NULL terminated array of all the shell functions. */
3075 all_shell_functions ()
3077 return (fapply ((sh_var_map_func_t
*)NULL
));
3084 return (invisible_p (var
) == 0);
3088 all_visible_functions ()
3090 return (fapply (visible_var
));
3094 all_visible_variables ()
3096 return (vapply (visible_var
));
3099 /* Return non-zero if the variable VAR is visible and exported. Array
3100 variables cannot be exported. */
3102 visible_and_exported (var
)
3105 return (invisible_p (var
) == 0 && exported_p (var
));
3108 /* Candidate variables for the export environment are either valid variables
3109 with the export attribute or invalid variables inherited from the initial
3110 environment and simply passed through. */
3112 export_environment_candidate (var
)
3115 return (exported_p (var
) && (invisible_p (var
) == 0 || imported_p (var
)));
3118 /* Return non-zero if VAR is a local variable in the current context and
3121 local_and_exported (var
)
3124 return (invisible_p (var
) == 0 && local_p (var
) && var
->context
== variable_context
&& exported_p (var
));
3128 all_exported_variables ()
3130 return (vapply (visible_and_exported
));
3134 local_exported_variables ()
3136 return (vapply (local_and_exported
));
3140 variable_in_context (var
)
3143 return (invisible_p (var
) == 0 && local_p (var
) && var
->context
== variable_context
);
3147 all_local_variables ()
3153 vc
= shell_variables
;
3154 for (vc
= shell_variables
; vc
; vc
= vc
->down
)
3155 if (vc_isfuncenv (vc
) && vc
->scope
== variable_context
)
3160 internal_error (_("all_local_variables: no function context at current scope"));
3161 return (SHELL_VAR
**)NULL
;
3163 if (vc
->table
== 0 || HASH_ENTRIES (vc
->table
) == 0 || vc_haslocals (vc
) == 0)
3164 return (SHELL_VAR
**)NULL
;
3166 vlist
= vlist_alloc (HASH_ENTRIES (vc
->table
));
3168 flatten (vc
->table
, variable_in_context
, vlist
, 0);
3173 sort_variables (ret
);
3177 #if defined (ARRAY_VARS)
3178 /* Return non-zero if the variable VAR is visible and an array. */
3180 visible_array_vars (var
)
3183 return (invisible_p (var
) == 0 && array_p (var
));
3187 all_array_variables ()
3189 return (vapply (visible_array_vars
));
3191 #endif /* ARRAY_VARS */
3194 all_variables_matching_prefix (prefix
)
3197 SHELL_VAR
**varlist
;
3199 int vind
, rind
, plen
;
3201 plen
= STRLEN (prefix
);
3202 varlist
= all_visible_variables ();
3203 for (vind
= 0; varlist
&& varlist
[vind
]; vind
++)
3205 if (varlist
== 0 || vind
== 0)
3206 return ((char **)NULL
);
3207 rlist
= strvec_create (vind
+ 1);
3208 for (vind
= rind
= 0; varlist
[vind
]; vind
++)
3210 if (plen
== 0 || STREQN (prefix
, varlist
[vind
]->name
, plen
))
3211 rlist
[rind
++] = savestring (varlist
[vind
]->name
);
3213 rlist
[rind
] = (char *)0;
3219 /* **************************************************************** */
3221 /* Managing temporary variable scopes */
3223 /* **************************************************************** */
3225 /* Make variable NAME have VALUE in the temporary environment. */
3227 bind_tempenv_variable (name
, value
)
3233 var
= temporary_env
? hash_lookup (name
, temporary_env
) : (SHELL_VAR
*)NULL
;
3237 FREE (value_cell (var
));
3238 var_setvalue (var
, savestring (value
));
3239 INVALIDATE_EXPORTSTR (var
);
3245 /* Find a variable in the temporary environment that is named NAME.
3246 Return the SHELL_VAR *, or NULL if not found. */
3248 find_tempenv_variable (name
)
3251 return (temporary_env
? hash_lookup (name
, temporary_env
) : (SHELL_VAR
*)NULL
);
3254 /* Push the variable described by (SHELL_VAR *)DATA down to the next
3255 variable context from the temporary environment. */
3257 push_temp_var (data
)
3261 HASH_TABLE
*binding_table
;
3263 var
= (SHELL_VAR
*)data
;
3265 binding_table
= shell_variables
->table
;
3266 if (binding_table
== 0)
3268 if (shell_variables
== global_variables
)
3269 /* shouldn't happen */
3270 binding_table
= shell_variables
->table
= global_variables
->table
= hash_create (0);
3272 binding_table
= shell_variables
->table
= hash_create (TEMPENV_HASH_BUCKETS
);
3275 v
= bind_variable_internal (var
->name
, value_cell (var
), binding_table
, 0, 0);
3277 /* XXX - should we set the context here? It shouldn't matter because of how
3278 assign_in_env works, but might want to check. */
3279 if (binding_table
== global_variables
->table
) /* XXX */
3280 var
->attributes
&= ~(att_tempvar
|att_propagate
);
3283 var
->attributes
|= att_propagate
;
3284 if (binding_table
== shell_variables
->table
)
3285 shell_variables
->flags
|= VC_HASTMPVAR
;
3287 v
->attributes
|= var
->attributes
;
3289 dispose_variable (var
);
3293 propagate_temp_var (data
)
3298 var
= (SHELL_VAR
*)data
;
3299 if (tempvar_p (var
) && (var
->attributes
& att_propagate
))
3300 push_temp_var (data
);
3302 dispose_variable (var
);
3305 /* Free the storage used in the hash table for temporary
3306 environment variables. PUSHF is a function to be called
3307 to free each hash table entry. It takes care of pushing variables
3308 to previous scopes if appropriate. */
3310 dispose_temporary_env (pushf
)
3311 sh_free_func_t
*pushf
;
3313 hash_flush (temporary_env
, pushf
);
3314 hash_dispose (temporary_env
);
3315 temporary_env
= (HASH_TABLE
*)NULL
;
3317 array_needs_making
= 1;
3319 sv_ifs ("IFS"); /* XXX here for now */
3323 dispose_used_env_vars ()
3327 dispose_temporary_env (propagate_temp_var
);
3328 maybe_make_export_env ();
3332 /* Take all of the shell variables in the temporary environment HASH_TABLE
3333 and make shell variables from them at the current variable context. */
3335 merge_temporary_env ()
3338 dispose_temporary_env (push_temp_var
);
3341 /* **************************************************************** */
3343 /* Creating and manipulating the environment */
3345 /* **************************************************************** */
3347 static inline char *
3348 mk_env_string (name
, value
)
3349 const char *name
, *value
;
3351 int name_len
, value_len
;
3354 name_len
= strlen (name
);
3355 value_len
= STRLEN (value
);
3356 p
= (char *)xmalloc (2 + name_len
+ value_len
);
3359 if (value
&& *value
)
3360 strcpy (p
+ name_len
+ 1, value
);
3362 p
[name_len
+ 1] = '\0';
3377 internal_error (_("%s has null exportstr"), v
->name
);
3380 if (legal_variable_starter ((unsigned char)*s
) == 0)
3382 internal_error (_("invalid character %d in exportstr for %s"), *s
, v
->name
);
3385 for (s
= v
->exportstr
+ 1; s
&& *s
; s
++)
3389 if (legal_variable_char ((unsigned char)*s
) == 0)
3391 internal_error (_("invalid character %d in exportstr for %s"), *s
, v
->name
);
3397 internal_error (_("no `=' in exportstr for %s"), v
->name
);
3405 make_env_array_from_var_list (vars
)
3408 register int i
, list_index
;
3409 register SHELL_VAR
*var
;
3410 char **list
, *value
;
3412 list
= strvec_create ((1 + strvec_len ((char **)vars
)));
3414 #define USE_EXPORTSTR (value == var->exportstr)
3416 for (i
= 0, list_index
= 0; var
= vars
[i
]; i
++)
3418 #if defined (__CYGWIN__)
3419 /* We don't use the exportstr stuff on Cygwin at all. */
3420 INVALIDATE_EXPORTSTR (var
);
3423 value
= var
->exportstr
;
3424 else if (function_p (var
))
3425 value
= named_function_string ((char *)NULL
, function_cell (var
), 0);
3426 #if defined (ARRAY_VARS)
3427 else if (array_p (var
))
3429 value
= array_to_assignment_string (array_cell (var
));
3431 continue; /* XXX array vars cannot yet be exported */
3433 else if (assoc_p (var
))
3435 value
= assoc_to_assignment_string (assoc_cell (var
));
3437 continue; /* XXX associative array vars cannot yet be exported */
3441 value
= value_cell (var
);
3445 /* Gee, I'd like to get away with not using savestring() if we're
3446 using the cached exportstr... */
3447 list
[list_index
] = USE_EXPORTSTR
? savestring (value
)
3448 : mk_env_string (var
->name
, value
);
3450 if (USE_EXPORTSTR
== 0)
3451 SAVE_EXPORTSTR (var
, list
[list_index
]);
3454 #undef USE_EXPORTSTR
3457 #if defined (ARRAY_VARS)
3458 if (array_p (var
) || assoc_p (var
))
3465 list
[list_index
] = (char *)NULL
;
3469 /* Make an array of assignment statements from the hash table
3470 HASHED_VARS which contains SHELL_VARs. Only visible, exported
3471 variables are eligible. */
3473 make_var_export_array (vcxt
)
3480 vars
= map_over (visible_and_exported
, vcxt
);
3482 vars
= map_over (export_environment_candidate
, vcxt
);
3486 return (char **)NULL
;
3488 list
= make_env_array_from_var_list (vars
);
3495 make_func_export_array ()
3500 vars
= map_over_funcs (visible_and_exported
);
3502 return (char **)NULL
;
3504 list
= make_env_array_from_var_list (vars
);
3510 /* Add ENVSTR to the end of the exported environment, EXPORT_ENV. */
3511 #define add_to_export_env(envstr,do_alloc) \
3514 if (export_env_index >= (export_env_size - 1)) \
3516 export_env_size += 16; \
3517 export_env = strvec_resize (export_env, export_env_size); \
3518 environ = export_env; \
3520 export_env[export_env_index++] = (do_alloc) ? savestring (envstr) : envstr; \
3521 export_env[export_env_index] = (char *)NULL; \
3524 /* Add ASSIGN to EXPORT_ENV, or supercede a previous assignment in the
3525 array with the same left-hand side. Return the new EXPORT_ENV. */
3527 add_or_supercede_exported_var (assign
, do_alloc
)
3534 equal_offset
= assignment (assign
, 0);
3535 if (equal_offset
== 0)
3536 return (export_env
);
3538 /* If this is a function, then only supersede the function definition.
3539 We do this by including the `=() {' in the comparison, like
3540 initialize_shell_variables does. */
3541 if (assign
[equal_offset
+ 1] == '(' &&
3542 strncmp (assign
+ equal_offset
+ 2, ") {", 3) == 0) /* } */
3545 for (i
= 0; i
< export_env_index
; i
++)
3547 if (STREQN (assign
, export_env
[i
], equal_offset
+ 1))
3549 free (export_env
[i
]);
3550 export_env
[i
] = do_alloc
? savestring (assign
) : assign
;
3551 return (export_env
);
3554 add_to_export_env (assign
, do_alloc
);
3555 return (export_env
);
3559 add_temp_array_to_env (temp_array
, do_alloc
, do_supercede
)
3561 int do_alloc
, do_supercede
;
3565 if (temp_array
== 0)
3568 for (i
= 0; temp_array
[i
]; i
++)
3571 export_env
= add_or_supercede_exported_var (temp_array
[i
], do_alloc
);
3573 add_to_export_env (temp_array
[i
], do_alloc
);
3579 /* Make the environment array for the command about to be executed, if the
3580 array needs making. Otherwise, do nothing. If a shell action could
3581 change the array that commands receive for their environment, then the
3582 code should `array_needs_making++'.
3584 The order to add to the array is:
3586 list of var contexts whose head is shell_variables
3589 This is the shell variable lookup order. We add only new variable
3590 names at each step, which allows local variables and variables in
3591 the temporary environments to shadow variables in the global (or
3592 any previous) scope.
3596 n_shell_variables ()
3601 for (n
= 0, vc
= shell_variables
; vc
; vc
= vc
->down
)
3602 n
+= HASH_ENTRIES (vc
->table
);
3607 maybe_make_export_env ()
3609 register char **temp_array
;
3613 if (array_needs_making
)
3616 strvec_flush (export_env
);
3618 /* Make a guess based on how many shell variables and functions we
3619 have. Since there will always be array variables, and array
3620 variables are not (yet) exported, this will always be big enough
3621 for the exported variables and functions. */
3622 new_size
= n_shell_variables () + HASH_ENTRIES (shell_functions
) + 1 +
3623 HASH_ENTRIES (temporary_env
);
3624 if (new_size
> export_env_size
)
3626 export_env_size
= new_size
;
3627 export_env
= strvec_resize (export_env
, export_env_size
);
3628 environ
= export_env
;
3630 export_env
[export_env_index
= 0] = (char *)NULL
;
3632 /* Make a dummy variable context from the temporary_env, stick it on
3633 the front of shell_variables, call make_var_export_array on the
3634 whole thing to flatten it, and convert the list of SHELL_VAR *s
3635 to the form needed by the environment. */
3638 tcxt
= new_var_context ((char *)NULL
, 0);
3639 tcxt
->table
= temporary_env
;
3640 tcxt
->down
= shell_variables
;
3643 tcxt
= shell_variables
;
3645 temp_array
= make_var_export_array (tcxt
);
3647 add_temp_array_to_env (temp_array
, 0, 0);
3649 if (tcxt
!= shell_variables
)
3652 #if defined (RESTRICTED_SHELL)
3653 /* Restricted shells may not export shell functions. */
3654 temp_array
= restricted
? (char **)0 : make_func_export_array ();
3656 temp_array
= make_func_export_array ();
3659 add_temp_array_to_env (temp_array
, 0, 0);
3661 array_needs_making
= 0;
3665 /* This is an efficiency hack. PWD and OLDPWD are auto-exported, so
3666 we will need to remake the exported environment every time we
3667 change directories. `_' is always put into the environment for
3668 every external command, so without special treatment it will always
3669 cause the environment to be remade.
3671 If there is no other reason to make the exported environment, we can
3672 just update the variables in place and mark the exported environment
3673 as no longer needing a remake. */
3675 update_export_env_inplace (env_prefix
, preflen
, value
)
3682 evar
= (char *)xmalloc (STRLEN (value
) + preflen
+ 1);
3683 strcpy (evar
, env_prefix
);
3685 strcpy (evar
+ preflen
, value
);
3686 export_env
= add_or_supercede_exported_var (evar
, 0);
3689 /* We always put _ in the environment as the name of this command. */
3691 put_command_name_into_env (command_name
)
3694 update_export_env_inplace ("_=", 2, command_name
);
3697 #if 0 /* UNUSED -- it caused too many problems */
3699 put_gnu_argv_flags_into_env (pid
, flags_string
)
3709 fl
= strlen (flags_string
);
3711 dummy
= (char *)xmalloc (l
+ fl
+ 30);
3713 strcpy (dummy
+ 1, pbuf
);
3714 strcpy (dummy
+ 1 + l
, "_GNU_nonoption_argv_flags_");
3715 dummy
[l
+ 27] = '=';
3716 strcpy (dummy
+ l
+ 28, flags_string
);
3720 export_env
= add_or_supercede_exported_var (dummy
, 0);
3724 /* **************************************************************** */
3726 /* Managing variable contexts */
3728 /* **************************************************************** */
3730 /* Allocate and return a new variable context with NAME and FLAGS.
3731 NAME can be NULL. */
3734 new_var_context (name
, flags
)
3740 vc
= (VAR_CONTEXT
*)xmalloc (sizeof (VAR_CONTEXT
));
3741 vc
->name
= name
? savestring (name
) : (char *)NULL
;
3742 vc
->scope
= variable_context
;
3745 vc
->up
= vc
->down
= (VAR_CONTEXT
*)NULL
;
3746 vc
->table
= (HASH_TABLE
*)NULL
;
3751 /* Free a variable context and its data, including the hash table. Dispose
3752 all of the variables. */
3754 dispose_var_context (vc
)
3761 delete_all_variables (vc
->table
);
3762 hash_dispose (vc
->table
);
3768 /* Set VAR's scope level to the current variable context. */
3773 return (var
->context
= variable_context
);
3776 /* Make a new variable context with NAME and FLAGS and a HASH_TABLE of
3777 temporary variables, and push it onto shell_variables. This is
3778 for shell functions. */
3780 push_var_context (name
, flags
, tempvars
)
3783 HASH_TABLE
*tempvars
;
3787 vc
= new_var_context (name
, flags
);
3788 vc
->table
= tempvars
;
3791 /* Have to do this because the temp environment was created before
3792 variable_context was incremented. */
3793 flatten (tempvars
, set_context
, (VARLIST
*)NULL
, 0);
3794 vc
->flags
|= VC_HASTMPVAR
;
3796 vc
->down
= shell_variables
;
3797 shell_variables
->up
= vc
;
3799 return (shell_variables
= vc
);
3803 push_func_var (data
)
3808 var
= (SHELL_VAR
*)data
;
3810 if (tempvar_p (var
) && (posixly_correct
|| (var
->attributes
& att_propagate
)))
3812 /* XXX - should we set v->context here? */
3813 v
= bind_variable_internal (var
->name
, value_cell (var
), shell_variables
->table
, 0, 0);
3814 if (shell_variables
== global_variables
)
3815 var
->attributes
&= ~(att_tempvar
|att_propagate
);
3817 shell_variables
->flags
|= VC_HASTMPVAR
;
3818 v
->attributes
|= var
->attributes
;
3821 stupidly_hack_special_variables (var
->name
); /* XXX */
3823 dispose_variable (var
);
3826 /* Pop the top context off of VCXT and dispose of it, returning the rest of
3831 VAR_CONTEXT
*ret
, *vcxt
;
3833 vcxt
= shell_variables
;
3834 if (vc_isfuncenv (vcxt
) == 0)
3836 internal_error (_("pop_var_context: head of shell_variables not a function context"));
3840 if (ret
= vcxt
->down
)
3842 ret
->up
= (VAR_CONTEXT
*)NULL
;
3843 shell_variables
= ret
;
3845 hash_flush (vcxt
->table
, push_func_var
);
3846 dispose_var_context (vcxt
);
3849 internal_error (_("pop_var_context: no global_variables context"));
3852 /* Delete the HASH_TABLEs for all variable contexts beginning at VCXT, and
3853 all of the VAR_CONTEXTs except GLOBAL_VARIABLES. */
3855 delete_all_contexts (vcxt
)
3860 for (v
= vcxt
; v
!= global_variables
; v
= t
)
3863 dispose_var_context (v
);
3866 delete_all_variables (global_variables
->table
);
3867 shell_variables
= global_variables
;
3870 /* **************************************************************** */
3872 /* Pushing and Popping temporary variable scopes */
3874 /* **************************************************************** */
3877 push_scope (flags
, tmpvars
)
3879 HASH_TABLE
*tmpvars
;
3881 return (push_var_context ((char *)NULL
, flags
, tmpvars
));
3885 push_exported_var (data
)
3890 var
= (SHELL_VAR
*)data
;
3892 /* If a temp var had its export attribute set, or it's marked to be
3893 propagated, bind it in the previous scope before disposing it. */
3894 /* XXX - This isn't exactly right, because all tempenv variables have the
3895 export attribute set. */
3897 if (exported_p (var
) || (var
->attributes
& att_propagate
))
3899 if (tempvar_p (var
) && exported_p (var
) && (var
->attributes
& att_propagate
))
3902 var
->attributes
&= ~att_tempvar
; /* XXX */
3903 v
= bind_variable_internal (var
->name
, value_cell (var
), shell_variables
->table
, 0, 0);
3904 if (shell_variables
== global_variables
)
3905 var
->attributes
&= ~att_propagate
;
3906 v
->attributes
|= var
->attributes
;
3909 stupidly_hack_special_variables (var
->name
); /* XXX */
3911 dispose_variable (var
);
3915 pop_scope (is_special
)
3918 VAR_CONTEXT
*vcxt
, *ret
;
3920 vcxt
= shell_variables
;
3921 if (vc_istempscope (vcxt
) == 0)
3923 internal_error (_("pop_scope: head of shell_variables not a temporary environment scope"));
3929 ret
->up
= (VAR_CONTEXT
*)NULL
;
3931 shell_variables
= ret
;
3933 /* Now we can take care of merging variables in VCXT into set of scopes
3934 whose head is RET (shell_variables). */
3939 hash_flush (vcxt
->table
, push_func_var
);
3941 hash_flush (vcxt
->table
, push_exported_var
);
3942 hash_dispose (vcxt
->table
);
3946 sv_ifs ("IFS"); /* XXX here for now */
3949 /* **************************************************************** */
3951 /* Pushing and Popping function contexts */
3953 /* **************************************************************** */
3955 static WORD_LIST
**dollar_arg_stack
= (WORD_LIST
**)NULL
;
3956 static int dollar_arg_stack_slots
;
3957 static int dollar_arg_stack_index
;
3959 /* XXX - we might want to consider pushing and popping the `getopts' state
3960 when we modify the positional parameters. */
3962 push_context (name
, is_subshell
, tempvars
)
3963 char *name
; /* function name */
3965 HASH_TABLE
*tempvars
;
3967 if (is_subshell
== 0)
3968 push_dollar_vars ();
3970 push_var_context (name
, VC_FUNCENV
, tempvars
);
3973 /* Only called when subshell == 0, so we don't need to check, and can
3974 unconditionally pop the dollar vars off the stack. */
3982 sv_ifs ("IFS"); /* XXX here for now */
3985 /* Save the existing positional parameters on a stack. */
3989 if (dollar_arg_stack_index
+ 2 > dollar_arg_stack_slots
)
3991 dollar_arg_stack
= (WORD_LIST
**)
3992 xrealloc (dollar_arg_stack
, (dollar_arg_stack_slots
+= 10)
3993 * sizeof (WORD_LIST
**));
3995 dollar_arg_stack
[dollar_arg_stack_index
++] = list_rest_of_args ();
3996 dollar_arg_stack
[dollar_arg_stack_index
] = (WORD_LIST
*)NULL
;
3999 /* Restore the positional parameters from our stack. */
4003 if (!dollar_arg_stack
|| dollar_arg_stack_index
== 0)
4006 remember_args (dollar_arg_stack
[--dollar_arg_stack_index
], 1);
4007 dispose_words (dollar_arg_stack
[dollar_arg_stack_index
]);
4008 dollar_arg_stack
[dollar_arg_stack_index
] = (WORD_LIST
*)NULL
;
4009 set_dollar_vars_unchanged ();
4013 dispose_saved_dollar_vars ()
4015 if (!dollar_arg_stack
|| dollar_arg_stack_index
== 0)
4018 dispose_words (dollar_arg_stack
[dollar_arg_stack_index
]);
4019 dollar_arg_stack
[dollar_arg_stack_index
] = (WORD_LIST
*)NULL
;
4022 /* Manipulate the special BASH_ARGV and BASH_ARGC variables. */
4028 #if defined (ARRAY_VARS) && defined (DEBUGGER)
4029 SHELL_VAR
*bash_argv_v
, *bash_argc_v
;
4030 ARRAY
*bash_argv_a
, *bash_argc_a
;
4035 GET_ARRAY_FROM_VAR ("BASH_ARGV", bash_argv_v
, bash_argv_a
);
4036 GET_ARRAY_FROM_VAR ("BASH_ARGC", bash_argc_v
, bash_argc_a
);
4038 for (l
= list
, i
= 0; l
; l
= l
->next
, i
++)
4039 array_push (bash_argv_a
, l
->word
->word
);
4042 array_push (bash_argc_a
, t
);
4044 #endif /* ARRAY_VARS && DEBUGGER */
4047 /* Remove arguments from BASH_ARGV array. Pop top element off BASH_ARGC
4048 array and use that value as the count of elements to remove from
4053 #if defined (ARRAY_VARS) && defined (DEBUGGER)
4054 SHELL_VAR
*bash_argv_v
, *bash_argc_v
;
4055 ARRAY
*bash_argv_a
, *bash_argc_a
;
4059 GET_ARRAY_FROM_VAR ("BASH_ARGV", bash_argv_v
, bash_argv_a
);
4060 GET_ARRAY_FROM_VAR ("BASH_ARGC", bash_argc_v
, bash_argc_a
);
4062 ce
= array_shift (bash_argc_a
, 1, 0);
4063 if (ce
== 0 || legal_number (element_value (ce
), &i
) == 0)
4067 array_pop (bash_argv_a
);
4068 array_dispose_element (ce
);
4069 #endif /* ARRAY_VARS && DEBUGGER */
4072 /*************************************************
4074 * Functions to manage special variables *
4076 *************************************************/
4078 /* Extern declarations for variables this code has to manage. */
4079 extern int eof_encountered
, eof_encountered_limit
, ignoreeof
;
4081 #if defined (READLINE)
4082 extern int hostname_list_initialized
;
4085 /* An alist of name.function for each special variable. Most of the
4086 functions don't do much, and in fact, this would be faster with a
4087 switch statement, but by the end of this file, I am sick of switch
4090 #define SET_INT_VAR(name, intvar) intvar = find_variable (name) != 0
4092 /* This table will be sorted with qsort() the first time it's accessed. */
4093 struct name_and_function
{
4095 sh_sv_func_t
*function
;
4098 static struct name_and_function special_vars
[] = {
4099 { "BASH_XTRACEFD", sv_xtracefd
},
4101 #if defined (READLINE)
4102 # if defined (STRICT_POSIX)
4103 { "COLUMNS", sv_winsize
},
4105 { "COMP_WORDBREAKS", sv_comp_wordbreaks
},
4108 { "GLOBIGNORE", sv_globignore
},
4110 #if defined (HISTORY)
4111 { "HISTCONTROL", sv_history_control
},
4112 { "HISTFILESIZE", sv_histsize
},
4113 { "HISTIGNORE", sv_histignore
},
4114 { "HISTSIZE", sv_histsize
},
4115 { "HISTTIMEFORMAT", sv_histtimefmt
},
4118 #if defined (__CYGWIN__)
4119 { "HOME", sv_home
},
4122 #if defined (READLINE)
4123 { "HOSTFILE", sv_hostfile
},
4127 { "IGNOREEOF", sv_ignoreeof
},
4129 { "LANG", sv_locale
},
4130 { "LC_ALL", sv_locale
},
4131 { "LC_COLLATE", sv_locale
},
4132 { "LC_CTYPE", sv_locale
},
4133 { "LC_MESSAGES", sv_locale
},
4134 { "LC_NUMERIC", sv_locale
},
4135 { "LC_TIME", sv_locale
},
4137 #if defined (READLINE) && defined (STRICT_POSIX)
4138 { "LINES", sv_winsize
},
4141 { "MAIL", sv_mail
},
4142 { "MAILCHECK", sv_mail
},
4143 { "MAILPATH", sv_mail
},
4145 { "OPTERR", sv_opterr
},
4146 { "OPTIND", sv_optind
},
4148 { "PATH", sv_path
},
4149 { "POSIXLY_CORRECT", sv_strict_posix
},
4151 #if defined (READLINE)
4152 { "TERM", sv_terminal
},
4153 { "TERMCAP", sv_terminal
},
4154 { "TERMINFO", sv_terminal
},
4155 #endif /* READLINE */
4157 { "TEXTDOMAIN", sv_locale
},
4158 { "TEXTDOMAINDIR", sv_locale
},
4160 #if defined (HAVE_TZSET) && defined (PROMPT_STRING_DECODE)
4164 #if defined (HISTORY) && defined (BANG_HISTORY)
4165 { "histchars", sv_histchars
},
4166 #endif /* HISTORY && BANG_HISTORY */
4168 { "ignoreeof", sv_ignoreeof
},
4170 { (char *)0, (sh_sv_func_t
*)0 }
4173 #define N_SPECIAL_VARS (sizeof (special_vars) / sizeof (special_vars[0]) - 1)
4176 sv_compare (sv1
, sv2
)
4177 struct name_and_function
*sv1
, *sv2
;
4181 if ((r
= sv1
->name
[0] - sv2
->name
[0]) == 0)
4182 r
= strcmp (sv1
->name
, sv2
->name
);
4187 find_special_var (name
)
4192 for (i
= 0; special_vars
[i
].name
; i
++)
4194 r
= special_vars
[i
].name
[0] - name
[0];
4196 r
= strcmp (special_vars
[i
].name
, name
);
4200 /* Can't match any of rest of elements in sorted list. Take this out
4201 if it causes problems in certain environments. */
4207 /* The variable in NAME has just had its state changed. Check to see if it
4208 is one of the special ones where something special happens. */
4210 stupidly_hack_special_variables (name
)
4213 static int sv_sorted
= 0;
4216 if (sv_sorted
== 0) /* shouldn't need, but it's fairly cheap. */
4218 qsort (special_vars
, N_SPECIAL_VARS
, sizeof (special_vars
[0]),
4219 (QSFUNC
*)sv_compare
);
4223 i
= find_special_var (name
);
4225 (*(special_vars
[i
].function
)) (name
);
4228 /* Special variables that need hooks to be run when they are unset as part
4229 of shell reinitialization should have their sv_ functions run here. */
4231 reinit_special_variables ()
4233 #if defined (READLINE)
4234 sv_comp_wordbreaks ("COMP_WORDBREAKS");
4236 sv_globignore ("GLOBIGNORE");
4237 sv_opterr ("OPTERR");
4246 v
= find_variable ("IFS");
4250 /* What to do just after the PATH variable has changed. */
4259 /* What to do just after one of the MAILxxxx variables has changed. NAME
4260 is the name of the variable. This is called with NAME set to one of
4261 MAIL, MAILCHECK, or MAILPATH. */
4266 /* If the time interval for checking the files has changed, then
4267 reset the mail timer. Otherwise, one of the pathname vars
4268 to the users mailbox has changed, so rebuild the array of
4270 if (name
[4] == 'C') /* if (strcmp (name, "MAILCHECK") == 0) */
4271 reset_mail_timer ();
4275 remember_mail_dates ();
4279 /* What to do when GLOBIGNORE changes. */
4281 sv_globignore (name
)
4284 if (privileged_mode
== 0)
4285 setup_glob_ignore (name
);
4288 #if defined (READLINE)
4290 sv_comp_wordbreaks (name
)
4295 sv
= find_variable (name
);
4297 reset_completer_word_break_chars ();
4300 /* What to do just after one of the TERMxxx variables has changed.
4301 If we are an interactive shell, then try to reset the terminal
4302 information in readline. */
4307 if (interactive_shell
&& no_line_editing
== 0)
4308 rl_reset_terminal (get_string_value ("TERM"));
4317 v
= find_variable (name
);
4319 clear_hostname_list ();
4321 hostname_list_initialized
= 0;
4324 #if defined (STRICT_POSIX)
4325 /* In strict posix mode, we allow assignments to LINES and COLUMNS (and values
4326 found in the initial environment) to override the terminal size reported by
4336 if (posixly_correct
== 0 || interactive_shell
== 0 || no_line_editing
)
4339 v
= find_variable (name
);
4340 if (v
== 0 || var_isnull (v
))
4341 rl_reset_screen_size ();
4344 if (legal_number (value_cell (v
), &xd
) == 0)
4346 winsize_assignment
= winsize_assigned
= 1;
4347 d
= xd
; /* truncate */
4348 if (name
[0] == 'L') /* LINES */
4349 rl_set_screen_size (d
, -1);
4351 rl_set_screen_size (-1, d
);
4352 winsize_assignment
= 0;
4355 #endif /* STRICT_POSIX */
4356 #endif /* READLINE */
4358 /* Update the value of HOME in the export environment so tilde expansion will
4360 #if defined (__CYGWIN__)
4364 array_needs_making
= 1;
4365 maybe_make_export_env ();
4369 #if defined (HISTORY)
4370 /* What to do after the HISTSIZE or HISTFILESIZE variables change.
4371 If there is a value for this HISTSIZE (and it is numeric), then stifle
4372 the history. Otherwise, if there is NO value for this variable,
4373 unstifle the history. If name is HISTFILESIZE, and its value is
4374 numeric, truncate the history file to hold no more than that many
4384 temp
= get_string_value (name
);
4388 if (legal_number (temp
, &num
))
4393 stifle_history (hmax
);
4394 hmax
= where_history ();
4395 if (history_lines_this_session
> hmax
)
4396 history_lines_this_session
= hmax
;
4400 history_truncate_file (get_string_value ("HISTFILE"), hmax
);
4401 if (hmax
<= history_lines_in_file
)
4402 history_lines_in_file
= hmax
;
4406 else if (name
[4] == 'S')
4407 unstifle_history ();
4410 /* What to do after the HISTIGNORE variable changes. */
4412 sv_histignore (name
)
4415 setup_history_ignore (name
);
4418 /* What to do after the HISTCONTROL variable changes. */
4420 sv_history_control (name
)
4427 history_control
= 0;
4428 temp
= get_string_value (name
);
4430 if (temp
== 0 || *temp
== 0)
4434 while (val
= extract_colon_unit (temp
, &tptr
))
4436 if (STREQ (val
, "ignorespace"))
4437 history_control
|= HC_IGNSPACE
;
4438 else if (STREQ (val
, "ignoredups"))
4439 history_control
|= HC_IGNDUPS
;
4440 else if (STREQ (val
, "ignoreboth"))
4441 history_control
|= HC_IGNBOTH
;
4442 else if (STREQ (val
, "erasedups"))
4443 history_control
|= HC_ERASEDUPS
;
4449 #if defined (BANG_HISTORY)
4450 /* Setting/unsetting of the history expansion character. */
4457 temp
= get_string_value (name
);
4460 history_expansion_char
= *temp
;
4461 if (temp
[0] && temp
[1])
4463 history_subst_char
= temp
[1];
4465 history_comment_char
= temp
[2];
4470 history_expansion_char
= '!';
4471 history_subst_char
= '^';
4472 history_comment_char
= '#';
4475 #endif /* BANG_HISTORY */
4478 sv_histtimefmt (name
)
4483 v
= find_variable (name
);
4484 history_write_timestamps
= (v
!= 0);
4486 #endif /* HISTORY */
4488 #if defined (HAVE_TZSET) && defined (PROMPT_STRING_DECODE)
4497 /* If the variable exists, then the value of it can be the number
4498 of times we actually ignore the EOF. The default is small,
4499 (smaller than csh, anyway). */
4507 eof_encountered
= 0;
4509 tmp_var
= find_variable (name
);
4510 ignoreeof
= tmp_var
!= 0;
4511 temp
= tmp_var
? value_cell (tmp_var
) : (char *)NULL
;
4513 eof_encountered_limit
= (*temp
&& all_digits (temp
)) ? atoi (temp
) : 10;
4514 set_shellopts (); /* make sure `ignoreeof' is/is not in $SHELLOPTS */
4524 tt
= get_string_value ("OPTIND");
4529 /* According to POSIX, setting OPTIND=1 resets the internal state
4531 if (s
< 0 || s
== 1)
4545 tt
= get_string_value ("OPTERR");
4546 sh_opterr
= (tt
&& *tt
) ? atoi (tt
) : 1;
4550 sv_strict_posix (name
)
4553 SET_INT_VAR (name
, posixly_correct
);
4554 posix_initialize (posixly_correct
);
4555 #if defined (READLINE)
4556 if (interactive_shell
)
4557 posix_readline_initialize (posixly_correct
);
4558 #endif /* READLINE */
4559 set_shellopts (); /* make sure `posix' is/is not in $SHELLOPTS */
4568 v
= get_string_value (name
);
4569 if (name
[0] == 'L' && name
[1] == 'A') /* LANG */
4572 set_locale_var (name
, v
); /* LC_*, TEXTDOMAIN* */
4575 #if defined (ARRAY_VARS)
4577 set_pipestatus_array (ps
, nproc
)
4585 char *t
, tbuf
[INT_STRLEN_BOUND(int) + 1];
4587 v
= find_variable ("PIPESTATUS");
4589 v
= make_new_array_variable ("PIPESTATUS");
4590 if (array_p (v
) == 0)
4591 return; /* Do nothing if not an array variable. */
4594 if (a
== 0 || array_num_elements (a
) == 0)
4596 for (i
= 0; i
< nproc
; i
++) /* was ps[i] != -1, not i < nproc */
4598 t
= inttostr (ps
[i
], tbuf
, sizeof (tbuf
));
4599 array_insert (a
, i
, t
);
4605 if (array_num_elements (a
) == nproc
&& nproc
== 1)
4607 ae
= element_forw (a
->head
);
4608 free (element_value (ae
));
4609 ae
->value
= itos (ps
[0]);
4611 else if (array_num_elements (a
) <= nproc
)
4613 /* modify in array_num_elements members in place, then add */
4615 for (i
= 0; i
< array_num_elements (a
); i
++)
4617 ae
= element_forw (ae
);
4618 free (element_value (ae
));
4619 ae
->value
= itos (ps
[i
]);
4622 for ( ; i
< nproc
; i
++)
4624 t
= inttostr (ps
[i
], tbuf
, sizeof (tbuf
));
4625 array_insert (a
, i
, t
);
4630 /* deleting elements. it's faster to rebuild the array. */
4632 for (i
= 0; ps
[i
] != -1; i
++)
4634 t
= inttostr (ps
[i
], tbuf
, sizeof (tbuf
));
4635 array_insert (a
, i
, t
);
4642 set_pipestatus_from_exit (s
)
4645 #if defined (ARRAY_VARS)
4646 static int v
[2] = { 0, -1 };
4649 set_pipestatus_array (v
, 1);
4662 v
= find_variable (name
);
4670 if (t
== 0 || *t
== 0)
4674 fd
= (int)strtol (t
, &e
, 10);
4675 if (e
!= t
&& *e
== '\0' && sh_validfd (fd
))
4677 fp
= fdopen (fd
, "w");
4679 internal_error (_("%s: %s: cannot open as FILE"), name
, value_cell (v
));
4681 xtrace_set (fd
, fp
);
4684 internal_error (_("%s: %s: invalid value for trace file descriptor"), name
, value_cell (v
));