1 /* variables.c -- Functions for hacking shell variables. */
3 /* Copyright (C) 1987-2013 Free Software Foundation, Inc.
5 This file is part of GNU Bash, the Bourne Again SHell.
7 Bash is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 Bash is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with Bash. If not, see <http://www.gnu.org/licenses/>.
23 #include "bashtypes.h"
24 #include "posixstat.h"
25 #include "posixtime.h"
28 # if defined (__QNXNTO__)
29 # include <sys/netmgr.h>
32 # endif /* !__QNXNTO__ */
35 #if defined (HAVE_UNISTD_H)
40 #include "chartypes.h"
41 #if defined (HAVE_PWD_H)
47 #define NEED_XTRACE_SET_DECL
51 #include "execute_cmd.h"
53 #include "mailcheck.h"
62 #include "builtins/getopt.h"
63 #include "builtins/common.h"
64 #include "builtins/builtext.h"
66 #if defined (READLINE)
67 # include "bashline.h"
68 # include <readline/readline.h>
70 # include <tilde/tilde.h>
74 # include "bashhist.h"
75 # include <readline/history.h>
78 #if defined (PROGRAMMABLE_COMPLETION)
79 # include "pcomplete.h"
82 #define TEMPENV_HASH_BUCKETS 4 /* must be power of two */
84 #define ifsname(s) ((s)[0] == 'I' && (s)[1] == 'F' && (s)[2] == 'S' && (s)[3] == '\0')
86 extern char **environ
;
88 /* Variables used here and defined in other files. */
89 extern int posixly_correct
;
90 extern int line_number
, line_number_base
;
91 extern int subshell_environment
, indirection_level
, subshell_level
;
92 extern int build_version
, patch_level
;
93 extern int expanding_redir
;
94 extern int last_command_exit_value
;
95 extern char *dist_version
, *release_status
;
96 extern char *shell_name
;
97 extern char *primary_prompt
, *secondary_prompt
;
98 extern char *current_host_name
;
99 extern sh_builtin_func_t
*this_shell_builtin
;
100 extern SHELL_VAR
*this_shell_function
;
101 extern char *the_printed_command_except_trap
;
102 extern char *this_command_name
;
103 extern char *command_execution_string
;
104 extern time_t shell_start_time
;
105 extern int assigning_in_environment
;
106 extern int executing_builtin
;
107 extern int funcnest_max
;
109 #if defined (READLINE)
110 extern int no_line_editing
;
111 extern int perform_hostname_completion
;
114 /* The list of shell variables that the user has created at the global
115 scope, or that came from the environment. */
116 VAR_CONTEXT
*global_variables
= (VAR_CONTEXT
*)NULL
;
118 /* The current list of shell variables, including function scopes */
119 VAR_CONTEXT
*shell_variables
= (VAR_CONTEXT
*)NULL
;
121 /* The list of shell functions that the user has created, or that came from
123 HASH_TABLE
*shell_functions
= (HASH_TABLE
*)NULL
;
125 #if defined (DEBUGGER)
126 /* The table of shell function definitions that the user defined or that
127 came from the environment. */
128 HASH_TABLE
*shell_function_defs
= (HASH_TABLE
*)NULL
;
131 /* The current variable context. This is really a count of how deep into
132 executing functions we are. */
133 int variable_context
= 0;
135 /* The set of shell assignments which are made only in the environment
136 for a single command. */
137 HASH_TABLE
*temporary_env
= (HASH_TABLE
*)NULL
;
139 /* Set to non-zero if an assignment error occurs while putting variables
140 into the temporary environment. */
141 int tempenv_assign_error
;
143 /* Some funky variables which are known about specially. Here is where
144 "$*", "$1", and all the cruft is kept. */
145 char *dollar_vars
[10];
146 WORD_LIST
*rest_of_args
= (WORD_LIST
*)NULL
;
148 /* The value of $$. */
149 pid_t dollar_dollar_pid
;
151 /* Non-zero means that we have to remake EXPORT_ENV. */
152 int array_needs_making
= 1;
154 /* The number of times BASH has been executed. This is set
155 by initialize_variables (). */
158 /* An array which is passed to commands as their environment. It is
159 manufactured from the union of the initial environment and the
160 shell variables that are marked for export. */
161 char **export_env
= (char **)NULL
;
162 static int export_env_index
;
163 static int export_env_size
;
165 #if defined (READLINE)
166 static int winsize_assignment
; /* currently assigning to LINES or COLUMNS */
169 static HASH_TABLE
*last_table_searched
; /* hash_lookup sets this */
171 /* Some forward declarations. */
172 static void create_variable_tables
__P((void));
174 static void set_machine_vars
__P((void));
175 static void set_home_var
__P((void));
176 static void set_shell_var
__P((void));
177 static char *get_bash_name
__P((void));
178 static void initialize_shell_level
__P((void));
179 static void uidset
__P((void));
180 #if defined (ARRAY_VARS)
181 static void make_vers_array
__P((void));
184 static SHELL_VAR
*null_assign
__P((SHELL_VAR
*, char *, arrayind_t
, char *));
185 #if defined (ARRAY_VARS)
186 static SHELL_VAR
*null_array_assign
__P((SHELL_VAR
*, char *, arrayind_t
, char *));
188 static SHELL_VAR
*get_self
__P((SHELL_VAR
*));
190 #if defined (ARRAY_VARS)
191 static SHELL_VAR
*init_dynamic_array_var
__P((char *, sh_var_value_func_t
*, sh_var_assign_func_t
*, int));
192 static SHELL_VAR
*init_dynamic_assoc_var
__P((char *, sh_var_value_func_t
*, sh_var_assign_func_t
*, int));
195 static SHELL_VAR
*assign_seconds
__P((SHELL_VAR
*, char *, arrayind_t
, char *));
196 static SHELL_VAR
*get_seconds
__P((SHELL_VAR
*));
197 static SHELL_VAR
*init_seconds_var
__P((void));
199 static int brand
__P((void));
200 static void sbrand
__P((unsigned long)); /* set bash random number generator. */
201 static void seedrand
__P((void)); /* seed generator randomly */
202 static SHELL_VAR
*assign_random
__P((SHELL_VAR
*, char *, arrayind_t
, char *));
203 static SHELL_VAR
*get_random
__P((SHELL_VAR
*));
205 static SHELL_VAR
*assign_lineno
__P((SHELL_VAR
*, char *, arrayind_t
, char *));
206 static SHELL_VAR
*get_lineno
__P((SHELL_VAR
*));
208 static SHELL_VAR
*assign_subshell
__P((SHELL_VAR
*, char *, arrayind_t
, char *));
209 static SHELL_VAR
*get_subshell
__P((SHELL_VAR
*));
211 static SHELL_VAR
*get_bashpid
__P((SHELL_VAR
*));
213 #if defined (HISTORY)
214 static SHELL_VAR
*get_histcmd
__P((SHELL_VAR
*));
217 #if defined (READLINE)
218 static SHELL_VAR
*get_comp_wordbreaks
__P((SHELL_VAR
*));
219 static SHELL_VAR
*assign_comp_wordbreaks
__P((SHELL_VAR
*, char *, arrayind_t
, char *));
222 #if defined (PUSHD_AND_POPD) && defined (ARRAY_VARS)
223 static SHELL_VAR
*assign_dirstack
__P((SHELL_VAR
*, char *, arrayind_t
, char *));
224 static SHELL_VAR
*get_dirstack
__P((SHELL_VAR
*));
227 #if defined (ARRAY_VARS)
228 static SHELL_VAR
*get_groupset
__P((SHELL_VAR
*));
230 static SHELL_VAR
*build_hashcmd
__P((SHELL_VAR
*));
231 static SHELL_VAR
*get_hashcmd
__P((SHELL_VAR
*));
232 static SHELL_VAR
*assign_hashcmd
__P((SHELL_VAR
*, char *, arrayind_t
, char *));
234 static SHELL_VAR
*build_aliasvar
__P((SHELL_VAR
*));
235 static SHELL_VAR
*get_aliasvar
__P((SHELL_VAR
*));
236 static SHELL_VAR
*assign_aliasvar
__P((SHELL_VAR
*, char *, arrayind_t
, char *));
240 static SHELL_VAR
*get_funcname
__P((SHELL_VAR
*));
241 static SHELL_VAR
*init_funcname_var
__P((void));
243 static void initialize_dynamic_variables
__P((void));
245 static SHELL_VAR
*hash_lookup
__P((const char *, HASH_TABLE
*));
246 static SHELL_VAR
*new_shell_variable
__P((const char *));
247 static SHELL_VAR
*make_new_variable
__P((const char *, HASH_TABLE
*));
248 static SHELL_VAR
*bind_variable_internal
__P((const char *, char *, HASH_TABLE
*, int, int));
250 static void dispose_variable_value
__P((SHELL_VAR
*));
251 static void free_variable_hash_data
__P((PTR_T
));
253 static VARLIST
*vlist_alloc
__P((int));
254 static VARLIST
*vlist_realloc
__P((VARLIST
*, int));
255 static void vlist_add
__P((VARLIST
*, SHELL_VAR
*, int));
257 static void flatten
__P((HASH_TABLE
*, sh_var_map_func_t
*, VARLIST
*, int));
259 static int qsort_var_comp
__P((SHELL_VAR
**, SHELL_VAR
**));
261 static SHELL_VAR
**vapply
__P((sh_var_map_func_t
*));
262 static SHELL_VAR
**fapply
__P((sh_var_map_func_t
*));
264 static int visible_var
__P((SHELL_VAR
*));
265 static int visible_and_exported
__P((SHELL_VAR
*));
266 static int export_environment_candidate
__P((SHELL_VAR
*));
267 static int local_and_exported
__P((SHELL_VAR
*));
268 static int variable_in_context
__P((SHELL_VAR
*));
269 #if defined (ARRAY_VARS)
270 static int visible_array_vars
__P((SHELL_VAR
*));
273 static SHELL_VAR
*find_nameref_at_context
__P((SHELL_VAR
*, VAR_CONTEXT
*));
274 static SHELL_VAR
*find_variable_nameref_context
__P((SHELL_VAR
*, VAR_CONTEXT
*, VAR_CONTEXT
**));
275 static SHELL_VAR
*find_variable_last_nameref_context
__P((SHELL_VAR
*, VAR_CONTEXT
*, VAR_CONTEXT
**));
277 static SHELL_VAR
*bind_tempenv_variable
__P((const char *, char *));
278 static void push_temp_var
__P((PTR_T
));
279 static void propagate_temp_var
__P((PTR_T
));
280 static void dispose_temporary_env
__P((sh_free_func_t
*));
282 static inline char *mk_env_string
__P((const char *, const char *));
283 static char **make_env_array_from_var_list
__P((SHELL_VAR
**));
284 static char **make_var_export_array
__P((VAR_CONTEXT
*));
285 static char **make_func_export_array
__P((void));
286 static void add_temp_array_to_env
__P((char **, int, int));
288 static int n_shell_variables
__P((void));
289 static int set_context
__P((SHELL_VAR
*));
291 static void push_func_var
__P((PTR_T
));
292 static void push_exported_var
__P((PTR_T
));
294 static inline int find_special_var
__P((const char *));
297 create_variable_tables ()
299 if (shell_variables
== 0)
301 shell_variables
= global_variables
= new_var_context ((char *)NULL
, 0);
302 shell_variables
->scope
= 0;
303 shell_variables
->table
= hash_create (0);
306 if (shell_functions
== 0)
307 shell_functions
= hash_create (0);
309 #if defined (DEBUGGER)
310 if (shell_function_defs
== 0)
311 shell_function_defs
= hash_create (0);
315 /* Initialize the shell variables from the current environment.
316 If PRIVMODE is nonzero, don't import functions from ENV or
319 initialize_shell_variables (env
, privmode
)
323 char *name
, *string
, *temp_string
;
324 int c
, char_index
, string_index
, string_length
, ro
;
327 create_variable_tables ();
329 for (string_index
= 0; string
= env
[string_index
++]; )
333 while ((c
= *string
++) && c
!= '=')
335 if (string
[-1] == '=')
336 char_index
= string
- name
- 1;
338 /* If there are weird things in the environment, like `=xxx' or a
339 string without an `=', just skip them. */
343 /* ASSERT(name[char_index] == '=') */
344 name
[char_index
] = '\0';
345 /* Now, name = env variable name, string = env variable value, and
346 char_index == strlen (name) */
348 temp_var
= (SHELL_VAR
*)NULL
;
350 /* If exported function, define it now. Don't import functions from
351 the environment in privileged mode. */
352 if (privmode
== 0 && read_but_dont_execute
== 0 && STREQN ("() {", string
, 4))
354 string_length
= strlen (string
);
355 temp_string
= (char *)xmalloc (3 + string_length
+ char_index
);
357 strcpy (temp_string
, name
);
358 temp_string
[char_index
] = ' ';
359 strcpy (temp_string
+ char_index
+ 1, string
);
361 if (posixly_correct
== 0 || legal_identifier (name
))
362 parse_and_execute (temp_string
, name
, SEVAL_NONINT
|SEVAL_NOHIST
);
364 /* Ancient backwards compatibility. Old versions of bash exported
365 functions like name()=() {...} */
366 if (name
[char_index
- 1] == ')' && name
[char_index
- 2] == '(')
367 name
[char_index
- 2] = '\0';
369 if (temp_var
= find_function (name
))
371 VSETATTR (temp_var
, (att_exported
|att_imported
));
372 array_needs_making
= 1;
376 if (temp_var
= bind_variable (name
, string
, 0))
378 VSETATTR (temp_var
, (att_exported
| att_imported
| att_invisible
));
379 array_needs_making
= 1;
381 last_command_exit_value
= 1;
382 report_error (_("error importing function definition for `%s'"), name
);
386 if (name
[char_index
- 1] == ')' && name
[char_index
- 2] == '\0')
387 name
[char_index
- 2] = '('; /* ) */
389 #if defined (ARRAY_VARS)
391 /* Array variables may not yet be exported. */
392 else if (*string
== '(' && string
[1] == '[' && string
[strlen (string
) - 1] == ')')
395 temp_string
= extract_array_assignment_list (string
, &string_length
);
396 temp_var
= assign_array_from_string (name
, temp_string
);
398 VSETATTR (temp_var
, (att_exported
| att_imported
));
399 array_needs_making
= 1;
401 # endif /* ARRAY_EXPORT */
404 else if (legal_identifier (name
))
410 if (posixly_correct
&& STREQ (name
, "SHELLOPTS"))
412 temp_var
= find_variable ("SHELLOPTS");
413 ro
= temp_var
&& readonly_p (temp_var
);
415 VUNSETATTR (temp_var
, att_readonly
);
417 temp_var
= bind_variable (name
, string
, 0);
420 if (legal_identifier (name
))
421 VSETATTR (temp_var
, (att_exported
| att_imported
));
423 VSETATTR (temp_var
, (att_exported
| att_imported
| att_invisible
));
425 VSETATTR (temp_var
, att_readonly
);
426 array_needs_making
= 1;
430 name
[char_index
] = '=';
431 /* temp_var can be NULL if it was an exported function with a syntax
432 error (a different bug, but it still shouldn't dump core). */
433 if (temp_var
&& function_p (temp_var
) == 0) /* XXX not yet */
435 CACHE_IMPORTSTR (temp_var
, name
);
441 /* Set up initial value of $_ */
442 temp_var
= set_if_not ("_", dollar_vars
[0]);
444 /* Remember this pid. */
445 dollar_dollar_pid
= getpid ();
447 /* Now make our own defaults in case the vars that we think are
448 important are missing. */
449 temp_var
= set_if_not ("PATH", DEFAULT_PATH_VALUE
);
451 set_auto_export (temp_var
); /* XXX */
454 temp_var
= set_if_not ("TERM", "dumb");
456 set_auto_export (temp_var
); /* XXX */
459 #if defined (__QNX__)
460 /* set node id -- don't import it from the environment */
463 # if defined (__QNXNTO__)
464 netmgr_ndtostr(ND2S_LOCAL_STR
, ND_LOCAL_NODE
, node_name
, sizeof(node_name
));
466 qnx_nidtostr (getnid (), node_name
, sizeof (node_name
));
468 temp_var
= bind_variable ("NODE", node_name
, 0);
469 set_auto_export (temp_var
);
473 /* set up the prompts. */
474 if (interactive_shell
)
476 #if defined (PROMPT_STRING_DECODE)
477 set_if_not ("PS1", primary_prompt
);
479 if (current_user
.uid
== -1)
480 get_current_user_info ();
481 set_if_not ("PS1", current_user
.euid
== 0 ? "# " : primary_prompt
);
483 set_if_not ("PS2", secondary_prompt
);
485 set_if_not ("PS4", "+ ");
487 /* Don't allow IFS to be imported from the environment. */
488 temp_var
= bind_variable ("IFS", " \t\n", 0);
491 /* Magic machine types. Pretty convenient. */
494 /* Default MAILCHECK for interactive shells. Defer the creation of a
495 default MAILPATH until the startup files are read, because MAIL
496 names a mail file if MAILPATH is not set, and we should provide a
497 default only if neither is set. */
498 if (interactive_shell
)
500 temp_var
= set_if_not ("MAILCHECK", posixly_correct
? "600" : "60");
501 VSETATTR (temp_var
, att_integer
);
504 /* Do some things with shell level. */
505 initialize_shell_level ();
509 /* Initialize the `getopts' stuff. */
510 temp_var
= bind_variable ("OPTIND", "1", 0);
511 VSETATTR (temp_var
, att_integer
);
513 bind_variable ("OPTERR", "1", 0);
516 if (login_shell
== 1 && posixly_correct
== 0)
519 /* Get the full pathname to THIS shell, and set the BASH variable
521 name
= get_bash_name ();
522 temp_var
= bind_variable ("BASH", name
, 0);
525 /* Make the exported environment variable SHELL be the user's login
526 shell. Note that the `tset' command looks at this variable
527 to determine what style of commands to output; if it ends in "csh",
528 then C-shell commands are output, else Bourne shell commands. */
531 /* Make a variable called BASH_VERSION which contains the version info. */
532 bind_variable ("BASH_VERSION", shell_version_string (), 0);
533 #if defined (ARRAY_VARS)
537 if (command_execution_string
)
538 bind_variable ("BASH_EXECUTION_STRING", command_execution_string
, 0);
540 /* Find out if we're supposed to be in Posix.2 mode via an
541 environment variable. */
542 temp_var
= find_variable ("POSIXLY_CORRECT");
544 temp_var
= find_variable ("POSIX_PEDANTIC");
545 if (temp_var
&& imported_p (temp_var
))
546 sv_strict_posix (temp_var
->name
);
548 #if defined (HISTORY)
549 /* Set history variables to defaults, and then do whatever we would
550 do if the variable had just been set. Do this only in the case
551 that we are remembering commands on the history list. */
552 if (remember_on_history
)
554 name
= bash_tilde_expand (posixly_correct
? "~/.sh_history" : "~/.bash_history", 0);
556 set_if_not ("HISTFILE", name
);
561 /* Seed the random number generator. */
564 /* Handle some "special" variables that we may have inherited from a
566 if (interactive_shell
)
568 temp_var
= find_variable ("IGNOREEOF");
570 temp_var
= find_variable ("ignoreeof");
571 if (temp_var
&& imported_p (temp_var
))
572 sv_ignoreeof (temp_var
->name
);
575 #if defined (HISTORY)
576 if (interactive_shell
&& remember_on_history
)
578 sv_history_control ("HISTCONTROL");
579 sv_histignore ("HISTIGNORE");
580 sv_histtimefmt ("HISTTIMEFORMAT");
584 #if defined (READLINE) && defined (STRICT_POSIX)
585 /* POSIXLY_CORRECT will only be 1 here if the shell was compiled
587 if (interactive_shell
&& posixly_correct
&& no_line_editing
== 0)
588 rl_prefer_env_winsize
= 1;
589 #endif /* READLINE && STRICT_POSIX */
594 * I'm tired of the arguing and bug reports. Bash now leaves SSH_CLIENT
595 * and SSH2_CLIENT alone. I'm going to rely on the shell_level check in
596 * isnetconn() to avoid running the startup files more often than wanted.
597 * That will, of course, only work if the user's login shell is bash, so
598 * I've made that behavior conditional on SSH_SOURCE_BASHRC being defined
602 temp_var
= find_variable ("SSH_CLIENT");
603 if (temp_var
&& imported_p (temp_var
))
605 VUNSETATTR (temp_var
, att_exported
);
606 array_needs_making
= 1;
608 temp_var
= find_variable ("SSH2_CLIENT");
609 if (temp_var
&& imported_p (temp_var
))
611 VUNSETATTR (temp_var
, att_exported
);
612 array_needs_making
= 1;
616 /* Get the user's real and effective user ids. */
619 temp_var
= find_variable ("BASH_XTRACEFD");
620 if (temp_var
&& imported_p (temp_var
))
621 sv_xtracefd (temp_var
->name
);
623 /* Initialize the dynamic variables, and seed their values. */
624 initialize_dynamic_variables ();
627 /* **************************************************************** */
629 /* Setting values for special shell variables */
631 /* **************************************************************** */
638 temp_var
= set_if_not ("HOSTTYPE", HOSTTYPE
);
639 temp_var
= set_if_not ("OSTYPE", OSTYPE
);
640 temp_var
= set_if_not ("MACHTYPE", MACHTYPE
);
642 temp_var
= set_if_not ("HOSTNAME", current_host_name
);
645 /* Set $HOME to the information in the password file if we didn't get
646 it from the environment. */
648 /* This function is not static so the tilde and readline libraries can
653 if (current_user
.home_dir
== 0)
654 get_current_user_info ();
655 return current_user
.home_dir
;
663 temp_var
= find_variable ("HOME");
665 temp_var
= bind_variable ("HOME", sh_get_home_dir (), 0);
667 VSETATTR (temp_var
, att_exported
);
671 /* Set $SHELL to the user's login shell if it is not already set. Call
672 get_current_user_info if we haven't already fetched the shell. */
678 temp_var
= find_variable ("SHELL");
681 if (current_user
.shell
== 0)
682 get_current_user_info ();
683 temp_var
= bind_variable ("SHELL", current_user
.shell
, 0);
686 VSETATTR (temp_var
, att_exported
);
695 if ((login_shell
== 1) && RELPATH(shell_name
))
697 if (current_user
.shell
== 0)
698 get_current_user_info ();
699 name
= savestring (current_user
.shell
);
701 else if (ABSPATH(shell_name
))
702 name
= savestring (shell_name
);
703 else if (shell_name
[0] == '.' && shell_name
[1] == '/')
705 /* Fast path for common case. */
709 cdir
= get_string_value ("PWD");
713 name
= (char *)xmalloc (len
+ strlen (shell_name
) + 1);
715 strcpy (name
+ len
, shell_name
+ 1);
718 name
= savestring (shell_name
);
725 tname
= find_user_command (shell_name
);
729 /* Try the current directory. If there is not an executable
730 there, just punt and use the login shell. */
731 s
= file_status (shell_name
);
734 tname
= make_absolute (shell_name
, get_string_value ("PWD"));
735 if (*shell_name
== '.')
737 name
= sh_canonpath (tname
, PATH_CHECKDOTDOT
|PATH_CHECKEXISTS
);
748 if (current_user
.shell
== 0)
749 get_current_user_info ();
750 name
= savestring (current_user
.shell
);
755 name
= full_pathname (tname
);
764 adjust_shell_level (change
)
767 char new_level
[5], *old_SHLVL
;
771 old_SHLVL
= get_string_value ("SHLVL");
772 if (old_SHLVL
== 0 || *old_SHLVL
== '\0' || legal_number (old_SHLVL
, &old_level
) == 0)
775 shell_level
= old_level
+ change
;
778 else if (shell_level
> 1000)
780 internal_warning (_("shell level (%d) too high, resetting to 1"), shell_level
);
784 /* We don't need the full generality of itos here. */
785 if (shell_level
< 10)
787 new_level
[0] = shell_level
+ '0';
790 else if (shell_level
< 100)
792 new_level
[0] = (shell_level
/ 10) + '0';
793 new_level
[1] = (shell_level
% 10) + '0';
796 else if (shell_level
< 1000)
798 new_level
[0] = (shell_level
/ 100) + '0';
799 old_level
= shell_level
% 100;
800 new_level
[1] = (old_level
/ 10) + '0';
801 new_level
[2] = (old_level
% 10) + '0';
805 temp_var
= bind_variable ("SHLVL", new_level
, 0);
806 set_auto_export (temp_var
);
810 initialize_shell_level ()
812 adjust_shell_level (1);
815 /* If we got PWD from the environment, update our idea of the current
816 working directory. In any case, make sure that PWD exists before
817 checking it. It is possible for getcwd () to fail on shell startup,
818 and in that case, PWD would be undefined. If this is an interactive
819 login shell, see if $HOME is the current working directory, and if
820 that's not the same string as $PWD, set PWD=$HOME. */
825 SHELL_VAR
*temp_var
, *home_var
;
826 char *temp_string
, *home_string
;
828 home_var
= find_variable ("HOME");
829 home_string
= home_var
? value_cell (home_var
) : (char *)NULL
;
831 temp_var
= find_variable ("PWD");
832 if (temp_var
&& imported_p (temp_var
) &&
833 (temp_string
= value_cell (temp_var
)) &&
834 same_file (temp_string
, ".", (struct stat
*)NULL
, (struct stat
*)NULL
))
835 set_working_directory (temp_string
);
836 else if (home_string
&& interactive_shell
&& login_shell
&&
837 same_file (home_string
, ".", (struct stat
*)NULL
, (struct stat
*)NULL
))
839 set_working_directory (home_string
);
840 temp_var
= bind_variable ("PWD", home_string
, 0);
841 set_auto_export (temp_var
);
845 temp_string
= get_working_directory ("shell-init");
848 temp_var
= bind_variable ("PWD", temp_string
, 0);
849 set_auto_export (temp_var
);
854 /* According to the Single Unix Specification, v2, $OLDPWD is an
855 `environment variable' and therefore should be auto-exported.
856 Make a dummy invisible variable for OLDPWD, and mark it as exported. */
857 temp_var
= bind_variable ("OLDPWD", (char *)NULL
, 0);
858 VSETATTR (temp_var
, (att_exported
| att_invisible
));
861 /* Make a variable $PPID, which holds the pid of the shell's parent. */
865 char namebuf
[INT_STRLEN_BOUND(pid_t
) + 1], *name
;
868 name
= inttostr (getppid (), namebuf
, sizeof(namebuf
));
869 temp_var
= find_variable ("PPID");
871 VUNSETATTR (temp_var
, (att_readonly
| att_exported
));
872 temp_var
= bind_variable ("PPID", name
, 0);
873 VSETATTR (temp_var
, (att_readonly
| att_integer
));
879 char buff
[INT_STRLEN_BOUND(uid_t
) + 1], *b
;
880 register SHELL_VAR
*v
;
882 b
= inttostr (current_user
.uid
, buff
, sizeof (buff
));
883 v
= find_variable ("UID");
886 v
= bind_variable ("UID", b
, 0);
887 VSETATTR (v
, (att_readonly
| att_integer
));
890 if (current_user
.euid
!= current_user
.uid
)
891 b
= inttostr (current_user
.euid
, buff
, sizeof (buff
));
893 v
= find_variable ("EUID");
896 v
= bind_variable ("EUID", b
, 0);
897 VSETATTR (v
, (att_readonly
| att_integer
));
901 #if defined (ARRAY_VARS)
907 char *s
, d
[32], b
[INT_STRLEN_BOUND(int) + 1];
909 unbind_variable ("BASH_VERSINFO");
911 vv
= make_new_array_variable ("BASH_VERSINFO");
912 av
= array_cell (vv
);
913 strcpy (d
, dist_version
);
917 array_insert (av
, 0, d
);
918 array_insert (av
, 1, s
);
919 s
= inttostr (patch_level
, b
, sizeof (b
));
920 array_insert (av
, 2, s
);
921 s
= inttostr (build_version
, b
, sizeof (b
));
922 array_insert (av
, 3, s
);
923 array_insert (av
, 4, release_status
);
924 array_insert (av
, 5, MACHTYPE
);
926 VSETATTR (vv
, att_readonly
);
928 #endif /* ARRAY_VARS */
930 /* Set the environment variables $LINES and $COLUMNS in response to
931 a window size change. */
933 sh_set_lines_and_columns (lines
, cols
)
936 char val
[INT_STRLEN_BOUND(int) + 1], *v
;
938 #if defined (READLINE)
939 /* If we are currently assigning to LINES or COLUMNS, don't do anything. */
940 if (winsize_assignment
)
944 v
= inttostr (lines
, val
, sizeof (val
));
945 bind_variable ("LINES", v
, 0);
947 v
= inttostr (cols
, val
, sizeof (val
));
948 bind_variable ("COLUMNS", v
, 0);
951 /* **************************************************************** */
953 /* Printing variables and values */
955 /* **************************************************************** */
957 /* Print LIST (a list of shell variables) to stdout in such a way that
958 they can be read back in. */
960 print_var_list (list
)
961 register SHELL_VAR
**list
;
964 register SHELL_VAR
*var
;
966 for (i
= 0; list
&& (var
= list
[i
]); i
++)
967 if (invisible_p (var
) == 0)
968 print_assignment (var
);
971 /* Print LIST (a list of shell functions) to stdout in such a way that
972 they can be read back in. */
974 print_func_list (list
)
975 register SHELL_VAR
**list
;
978 register SHELL_VAR
*var
;
980 for (i
= 0; list
&& (var
= list
[i
]); i
++)
982 printf ("%s ", var
->name
);
983 print_var_function (var
);
988 /* Print the value of a single SHELL_VAR. No newline is
989 output, but the variable is printed in such a way that
990 it can be read back in. */
992 print_assignment (var
)
995 if (var_isset (var
) == 0)
998 if (function_p (var
))
1000 printf ("%s", var
->name
);
1001 print_var_function (var
);
1004 #if defined (ARRAY_VARS)
1005 else if (array_p (var
))
1006 print_array_assignment (var
, 0);
1007 else if (assoc_p (var
))
1008 print_assoc_assignment (var
, 0);
1009 #endif /* ARRAY_VARS */
1012 printf ("%s=", var
->name
);
1013 print_var_value (var
, 1);
1018 /* Print the value cell of VAR, a shell variable. Do not print
1019 the name, nor leading/trailing newline. If QUOTE is non-zero,
1020 and the value contains shell metacharacters, quote the value
1021 in such a way that it can be read back in. */
1023 print_var_value (var
, quote
)
1029 if (var_isset (var
) == 0)
1032 if (quote
&& posixly_correct
== 0 && ansic_shouldquote (value_cell (var
)))
1034 t
= ansic_quote (value_cell (var
), 0, (int *)0);
1038 else if (quote
&& sh_contains_shell_metas (value_cell (var
)))
1040 t
= sh_single_quote (value_cell (var
));
1045 printf ("%s", value_cell (var
));
1048 /* Print the function cell of VAR, a shell variable. Do not
1049 print the name, nor leading/trailing newline. */
1051 print_var_function (var
)
1056 if (function_p (var
) && var_isset (var
))
1058 x
= named_function_string ((char *)NULL
, function_cell(var
), FUNC_MULTILINE
|FUNC_EXTERNAL
);
1063 /* **************************************************************** */
1065 /* Dynamic Variables */
1067 /* **************************************************************** */
1069 /* DYNAMIC VARIABLES
1071 These are variables whose values are generated anew each time they are
1072 referenced. These are implemented using a pair of function pointers
1073 in the struct variable: assign_func, which is called from bind_variable
1074 and, if arrays are compiled into the shell, some of the functions in
1075 arrayfunc.c, and dynamic_value, which is called from find_variable.
1077 assign_func is called from bind_variable_internal, if
1078 bind_variable_internal discovers that the variable being assigned to
1079 has such a function. The function is called as
1080 SHELL_VAR *temp = (*(entry->assign_func)) (entry, value, ind)
1081 and the (SHELL_VAR *)temp is returned as the value of bind_variable. It
1082 is usually ENTRY (self). IND is an index for an array variable, and
1085 dynamic_value is called from find_variable_internal to return a `new'
1086 value for the specified dynamic varible. If this function is NULL,
1087 the variable is treated as a `normal' shell variable. If it is not,
1088 however, then this function is called like this:
1089 tempvar = (*(var->dynamic_value)) (var);
1091 Sometimes `tempvar' will replace the value of `var'. Other times, the
1092 shell will simply use the string value. Pretty object-oriented, huh?
1094 Be warned, though: if you `unset' a special variable, it loses its
1095 special meaning, even if you subsequently set it.
1097 The special assignment code would probably have been better put in
1098 subst.c: do_assignment_internal, in the same style as
1099 stupidly_hack_special_variables, but I wanted the changes as
1100 localized as possible. */
1102 #define INIT_DYNAMIC_VAR(var, val, gfunc, afunc) \
1105 v = bind_variable (var, (val), 0); \
1106 v->dynamic_value = gfunc; \
1107 v->assign_func = afunc; \
1111 #define INIT_DYNAMIC_ARRAY_VAR(var, gfunc, afunc) \
1114 v = make_new_array_variable (var); \
1115 v->dynamic_value = gfunc; \
1116 v->assign_func = afunc; \
1120 #define INIT_DYNAMIC_ASSOC_VAR(var, gfunc, afunc) \
1123 v = make_new_assoc_variable (var); \
1124 v->dynamic_value = gfunc; \
1125 v->assign_func = afunc; \
1130 null_assign (self
, value
, unused
, key
)
1139 #if defined (ARRAY_VARS)
1141 null_array_assign (self
, value
, ind
, key
)
1151 /* Degenerate `dynamic_value' function; just returns what's passed without
1160 #if defined (ARRAY_VARS)
1161 /* A generic dynamic array variable initializer. Intialize array variable
1162 NAME with dynamic value function GETFUNC and assignment function SETFUNC. */
1164 init_dynamic_array_var (name
, getfunc
, setfunc
, attrs
)
1166 sh_var_value_func_t
*getfunc
;
1167 sh_var_assign_func_t
*setfunc
;
1172 v
= find_variable (name
);
1175 INIT_DYNAMIC_ARRAY_VAR (name
, getfunc
, setfunc
);
1177 VSETATTR (v
, attrs
);
1182 init_dynamic_assoc_var (name
, getfunc
, setfunc
, attrs
)
1184 sh_var_value_func_t
*getfunc
;
1185 sh_var_assign_func_t
*setfunc
;
1190 v
= find_variable (name
);
1193 INIT_DYNAMIC_ASSOC_VAR (name
, getfunc
, setfunc
);
1195 VSETATTR (v
, attrs
);
1200 /* The value of $SECONDS. This is the number of seconds since shell
1201 invocation, or, the number of seconds since the last assignment + the
1202 value of the last assignment. */
1203 static intmax_t seconds_value_assigned
;
1206 assign_seconds (self
, value
, unused
, key
)
1212 if (legal_number (value
, &seconds_value_assigned
) == 0)
1213 seconds_value_assigned
= 0;
1214 shell_start_time
= NOW
;
1222 time_t time_since_start
;
1225 time_since_start
= NOW
- shell_start_time
;
1226 p
= itos(seconds_value_assigned
+ time_since_start
);
1228 FREE (value_cell (var
));
1230 VSETATTR (var
, att_integer
);
1231 var_setvalue (var
, p
);
1240 v
= find_variable ("SECONDS");
1243 if (legal_number (value_cell(v
), &seconds_value_assigned
) == 0)
1244 seconds_value_assigned
= 0;
1246 INIT_DYNAMIC_VAR ("SECONDS", (v
? value_cell (v
) : (char *)NULL
), get_seconds
, assign_seconds
);
1250 /* The random number seed. You can change this by setting RANDOM. */
1251 static unsigned long rseed
= 1;
1252 static int last_random_value
;
1253 static int seeded_subshell
= 0;
1255 /* A linear congruential random number generator based on the example
1256 one in the ANSI C standard. This one isn't very good, but a more
1257 complicated one is overkill. */
1259 /* Returns a pseudo-random number between 0 and 32767. */
1263 /* From "Random number generators: good ones are hard to find",
1264 Park and Miller, Communications of the ACM, vol. 31, no. 10,
1265 October 1988, p. 1195. filtered through FreeBSD */
1268 /* Can't seed with 0. */
1273 rseed
= 16807 * l
- 2836 * h
;
1276 rseed
+= 0x7fffffff;
1278 return ((unsigned int)(rseed
& 32767)); /* was % 32768 */
1281 /* Set the random number generator seed to SEED. */
1287 last_random_value
= 0;
1295 gettimeofday (&tv
, NULL
);
1296 sbrand (tv
.tv_sec
^ tv
.tv_usec
^ getpid ());
1300 assign_random (self
, value
, unused
, key
)
1306 sbrand (strtoul (value
, (char **)NULL
, 10));
1307 if (subshell_environment
)
1308 seeded_subshell
= getpid ();
1313 get_random_number ()
1317 /* Reset for command and process substitution. */
1319 if (subshell_environment
&& seeded_subshell
!= pid
)
1322 seeded_subshell
= pid
;
1327 while (rv
== last_random_value
);
1338 rv
= get_random_number ();
1339 last_random_value
= rv
;
1342 FREE (value_cell (var
));
1344 VSETATTR (var
, att_integer
);
1345 var_setvalue (var
, p
);
1350 assign_lineno (var
, value
, unused
, key
)
1358 if (value
== 0 || *value
== '\0' || legal_number (value
, &new_value
) == 0)
1360 line_number
= line_number_base
= new_value
;
1364 /* Function which returns the current line number. */
1372 ln
= executing_line_number ();
1374 FREE (value_cell (var
));
1375 var_setvalue (var
, p
);
1380 assign_subshell (var
, value
, unused
, key
)
1388 if (value
== 0 || *value
== '\0' || legal_number (value
, &new_value
) == 0)
1390 subshell_level
= new_value
;
1400 p
= itos (subshell_level
);
1401 FREE (value_cell (var
));
1402 var_setvalue (var
, p
);
1416 FREE (value_cell (var
));
1417 VSETATTR (var
, att_integer
|att_readonly
);
1418 var_setvalue (var
, p
);
1423 get_bash_command (var
)
1428 if (the_printed_command_except_trap
)
1429 p
= savestring (the_printed_command_except_trap
);
1432 p
= (char *)xmalloc (1);
1435 FREE (value_cell (var
));
1436 var_setvalue (var
, p
);
1440 #if defined (HISTORY)
1447 p
= itos (history_number ());
1448 FREE (value_cell (var
));
1449 var_setvalue (var
, p
);
1454 #if defined (READLINE)
1455 /* When this function returns, VAR->value points to malloced memory. */
1457 get_comp_wordbreaks (var
)
1460 /* If we don't have anything yet, assign a default value. */
1461 if (rl_completer_word_break_characters
== 0 && bash_readline_initialized
== 0)
1462 enable_hostname_completion (perform_hostname_completion
);
1464 FREE (value_cell (var
));
1465 var_setvalue (var
, savestring (rl_completer_word_break_characters
));
1470 /* When this function returns, rl_completer_word_break_characters points to
1473 assign_comp_wordbreaks (self
, value
, unused
, key
)
1479 if (rl_completer_word_break_characters
&&
1480 rl_completer_word_break_characters
!= rl_basic_word_break_characters
)
1481 free (rl_completer_word_break_characters
);
1483 rl_completer_word_break_characters
= savestring (value
);
1486 #endif /* READLINE */
1488 #if defined (PUSHD_AND_POPD) && defined (ARRAY_VARS)
1490 assign_dirstack (self
, value
, ind
, key
)
1496 set_dirstack_element (ind
, 1, value
);
1507 l
= get_directory_stack (0);
1508 a
= array_from_word_list (l
);
1509 array_dispose (array_cell (self
));
1511 var_setarray (self
, a
);
1514 #endif /* PUSHD AND POPD && ARRAY_VARS */
1516 #if defined (ARRAY_VARS)
1517 /* We don't want to initialize the group set with a call to getgroups()
1518 unless we're asked to, but we only want to do it once. */
1526 static char **group_set
= (char **)NULL
;
1530 group_set
= get_group_list (&ng
);
1531 a
= array_cell (self
);
1532 for (i
= 0; i
< ng
; i
++)
1533 array_insert (a
, i
, group_set
[i
]);
1539 build_hashcmd (self
)
1545 BUCKET_CONTENTS
*item
;
1547 h
= assoc_cell (self
);
1551 if (hashed_filenames
== 0 || HASH_ENTRIES (hashed_filenames
) == 0)
1553 var_setvalue (self
, (char *)NULL
);
1557 h
= assoc_create (hashed_filenames
->nbuckets
);
1558 for (i
= 0; i
< hashed_filenames
->nbuckets
; i
++)
1560 for (item
= hash_items (i
, hashed_filenames
); item
; item
= item
->next
)
1562 k
= savestring (item
->key
);
1563 v
= pathdata(item
)->path
;
1564 assoc_insert (h
, k
, v
);
1568 var_setvalue (self
, (char *)h
);
1576 build_hashcmd (self
);
1581 assign_hashcmd (self
, value
, ind
, key
)
1587 phash_insert (key
, value
, 0, 0);
1588 return (build_hashcmd (self
));
1593 build_aliasvar (self
)
1599 BUCKET_CONTENTS
*item
;
1601 h
= assoc_cell (self
);
1605 if (aliases
== 0 || HASH_ENTRIES (aliases
) == 0)
1607 var_setvalue (self
, (char *)NULL
);
1611 h
= assoc_create (aliases
->nbuckets
);
1612 for (i
= 0; i
< aliases
->nbuckets
; i
++)
1614 for (item
= hash_items (i
, aliases
); item
; item
= item
->next
)
1616 k
= savestring (item
->key
);
1617 v
= ((alias_t
*)(item
->data
))->value
;
1618 assoc_insert (h
, k
, v
);
1622 var_setvalue (self
, (char *)h
);
1630 build_aliasvar (self
);
1635 assign_aliasvar (self
, value
, ind
, key
)
1641 add_alias (key
, value
);
1642 return (build_aliasvar (self
));
1646 #endif /* ARRAY_VARS */
1648 /* If ARRAY_VARS is not defined, this just returns the name of any
1649 currently-executing function. If we have arrays, it's a call stack. */
1654 #if ! defined (ARRAY_VARS)
1656 if (variable_context
&& this_shell_function
)
1658 FREE (value_cell (self
));
1659 t
= savestring (this_shell_function
->name
);
1660 var_setvalue (self
, t
);
1667 make_funcname_visible (on_or_off
)
1672 v
= find_variable ("FUNCNAME");
1673 if (v
== 0 || v
->dynamic_value
== 0)
1677 VUNSETATTR (v
, att_invisible
);
1679 VSETATTR (v
, att_invisible
);
1683 init_funcname_var ()
1687 v
= find_variable ("FUNCNAME");
1690 #if defined (ARRAY_VARS)
1691 INIT_DYNAMIC_ARRAY_VAR ("FUNCNAME", get_funcname
, null_array_assign
);
1693 INIT_DYNAMIC_VAR ("FUNCNAME", (char *)NULL
, get_funcname
, null_assign
);
1695 VSETATTR (v
, att_invisible
|att_noassign
);
1700 initialize_dynamic_variables ()
1704 v
= init_seconds_var ();
1706 INIT_DYNAMIC_VAR ("BASH_COMMAND", (char *)NULL
, get_bash_command
, (sh_var_assign_func_t
*)NULL
);
1707 INIT_DYNAMIC_VAR ("BASH_SUBSHELL", (char *)NULL
, get_subshell
, assign_subshell
);
1709 INIT_DYNAMIC_VAR ("RANDOM", (char *)NULL
, get_random
, assign_random
);
1710 VSETATTR (v
, att_integer
);
1711 INIT_DYNAMIC_VAR ("LINENO", (char *)NULL
, get_lineno
, assign_lineno
);
1712 VSETATTR (v
, att_integer
);
1714 INIT_DYNAMIC_VAR ("BASHPID", (char *)NULL
, get_bashpid
, null_assign
);
1715 VSETATTR (v
, att_integer
|att_readonly
);
1717 #if defined (HISTORY)
1718 INIT_DYNAMIC_VAR ("HISTCMD", (char *)NULL
, get_histcmd
, (sh_var_assign_func_t
*)NULL
);
1719 VSETATTR (v
, att_integer
);
1722 #if defined (READLINE)
1723 INIT_DYNAMIC_VAR ("COMP_WORDBREAKS", (char *)NULL
, get_comp_wordbreaks
, assign_comp_wordbreaks
);
1726 #if defined (PUSHD_AND_POPD) && defined (ARRAY_VARS)
1727 v
= init_dynamic_array_var ("DIRSTACK", get_dirstack
, assign_dirstack
, 0);
1728 #endif /* PUSHD_AND_POPD && ARRAY_VARS */
1730 #if defined (ARRAY_VARS)
1731 v
= init_dynamic_array_var ("GROUPS", get_groupset
, null_array_assign
, att_noassign
);
1733 # if defined (DEBUGGER)
1734 v
= init_dynamic_array_var ("BASH_ARGC", get_self
, null_array_assign
, att_noassign
|att_nounset
);
1735 v
= init_dynamic_array_var ("BASH_ARGV", get_self
, null_array_assign
, att_noassign
|att_nounset
);
1736 # endif /* DEBUGGER */
1737 v
= init_dynamic_array_var ("BASH_SOURCE", get_self
, null_array_assign
, att_noassign
|att_nounset
);
1738 v
= init_dynamic_array_var ("BASH_LINENO", get_self
, null_array_assign
, att_noassign
|att_nounset
);
1740 v
= init_dynamic_assoc_var ("BASH_CMDS", get_hashcmd
, assign_hashcmd
, att_nofree
);
1741 # if defined (ALIAS)
1742 v
= init_dynamic_assoc_var ("BASH_ALIASES", get_aliasvar
, assign_aliasvar
, att_nofree
);
1746 v
= init_funcname_var ();
1749 /* **************************************************************** */
1751 /* Retrieving variables and values */
1753 /* **************************************************************** */
1755 /* How to get a pointer to the shell variable or function named NAME.
1756 HASHED_VARS is a pointer to the hash table containing the list
1757 of interest (either variables or functions). */
1760 hash_lookup (name
, hashed_vars
)
1762 HASH_TABLE
*hashed_vars
;
1764 BUCKET_CONTENTS
*bucket
;
1766 bucket
= hash_search (name
, hashed_vars
, 0);
1767 /* If we find the name in HASHED_VARS, set LAST_TABLE_SEARCHED to that
1770 last_table_searched
= hashed_vars
;
1771 return (bucket
? (SHELL_VAR
*)bucket
->data
: (SHELL_VAR
*)NULL
);
1775 var_lookup (name
, vcontext
)
1777 VAR_CONTEXT
*vcontext
;
1782 v
= (SHELL_VAR
*)NULL
;
1783 for (vc
= vcontext
; vc
; vc
= vc
->down
)
1784 if (v
= hash_lookup (name
, vc
->table
))
1790 /* Look up the variable entry named NAME. If SEARCH_TEMPENV is non-zero,
1791 then also search the temporarily built list of exported variables.
1792 The lookup order is:
1794 shell_variables list
1798 find_variable_internal (name
, force_tempenv
)
1806 var
= (SHELL_VAR
*)NULL
;
1808 /* If explicitly requested, first look in the temporary environment for
1809 the variable. This allows constructs such as "foo=x eval 'echo $foo'"
1810 to get the `exported' value of $foo. This happens if we are executing
1811 a function or builtin, or if we are looking up a variable in a
1812 "subshell environment". */
1813 search_tempenv
= force_tempenv
|| (expanding_redir
== 0 && subshell_environment
);
1815 if (search_tempenv
&& temporary_env
)
1816 var
= hash_lookup (name
, temporary_env
);
1818 vc
= shell_variables
;
1820 if (search_tempenv
== 0 && /* (subshell_environment & SUBSHELL_COMSUB) && */
1822 (this_shell_builtin
== eval_builtin
|| this_shell_builtin
== command_builtin
))
1824 itrace("find_variable_internal: search_tempenv == 0: skipping VC_BLTNENV");
1825 while (vc
&& (vc
->flags
& VC_BLTNENV
))
1828 vc
= shell_variables
;
1833 var
= var_lookup (name
, vc
);
1836 return ((SHELL_VAR
*)NULL
);
1838 return (var
->dynamic_value
? (*(var
->dynamic_value
)) (var
) : var
);
1841 /* Look up and resolve the chain of nameref variables starting at V all the
1842 way to NULL or non-nameref. */
1844 find_variable_nameref (v
)
1849 SHELL_VAR
*orig
, *oldv
;
1853 while (v
&& nameref_p (v
))
1856 if (level
> NAMEREF_MAX
)
1857 return ((SHELL_VAR
*)0); /* error message here? */
1858 newname
= nameref_cell (v
);
1859 if (newname
== 0 || *newname
== '\0')
1860 return ((SHELL_VAR
*)0);
1862 v
= find_variable_internal (newname
, (expanding_redir
== 0 && (assigning_in_environment
|| executing_builtin
)));
1863 if (v
== orig
|| v
== oldv
)
1865 internal_warning (_("%s: circular name reference"), orig
->name
);
1866 return ((SHELL_VAR
*)0);
1872 /* Resolve the chain of nameref variables for NAME. XXX - could change later */
1874 find_variable_last_nameref (name
)
1881 nv
= v
= find_variable_noref (name
);
1883 while (v
&& nameref_p (v
))
1886 if (level
> NAMEREF_MAX
)
1887 return ((SHELL_VAR
*)0); /* error message here? */
1888 newname
= nameref_cell (v
);
1889 if (newname
== 0 || *newname
== '\0')
1890 return ((SHELL_VAR
*)0);
1892 v
= find_variable_internal (newname
, (expanding_redir
== 0 && (assigning_in_environment
|| executing_builtin
)));
1897 /* Resolve the chain of nameref variables for NAME. XXX - could change later */
1899 find_global_variable_last_nameref (name
)
1906 nv
= v
= find_global_variable_noref (name
);
1908 while (v
&& nameref_p (v
))
1911 if (level
> NAMEREF_MAX
)
1912 return ((SHELL_VAR
*)0); /* error message here? */
1913 newname
= nameref_cell (v
);
1914 if (newname
== 0 || *newname
== '\0')
1915 return ((SHELL_VAR
*)0);
1917 v
= find_global_variable_noref (newname
);
1923 find_nameref_at_context (v
, vc
)
1927 SHELL_VAR
*nv
, *nv2
;
1934 while (nv
&& nameref_p (nv
))
1937 if (level
> NAMEREF_MAX
)
1938 return ((SHELL_VAR
*)NULL
);
1939 newname
= nameref_cell (nv
);
1940 if (newname
== 0 || *newname
== '\0')
1941 return ((SHELL_VAR
*)NULL
);
1942 nv2
= hash_lookup (newname
, vc
->table
);
1950 /* Do nameref resolution from the VC, which is the local context for some
1951 function or builtin, `up' the chain to the global variables context. If
1952 NVCP is not NULL, return the variable context where we finally ended the
1953 nameref resolution (so the bind_variable_internal can use the correct
1954 variable context and hash table). */
1956 find_variable_nameref_context (v
, vc
, nvcp
)
1961 SHELL_VAR
*nv
, *nv2
;
1964 /* Look starting at the current context all the way `up' */
1965 for (nv
= v
, nvc
= vc
; nvc
; nvc
= nvc
->down
)
1967 nv2
= find_nameref_at_context (nv
, nvc
);
1974 return (nameref_p (nv
) ? (SHELL_VAR
*)NULL
: nv
);
1977 /* Do nameref resolution from the VC, which is the local context for some
1978 function or builtin, `up' the chain to the global variables context. If
1979 NVCP is not NULL, return the variable context where we finally ended the
1980 nameref resolution (so the bind_variable_internal can use the correct
1981 variable context and hash table). */
1983 find_variable_last_nameref_context (v
, vc
, nvcp
)
1988 SHELL_VAR
*nv
, *nv2
;
1991 /* Look starting at the current context all the way `up' */
1992 for (nv
= v
, nvc
= vc
; nvc
; nvc
= nvc
->down
)
1994 nv2
= find_nameref_at_context (nv
, nvc
);
2001 return (nameref_p (nv
) ? nv
: (SHELL_VAR
*)NULL
);
2004 /* Find a variable, forcing a search of the temporary environment first */
2006 find_variable_tempenv (name
)
2011 var
= find_variable_internal (name
, 1);
2012 if (var
&& nameref_p (var
))
2013 var
= find_variable_nameref (var
);
2017 /* Find a variable, not forcing a search of the temporary environment first */
2019 find_variable_notempenv (name
)
2024 var
= find_variable_internal (name
, 0);
2025 if (var
&& nameref_p (var
))
2026 var
= find_variable_nameref (var
);
2031 find_global_variable (name
)
2036 var
= var_lookup (name
, global_variables
);
2037 if (var
&& nameref_p (var
))
2038 var
= find_variable_nameref (var
);
2041 return ((SHELL_VAR
*)NULL
);
2043 return (var
->dynamic_value
? (*(var
->dynamic_value
)) (var
) : var
);
2047 find_global_variable_noref (name
)
2052 var
= var_lookup (name
, global_variables
);
2055 return ((SHELL_VAR
*)NULL
);
2057 return (var
->dynamic_value
? (*(var
->dynamic_value
)) (var
) : var
);
2061 find_shell_variable (name
)
2066 var
= var_lookup (name
, shell_variables
);
2067 if (var
&& nameref_p (var
))
2068 var
= find_variable_nameref (var
);
2071 return ((SHELL_VAR
*)NULL
);
2073 return (var
->dynamic_value
? (*(var
->dynamic_value
)) (var
) : var
);
2076 /* Look up the variable entry named NAME. Returns the entry or NULL. */
2078 find_variable (name
)
2083 last_table_searched
= 0;
2084 v
= find_variable_internal (name
, (expanding_redir
== 0 && (assigning_in_environment
|| executing_builtin
)));
2085 if (v
&& nameref_p (v
))
2086 v
= find_variable_nameref (v
);
2091 find_variable_noref (name
)
2096 v
= find_variable_internal (name
, (expanding_redir
== 0 && (assigning_in_environment
|| executing_builtin
)));
2100 /* Look up the function entry whose name matches STRING.
2101 Returns the entry or NULL. */
2103 find_function (name
)
2106 return (hash_lookup (name
, shell_functions
));
2109 /* Find the function definition for the shell function named NAME. Returns
2110 the entry or NULL. */
2112 find_function_def (name
)
2115 #if defined (DEBUGGER)
2116 return ((FUNCTION_DEF
*)hash_lookup (name
, shell_function_defs
));
2118 return ((FUNCTION_DEF
*)0);
2122 /* Return the value of VAR. VAR is assumed to have been the result of a
2123 lookup without any subscript, if arrays are compiled into the shell. */
2125 get_variable_value (var
)
2129 return ((char *)NULL
);
2130 #if defined (ARRAY_VARS)
2131 else if (array_p (var
))
2132 return (array_reference (array_cell (var
), 0));
2133 else if (assoc_p (var
))
2134 return (assoc_reference (assoc_cell (var
), "0"));
2137 return (value_cell (var
));
2140 /* Return the string value of a variable. Return NULL if the variable
2141 doesn't exist. Don't cons a new string. This is a potential memory
2142 leak if the variable is found in the temporary environment. Since
2143 functions and variables have separate name spaces, returns NULL if
2144 var_name is a shell function only. */
2146 get_string_value (var_name
)
2147 const char *var_name
;
2151 var
= find_variable (var_name
);
2152 return ((var
) ? get_variable_value (var
) : (char *)NULL
);
2155 /* This is present for use by the tilde and readline libraries. */
2157 sh_get_env_value (v
)
2160 return get_string_value (v
);
2163 /* **************************************************************** */
2165 /* Creating and setting variables */
2167 /* **************************************************************** */
2169 /* Set NAME to VALUE if NAME has no value. */
2171 set_if_not (name
, value
)
2176 if (shell_variables
== 0)
2177 create_variable_tables ();
2179 v
= find_variable (name
);
2181 v
= bind_variable_internal (name
, value
, global_variables
->table
, HASH_NOSRCH
, 0);
2185 /* Create a local variable referenced by NAME. */
2187 make_local_variable (name
)
2190 SHELL_VAR
*new_var
, *old_var
;
2195 /* local foo; local foo; is a no-op. */
2196 old_var
= find_variable (name
);
2197 if (old_var
&& local_p (old_var
) && old_var
->context
== variable_context
)
2199 VUNSETATTR (old_var
, att_invisible
);
2203 was_tmpvar
= old_var
&& tempvar_p (old_var
);
2204 /* If we're making a local variable in a shell function, the temporary env
2205 has already been merged into the function's variable context stack. We
2206 can assume that a temporary var in the same context appears in the same
2207 VAR_CONTEXT and can safely be returned without creating a new variable
2208 (which results in duplicate names in the same VAR_CONTEXT->table */
2209 /* We can't just test tmpvar_p because variables in the temporary env given
2210 to a shell function appear in the function's local variable VAR_CONTEXT
2211 but retain their tempvar attribute. We want temporary variables that are
2212 found in temporary_env, hence the test for last_table_searched, which is
2213 set in hash_lookup and only (so far) checked here. */
2214 if (was_tmpvar
&& old_var
->context
== variable_context
&& last_table_searched
!= temporary_env
)
2216 VUNSETATTR (old_var
, att_invisible
);
2220 tmp_value
= value_cell (old_var
);
2222 for (vc
= shell_variables
; vc
; vc
= vc
->down
)
2223 if (vc_isfuncenv (vc
) && vc
->scope
== variable_context
)
2228 internal_error (_("make_local_variable: no function context at current scope"));
2229 return ((SHELL_VAR
*)NULL
);
2231 else if (vc
->table
== 0)
2232 vc
->table
= hash_create (TEMPENV_HASH_BUCKETS
);
2234 /* Since this is called only from the local/declare/typeset code, we can
2235 call builtin_error here without worry (of course, it will also work
2236 for anything that sets this_command_name). Variables with the `noassign'
2237 attribute may not be made local. The test against old_var's context
2238 level is to disallow local copies of readonly global variables (since I
2239 believe that this could be a security hole). Readonly copies of calling
2240 function local variables are OK. */
2241 if (old_var
&& (noassign_p (old_var
) ||
2242 (readonly_p (old_var
) && old_var
->context
== 0)))
2244 if (readonly_p (old_var
))
2246 else if (noassign_p (old_var
))
2247 builtin_error (_("%s: variable may not be assigned value"), name
);
2249 /* Let noassign variables through with a warning */
2250 if (readonly_p (old_var
))
2252 return ((SHELL_VAR
*)NULL
);
2256 new_var
= make_new_variable (name
, vc
->table
);
2259 new_var
= make_new_variable (name
, vc
->table
);
2261 /* If we found this variable in one of the temporary environments,
2262 inherit its value. Watch to see if this causes problems with
2263 things like `x=4 local x'. XXX - see above for temporary env
2264 variables with the same context level as variable_context */
2265 /* XXX - we should only do this if the variable is not an array. */
2267 var_setvalue (new_var
, savestring (tmp_value
));
2269 new_var
->attributes
= exported_p (old_var
) ? att_exported
: 0;
2272 vc
->flags
|= VC_HASLOCAL
;
2274 new_var
->context
= variable_context
;
2275 VSETATTR (new_var
, att_local
);
2283 /* Create a new shell variable with name NAME. */
2285 new_shell_variable (name
)
2290 entry
= (SHELL_VAR
*)xmalloc (sizeof (SHELL_VAR
));
2292 entry
->name
= savestring (name
);
2293 var_setvalue (entry
, (char *)NULL
);
2294 CLEAR_EXPORTSTR (entry
);
2296 entry
->dynamic_value
= (sh_var_value_func_t
*)NULL
;
2297 entry
->assign_func
= (sh_var_assign_func_t
*)NULL
;
2299 entry
->attributes
= 0;
2301 /* Always assume variables are to be made at toplevel!
2302 make_local_variable has the responsibilty of changing the
2303 variable context. */
2309 /* Create a new shell variable with name NAME and add it to the hash table
2312 make_new_variable (name
, table
)
2317 BUCKET_CONTENTS
*elt
;
2319 entry
= new_shell_variable (name
);
2321 /* Make sure we have a shell_variables hash table to add to. */
2322 if (shell_variables
== 0)
2323 create_variable_tables ();
2325 elt
= hash_insert (savestring (name
), table
, HASH_NOSRCH
);
2326 elt
->data
= (PTR_T
)entry
;
2331 #if defined (ARRAY_VARS)
2333 make_new_array_variable (name
)
2339 entry
= make_new_variable (name
, global_variables
->table
);
2340 array
= array_create ();
2342 var_setarray (entry
, array
);
2343 VSETATTR (entry
, att_array
);
2348 make_local_array_variable (name
, assoc_ok
)
2355 var
= make_local_variable (name
);
2356 if (var
== 0 || array_p (var
) || (assoc_ok
&& assoc_p (var
)))
2359 array
= array_create ();
2361 dispose_variable_value (var
);
2362 var_setarray (var
, array
);
2363 VSETATTR (var
, att_array
);
2368 make_new_assoc_variable (name
)
2374 entry
= make_new_variable (name
, global_variables
->table
);
2375 hash
= assoc_create (0);
2377 var_setassoc (entry
, hash
);
2378 VSETATTR (entry
, att_assoc
);
2383 make_local_assoc_variable (name
)
2389 var
= make_local_variable (name
);
2390 if (var
== 0 || assoc_p (var
))
2393 dispose_variable_value (var
);
2394 hash
= assoc_create (0);
2396 var_setassoc (var
, hash
);
2397 VSETATTR (var
, att_assoc
);
2403 make_variable_value (var
, value
, flags
)
2408 char *retval
, *oval
;
2409 intmax_t lval
, rval
;
2410 int expok
, olen
, op
;
2412 /* If this variable has had its type set to integer (via `declare -i'),
2413 then do expression evaluation on it and store the result. The
2414 functions in expr.c (evalexp()) and bind_int_variable() are responsible
2415 for turning off the integer flag if they don't want further
2417 if (integer_p (var
))
2419 if (flags
& ASS_APPEND
)
2421 oval
= value_cell (var
);
2422 lval
= evalexp (oval
, &expok
); /* ksh93 seems to do this */
2425 top_level_cleanup ();
2426 jump_to_top_level (DISCARD
);
2429 rval
= evalexp (value
, &expok
);
2432 top_level_cleanup ();
2433 jump_to_top_level (DISCARD
);
2435 if (flags
& ASS_APPEND
)
2437 retval
= itos (rval
);
2439 #if defined (CASEMOD_ATTRS)
2440 else if (capcase_p (var
) || uppercase_p (var
) || lowercase_p (var
))
2442 if (flags
& ASS_APPEND
)
2444 oval
= get_variable_value (var
);
2445 if (oval
== 0) /* paranoia */
2447 olen
= STRLEN (oval
);
2448 retval
= (char *)xmalloc (olen
+ (value
? STRLEN (value
) : 0) + 1);
2449 strcpy (retval
, oval
);
2451 strcpy (retval
+olen
, value
);
2454 retval
= savestring (value
);
2457 retval
= (char *)xmalloc (1);
2460 op
= capcase_p (var
) ? CASE_CAPITALIZE
2461 : (uppercase_p (var
) ? CASE_UPPER
: CASE_LOWER
);
2462 oval
= sh_modcase (retval
, (char *)0, op
);
2466 #endif /* CASEMOD_ATTRS */
2469 if (flags
& ASS_APPEND
)
2471 oval
= get_variable_value (var
);
2472 if (oval
== 0) /* paranoia */
2474 olen
= STRLEN (oval
);
2475 retval
= (char *)xmalloc (olen
+ (value
? STRLEN (value
) : 0) + 1);
2476 strcpy (retval
, oval
);
2478 strcpy (retval
+olen
, value
);
2481 retval
= savestring (value
);
2484 retval
= (char *)xmalloc (1);
2489 retval
= (char *)NULL
;
2494 /* Bind a variable NAME to VALUE in the HASH_TABLE TABLE, which may be the
2495 temporary environment (but usually is not). */
2497 bind_variable_internal (name
, value
, table
, hflags
, aflags
)
2506 entry
= (hflags
& HASH_NOSRCH
) ? (SHELL_VAR
*)NULL
: hash_lookup (name
, table
);
2507 /* Follow the nameref chain here if this is the global variables table */
2508 if (entry
&& nameref_p (entry
) && (invisible_p (entry
) == 0) && table
== global_variables
->table
)
2510 entry
= find_global_variable (entry
->name
);
2511 /* Let's see if we have a nameref referencing a variable that hasn't yet
2514 entry
= find_variable_last_nameref (name
); /* XXX */
2515 if (entry
== 0) /* just in case */
2519 /* The first clause handles `declare -n ref; ref=x;' */
2520 if (entry
&& invisible_p (entry
) && nameref_p (entry
))
2522 else if (entry
&& nameref_p (entry
))
2524 newval
= nameref_cell (entry
);
2525 #if defined (ARRAY_VARS)
2526 /* declare -n foo=x[2] */
2527 if (valid_array_reference (newval
))
2528 /* XXX - should it be aflags? */
2529 entry
= assign_array_element (newval
, make_variable_value (entry
, value
, 0), aflags
);
2533 entry
= make_new_variable (newval
, table
);
2534 var_setvalue (entry
, make_variable_value (entry
, value
, 0));
2537 else if (entry
== 0)
2539 entry
= make_new_variable (name
, table
);
2540 var_setvalue (entry
, make_variable_value (entry
, value
, 0)); /* XXX */
2542 else if (entry
->assign_func
) /* array vars have assign functions now */
2544 INVALIDATE_EXPORTSTR (entry
);
2545 newval
= (aflags
& ASS_APPEND
) ? make_variable_value (entry
, value
, aflags
) : value
;
2546 if (assoc_p (entry
))
2547 entry
= (*(entry
->assign_func
)) (entry
, newval
, -1, savestring ("0"));
2548 else if (array_p (entry
))
2549 entry
= (*(entry
->assign_func
)) (entry
, newval
, 0, 0);
2551 entry
= (*(entry
->assign_func
)) (entry
, newval
, -1, 0);
2552 if (newval
!= value
)
2559 if (readonly_p (entry
) || noassign_p (entry
))
2561 if (readonly_p (entry
))
2562 err_readonly (name
);
2566 /* Variables which are bound are visible. */
2567 VUNSETATTR (entry
, att_invisible
);
2569 #if defined (ARRAY_VARS)
2570 if (assoc_p (entry
) || array_p (entry
))
2571 newval
= make_array_variable_value (entry
, 0, "0", value
, aflags
);
2575 newval
= make_variable_value (entry
, value
, aflags
); /* XXX */
2577 /* Invalidate any cached export string */
2578 INVALIDATE_EXPORTSTR (entry
);
2580 #if defined (ARRAY_VARS)
2581 /* XXX -- this bears looking at again -- XXX */
2582 /* If an existing array variable x is being assigned to with x=b or
2583 `read x' or something of that nature, silently convert it to
2584 x[0]=b or `read x[0]'. */
2585 if (assoc_p (entry
))
2587 assoc_insert (assoc_cell (entry
), savestring ("0"), newval
);
2590 else if (array_p (entry
))
2592 array_insert (array_cell (entry
), 0, newval
);
2598 FREE (value_cell (entry
));
2599 var_setvalue (entry
, newval
);
2603 if (mark_modified_vars
)
2604 VSETATTR (entry
, att_exported
);
2606 if (exported_p (entry
))
2607 array_needs_making
= 1;
2612 /* Bind a variable NAME to VALUE. This conses up the name
2613 and value strings. If we have a temporary environment, we bind there
2614 first, then we bind into shell_variables. */
2617 bind_variable (name
, value
, flags
)
2623 VAR_CONTEXT
*vc
, *nvc
;
2626 if (shell_variables
== 0)
2627 create_variable_tables ();
2629 /* If we have a temporary environment, look there first for the variable,
2630 and, if found, modify the value there before modifying it in the
2631 shell_variables table. This allows sourced scripts to modify values
2632 given to them in a temporary environment while modifying the variable
2633 value that the caller sees. */
2635 bind_tempenv_variable (name
, value
);
2637 /* XXX -- handle local variables here. */
2638 for (vc
= shell_variables
; vc
; vc
= vc
->down
)
2640 if (vc_isfuncenv (vc
) || vc_isbltnenv (vc
))
2642 v
= hash_lookup (name
, vc
->table
);
2644 if (v
&& nameref_p (v
))
2646 nv
= find_variable_nameref_context (v
, vc
, &nvc
);
2649 nv
= find_variable_last_nameref_context (v
, vc
, &nvc
);
2650 if (nv
&& nameref_p (nv
))
2651 return (bind_variable_internal (nameref_cell (nv
), value
, nvc
->table
, 0, flags
));
2659 return (bind_variable_internal (v
->name
, value
, nvc
->table
, 0, flags
));
2662 /* bind_variable_internal will handle nameref resolution in this case */
2663 return (bind_variable_internal (name
, value
, global_variables
->table
, 0, flags
));
2667 bind_global_variable (name
, value
, flags
)
2673 VAR_CONTEXT
*vc
, *nvc
;
2676 if (shell_variables
== 0)
2677 create_variable_tables ();
2679 /* bind_variable_internal will handle nameref resolution in this case */
2680 return (bind_variable_internal (name
, value
, global_variables
->table
, 0, flags
));
2683 /* Make VAR, a simple shell variable, have value VALUE. Once assigned a
2684 value, variables are no longer invisible. This is a duplicate of part
2685 of the internals of bind_variable. If the variable is exported, or
2686 all modified variables should be exported, mark the variable for export
2687 and note that the export environment needs to be recreated. */
2689 bind_variable_value (var
, value
, aflags
)
2696 VUNSETATTR (var
, att_invisible
);
2698 if (var
->assign_func
)
2700 /* If we're appending, we need the old value, so use
2701 make_variable_value */
2702 t
= (aflags
& ASS_APPEND
) ? make_variable_value (var
, value
, aflags
) : value
;
2703 (*(var
->assign_func
)) (var
, t
, -1, 0);
2704 if (t
!= value
&& t
)
2709 t
= make_variable_value (var
, value
, aflags
);
2710 FREE (value_cell (var
));
2711 var_setvalue (var
, t
);
2714 INVALIDATE_EXPORTSTR (var
);
2716 if (mark_modified_vars
)
2717 VSETATTR (var
, att_exported
);
2719 if (exported_p (var
))
2720 array_needs_making
= 1;
2725 /* Bind/create a shell variable with the name LHS to the RHS.
2726 This creates or modifies a variable such that it is an integer.
2728 This used to be in expr.c, but it is here so that all of the
2729 variable binding stuff is localized. Since we don't want any
2730 recursive evaluation from bind_variable() (possible without this code,
2731 since bind_variable() calls the evaluator for variables with the integer
2732 attribute set), we temporarily turn off the integer attribute for each
2733 variable we set here, then turn it back on after binding as necessary. */
2736 bind_int_variable (lhs
, rhs
)
2739 register SHELL_VAR
*v
;
2740 int isint
, isarr
, implicitarray
;
2742 isint
= isarr
= implicitarray
= 0;
2743 #if defined (ARRAY_VARS)
2744 if (valid_array_reference (lhs
))
2747 v
= array_variable_part (lhs
, (char **)0, (int *)0);
2751 v
= find_variable (lhs
);
2755 isint
= integer_p (v
);
2756 VUNSETATTR (v
, att_integer
);
2757 #if defined (ARRAY_VARS)
2758 if (array_p (v
) && isarr
== 0)
2763 #if defined (ARRAY_VARS)
2765 v
= assign_array_element (lhs
, rhs
, 0);
2766 else if (implicitarray
)
2767 v
= bind_array_variable (lhs
, 0, rhs
, 0);
2770 v
= bind_variable (lhs
, rhs
, 0);
2773 VSETATTR (v
, att_integer
);
2775 VUNSETATTR (v
, att_invisible
);
2781 bind_var_to_int (var
, val
)
2785 char ibuf
[INT_STRLEN_BOUND (intmax_t) + 1], *p
;
2787 p
= fmtulong (val
, 10, ibuf
, sizeof (ibuf
), 0);
2788 return (bind_int_variable (var
, p
));
2791 /* Do a function binding to a variable. You pass the name and
2792 the command to bind to. This conses the name and command. */
2794 bind_function (name
, value
)
2800 entry
= find_function (name
);
2803 BUCKET_CONTENTS
*elt
;
2805 elt
= hash_insert (savestring (name
), shell_functions
, HASH_NOSRCH
);
2806 entry
= new_shell_variable (name
);
2807 elt
->data
= (PTR_T
)entry
;
2810 INVALIDATE_EXPORTSTR (entry
);
2812 if (var_isset (entry
))
2813 dispose_command (function_cell (entry
));
2816 var_setfunc (entry
, copy_command (value
));
2818 var_setfunc (entry
, 0);
2820 VSETATTR (entry
, att_function
);
2822 if (mark_modified_vars
)
2823 VSETATTR (entry
, att_exported
);
2825 VUNSETATTR (entry
, att_invisible
); /* Just to be sure */
2827 if (exported_p (entry
))
2828 array_needs_making
= 1;
2830 #if defined (PROGRAMMABLE_COMPLETION)
2831 set_itemlist_dirty (&it_functions
);
2837 #if defined (DEBUGGER)
2838 /* Bind a function definition, which includes source file and line number
2839 information in addition to the command, into the FUNCTION_DEF hash table.*/
2841 bind_function_def (name
, value
)
2843 FUNCTION_DEF
*value
;
2845 FUNCTION_DEF
*entry
;
2846 BUCKET_CONTENTS
*elt
;
2849 entry
= find_function_def (name
);
2852 dispose_function_def_contents (entry
);
2853 entry
= copy_function_def_contents (value
, entry
);
2857 cmd
= value
->command
;
2859 entry
= copy_function_def (value
);
2860 value
->command
= cmd
;
2862 elt
= hash_insert (savestring (name
), shell_function_defs
, HASH_NOSRCH
);
2863 elt
->data
= (PTR_T
*)entry
;
2866 #endif /* DEBUGGER */
2868 /* Add STRING, which is of the form foo=bar, to the temporary environment
2869 HASH_TABLE (temporary_env). The functions in execute_cmd.c are
2870 responsible for moving the main temporary env to one of the other
2871 temporary environments. The expansion code in subst.c calls this. */
2873 assign_in_env (word
, flags
)
2878 char *name
, *temp
, *value
;
2882 string
= word
->word
;
2885 offset
= assignment (string
, 0);
2886 name
= savestring (string
);
2887 value
= (char *)NULL
;
2889 if (name
[offset
] == '=')
2893 /* ignore the `+' when assigning temporary environment */
2894 if (name
[offset
- 1] == '+')
2896 name
[offset
- 1] = '\0';
2897 aflags
|= ASS_APPEND
;
2900 var
= find_variable (name
);
2901 if (var
&& (readonly_p (var
) || noassign_p (var
)))
2903 if (readonly_p (var
))
2904 err_readonly (name
);
2909 temp
= name
+ offset
+ 1;
2910 value
= expand_assignment_string_to_string (temp
, 0);
2912 if (var
&& (aflags
& ASS_APPEND
))
2914 temp
= make_variable_value (var
, value
, aflags
);
2920 if (temporary_env
== 0)
2921 temporary_env
= hash_create (TEMPENV_HASH_BUCKETS
);
2923 var
= hash_lookup (name
, temporary_env
);
2925 var
= make_new_variable (name
, temporary_env
);
2927 FREE (value_cell (var
));
2931 value
= (char *)xmalloc (1); /* like do_assignment_internal */
2935 var_setvalue (var
, value
);
2936 var
->attributes
|= (att_exported
|att_tempvar
);
2937 var
->context
= variable_context
; /* XXX */
2939 INVALIDATE_EXPORTSTR (var
);
2940 var
->exportstr
= mk_env_string (name
, value
);
2942 array_needs_making
= 1;
2945 stupidly_hack_special_variables (name
);
2947 if (echo_command_at_execute
)
2948 /* The Korn shell prints the `+ ' in front of assignment statements,
2950 xtrace_print_assignment (name
, value
, 0, 1);
2956 /* **************************************************************** */
2958 /* Copying variables */
2960 /* **************************************************************** */
2962 #ifdef INCLUDE_UNUSED
2963 /* Copy VAR to a new data structure and return that structure. */
2968 SHELL_VAR
*copy
= (SHELL_VAR
*)NULL
;
2972 copy
= (SHELL_VAR
*)xmalloc (sizeof (SHELL_VAR
));
2974 copy
->attributes
= var
->attributes
;
2975 copy
->name
= savestring (var
->name
);
2977 if (function_p (var
))
2978 var_setfunc (copy
, copy_command (function_cell (var
)));
2979 #if defined (ARRAY_VARS)
2980 else if (array_p (var
))
2981 var_setarray (copy
, array_copy (array_cell (var
)));
2982 else if (assoc_p (var
))
2983 var_setassoc (copy
, assoc_copy (assoc_cell (var
)));
2985 else if (nameref_cell (var
)) /* XXX - nameref */
2986 var_setref (copy
, savestring (nameref_cell (var
)));
2987 else if (value_cell (var
)) /* XXX - nameref */
2988 var_setvalue (copy
, savestring (value_cell (var
)));
2990 var_setvalue (copy
, (char *)NULL
);
2992 copy
->dynamic_value
= var
->dynamic_value
;
2993 copy
->assign_func
= var
->assign_func
;
2995 copy
->exportstr
= COPY_EXPORTSTR (var
);
2997 copy
->context
= var
->context
;
3003 /* **************************************************************** */
3005 /* Deleting and unsetting variables */
3007 /* **************************************************************** */
3009 /* Dispose of the information attached to VAR. */
3011 dispose_variable_value (var
)
3014 if (function_p (var
))
3015 dispose_command (function_cell (var
));
3016 #if defined (ARRAY_VARS)
3017 else if (array_p (var
))
3018 array_dispose (array_cell (var
));
3019 else if (assoc_p (var
))
3020 assoc_dispose (assoc_cell (var
));
3022 else if (nameref_p (var
))
3023 FREE (nameref_cell (var
));
3025 FREE (value_cell (var
));
3029 dispose_variable (var
)
3035 if (nofree_p (var
) == 0)
3036 dispose_variable_value (var
);
3038 FREE_EXPORTSTR (var
);
3042 if (exported_p (var
))
3043 array_needs_making
= 1;
3048 /* Unset the shell variable referenced by NAME. Unsetting a nameref variable
3049 unsets the variable it resolves to but leaves the nameref alone. */
3051 unbind_variable (name
)
3057 v
= var_lookup (name
, shell_variables
);
3058 nv
= (v
&& nameref_p (v
)) ? find_variable_nameref (v
) : (SHELL_VAR
*)NULL
;
3060 r
= nv
? makunbound (nv
->name
, shell_variables
) : makunbound (name
, shell_variables
);
3064 /* Unbind NAME, where NAME is assumed to be a nameref variable */
3066 unbind_nameref (name
)
3071 v
= var_lookup (name
, shell_variables
);
3072 if (v
&& nameref_p (v
))
3073 return makunbound (name
, shell_variables
);
3077 /* Unset the shell function named NAME. */
3082 BUCKET_CONTENTS
*elt
;
3085 elt
= hash_remove (name
, shell_functions
, 0);
3090 #if defined (PROGRAMMABLE_COMPLETION)
3091 set_itemlist_dirty (&it_functions
);
3094 func
= (SHELL_VAR
*)elt
->data
;
3097 if (exported_p (func
))
3098 array_needs_making
++;
3099 dispose_variable (func
);
3108 #if defined (DEBUGGER)
3110 unbind_function_def (name
)
3113 BUCKET_CONTENTS
*elt
;
3114 FUNCTION_DEF
*funcdef
;
3116 elt
= hash_remove (name
, shell_function_defs
, 0);
3121 funcdef
= (FUNCTION_DEF
*)elt
->data
;
3123 dispose_function_def (funcdef
);
3130 #endif /* DEBUGGER */
3132 /* Make the variable associated with NAME go away. HASH_LIST is the
3133 hash table from which this variable should be deleted (either
3134 shell_variables or shell_functions).
3135 Returns non-zero if the variable couldn't be found. */
3137 makunbound (name
, vc
)
3141 BUCKET_CONTENTS
*elt
, *new_elt
;
3146 for (elt
= (BUCKET_CONTENTS
*)NULL
, v
= vc
; v
; v
= v
->down
)
3147 if (elt
= hash_remove (name
, v
->table
, 0))
3153 old_var
= (SHELL_VAR
*)elt
->data
;
3155 if (old_var
&& exported_p (old_var
))
3156 array_needs_making
++;
3158 /* If we're unsetting a local variable and we're still executing inside
3159 the function, just mark the variable as invisible. The function
3160 eventually called by pop_var_context() will clean it up later. This
3161 must be done so that if the variable is subsequently assigned a new
3162 value inside the function, the `local' attribute is still present.
3163 We also need to add it back into the correct hash table. */
3164 if (old_var
&& local_p (old_var
) && variable_context
== old_var
->context
)
3166 if (nofree_p (old_var
))
3167 var_setvalue (old_var
, (char *)NULL
);
3168 #if defined (ARRAY_VARS)
3169 else if (array_p (old_var
))
3170 array_dispose (array_cell (old_var
));
3171 else if (assoc_p (old_var
))
3172 assoc_dispose (assoc_cell (old_var
));
3174 else if (nameref_p (old_var
))
3175 FREE (nameref_cell (old_var
));
3177 FREE (value_cell (old_var
));
3178 /* Reset the attributes. Preserve the export attribute if the variable
3179 came from a temporary environment. Make sure it stays local, and
3180 make it invisible. */
3181 old_var
->attributes
= (exported_p (old_var
) && tempvar_p (old_var
)) ? att_exported
: 0;
3182 VSETATTR (old_var
, att_local
);
3183 VSETATTR (old_var
, att_invisible
);
3184 var_setvalue (old_var
, (char *)NULL
);
3185 INVALIDATE_EXPORTSTR (old_var
);
3187 new_elt
= hash_insert (savestring (old_var
->name
), v
->table
, 0);
3188 new_elt
->data
= (PTR_T
)old_var
;
3189 stupidly_hack_special_variables (old_var
->name
);
3196 /* Have to save a copy of name here, because it might refer to
3197 old_var->name. If so, stupidly_hack_special_variables will
3198 reference freed memory. */
3199 t
= savestring (name
);
3204 dispose_variable (old_var
);
3205 stupidly_hack_special_variables (t
);
3211 /* Get rid of all of the variables in the current context. */
3213 kill_all_local_variables ()
3217 for (vc
= shell_variables
; vc
; vc
= vc
->down
)
3218 if (vc_isfuncenv (vc
) && vc
->scope
== variable_context
)
3223 if (vc
->table
&& vc_haslocals (vc
))
3225 delete_all_variables (vc
->table
);
3226 hash_dispose (vc
->table
);
3228 vc
->table
= (HASH_TABLE
*)NULL
;
3232 free_variable_hash_data (data
)
3237 var
= (SHELL_VAR
*)data
;
3238 dispose_variable (var
);
3241 /* Delete the entire contents of the hash table. */
3243 delete_all_variables (hashed_vars
)
3244 HASH_TABLE
*hashed_vars
;
3246 hash_flush (hashed_vars
, free_variable_hash_data
);
3249 /* **************************************************************** */
3251 /* Setting variable attributes */
3253 /* **************************************************************** */
3255 #define FIND_OR_MAKE_VARIABLE(name, entry) \
3258 entry = find_variable (name); \
3261 entry = bind_variable (name, "", 0); \
3262 if (!no_invisible_vars && entry) entry->attributes |= att_invisible; \
3267 /* Make the variable associated with NAME be readonly.
3268 If NAME does not exist yet, create it. */
3270 set_var_read_only (name
)
3275 FIND_OR_MAKE_VARIABLE (name
, entry
);
3276 VSETATTR (entry
, att_readonly
);
3279 #ifdef INCLUDE_UNUSED
3280 /* Make the function associated with NAME be readonly.
3281 If NAME does not exist, we just punt, like auto_export code below. */
3283 set_func_read_only (name
)
3288 entry
= find_function (name
);
3290 VSETATTR (entry
, att_readonly
);
3293 /* Make the variable associated with NAME be auto-exported.
3294 If NAME does not exist yet, create it. */
3296 set_var_auto_export (name
)
3301 FIND_OR_MAKE_VARIABLE (name
, entry
);
3302 set_auto_export (entry
);
3305 /* Make the function associated with NAME be auto-exported. */
3307 set_func_auto_export (name
)
3312 entry
= find_function (name
);
3314 set_auto_export (entry
);
3318 /* **************************************************************** */
3320 /* Creating lists of variables */
3322 /* **************************************************************** */
3325 vlist_alloc (nentries
)
3330 vlist
= (VARLIST
*)xmalloc (sizeof (VARLIST
));
3331 vlist
->list
= (SHELL_VAR
**)xmalloc ((nentries
+ 1) * sizeof (SHELL_VAR
*));
3332 vlist
->list_size
= nentries
;
3333 vlist
->list_len
= 0;
3334 vlist
->list
[0] = (SHELL_VAR
*)NULL
;
3340 vlist_realloc (vlist
, n
)
3345 return (vlist
= vlist_alloc (n
));
3346 if (n
> vlist
->list_size
)
3348 vlist
->list_size
= n
;
3349 vlist
->list
= (SHELL_VAR
**)xrealloc (vlist
->list
, (vlist
->list_size
+ 1) * sizeof (SHELL_VAR
*));
3355 vlist_add (vlist
, var
, flags
)
3362 for (i
= 0; i
< vlist
->list_len
; i
++)
3363 if (STREQ (var
->name
, vlist
->list
[i
]->name
))
3365 if (i
< vlist
->list_len
)
3368 if (i
>= vlist
->list_size
)
3369 vlist
= vlist_realloc (vlist
, vlist
->list_size
+ 16);
3371 vlist
->list
[vlist
->list_len
++] = var
;
3372 vlist
->list
[vlist
->list_len
] = (SHELL_VAR
*)NULL
;
3375 /* Map FUNCTION over the variables in VAR_HASH_TABLE. Return an array of the
3376 variables for which FUNCTION returns a non-zero value. A NULL value
3377 for FUNCTION means to use all variables. */
3379 map_over (function
, vc
)
3380 sh_var_map_func_t
*function
;
3388 for (nentries
= 0, v
= vc
; v
; v
= v
->down
)
3389 nentries
+= HASH_ENTRIES (v
->table
);
3392 return (SHELL_VAR
**)NULL
;
3394 vlist
= vlist_alloc (nentries
);
3396 for (v
= vc
; v
; v
= v
->down
)
3397 flatten (v
->table
, function
, vlist
, 0);
3405 map_over_funcs (function
)
3406 sh_var_map_func_t
*function
;
3411 if (shell_functions
== 0 || HASH_ENTRIES (shell_functions
) == 0)
3412 return ((SHELL_VAR
**)NULL
);
3414 vlist
= vlist_alloc (HASH_ENTRIES (shell_functions
));
3416 flatten (shell_functions
, function
, vlist
, 0);
3423 /* Flatten VAR_HASH_TABLE, applying FUNC to each member and adding those
3424 elements for which FUNC succeeds to VLIST->list. FLAGS is reserved
3425 for future use. Only unique names are added to VLIST. If FUNC is
3426 NULL, each variable in VAR_HASH_TABLE is added to VLIST. If VLIST is
3427 NULL, FUNC is applied to each SHELL_VAR in VAR_HASH_TABLE. If VLIST
3428 and FUNC are both NULL, nothing happens. */
3430 flatten (var_hash_table
, func
, vlist
, flags
)
3431 HASH_TABLE
*var_hash_table
;
3432 sh_var_map_func_t
*func
;
3437 register BUCKET_CONTENTS
*tlist
;
3441 if (var_hash_table
== 0 || (HASH_ENTRIES (var_hash_table
) == 0) || (vlist
== 0 && func
== 0))
3444 for (i
= 0; i
< var_hash_table
->nbuckets
; i
++)
3446 for (tlist
= hash_items (i
, var_hash_table
); tlist
; tlist
= tlist
->next
)
3448 var
= (SHELL_VAR
*)tlist
->data
;
3450 r
= func
? (*func
) (var
) : 1;
3452 vlist_add (vlist
, var
, flags
);
3458 sort_variables (array
)
3461 qsort (array
, strvec_len ((char **)array
), sizeof (SHELL_VAR
*), (QSFUNC
*)qsort_var_comp
);
3465 qsort_var_comp (var1
, var2
)
3466 SHELL_VAR
**var1
, **var2
;
3470 if ((result
= (*var1
)->name
[0] - (*var2
)->name
[0]) == 0)
3471 result
= strcmp ((*var1
)->name
, (*var2
)->name
);
3476 /* Apply FUNC to each variable in SHELL_VARIABLES, adding each one for
3477 which FUNC succeeds to an array of SHELL_VAR *s. Returns the array. */
3480 sh_var_map_func_t
*func
;
3484 list
= map_over (func
, shell_variables
);
3485 if (list
/* && posixly_correct */)
3486 sort_variables (list
);
3490 /* Apply FUNC to each variable in SHELL_FUNCTIONS, adding each one for
3491 which FUNC succeeds to an array of SHELL_VAR *s. Returns the array. */
3494 sh_var_map_func_t
*func
;
3498 list
= map_over_funcs (func
);
3499 if (list
/* && posixly_correct */)
3500 sort_variables (list
);
3504 /* Create a NULL terminated array of all the shell variables. */
3506 all_shell_variables ()
3508 return (vapply ((sh_var_map_func_t
*)NULL
));
3511 /* Create a NULL terminated array of all the shell functions. */
3513 all_shell_functions ()
3515 return (fapply ((sh_var_map_func_t
*)NULL
));
3522 return (invisible_p (var
) == 0);
3526 all_visible_functions ()
3528 return (fapply (visible_var
));
3532 all_visible_variables ()
3534 return (vapply (visible_var
));
3537 /* Return non-zero if the variable VAR is visible and exported. Array
3538 variables cannot be exported. */
3540 visible_and_exported (var
)
3543 return (invisible_p (var
) == 0 && exported_p (var
));
3546 /* Candidate variables for the export environment are either valid variables
3547 with the export attribute or invalid variables inherited from the initial
3548 environment and simply passed through. */
3550 export_environment_candidate (var
)
3553 return (exported_p (var
) && (invisible_p (var
) == 0 || imported_p (var
)));
3556 /* Return non-zero if VAR is a local variable in the current context and
3559 local_and_exported (var
)
3562 return (invisible_p (var
) == 0 && local_p (var
) && var
->context
== variable_context
&& exported_p (var
));
3566 all_exported_variables ()
3568 return (vapply (visible_and_exported
));
3572 local_exported_variables ()
3574 return (vapply (local_and_exported
));
3578 variable_in_context (var
)
3581 return (invisible_p (var
) == 0 && local_p (var
) && var
->context
== variable_context
);
3585 all_local_variables ()
3591 vc
= shell_variables
;
3592 for (vc
= shell_variables
; vc
; vc
= vc
->down
)
3593 if (vc_isfuncenv (vc
) && vc
->scope
== variable_context
)
3598 internal_error (_("all_local_variables: no function context at current scope"));
3599 return (SHELL_VAR
**)NULL
;
3601 if (vc
->table
== 0 || HASH_ENTRIES (vc
->table
) == 0 || vc_haslocals (vc
) == 0)
3602 return (SHELL_VAR
**)NULL
;
3604 vlist
= vlist_alloc (HASH_ENTRIES (vc
->table
));
3606 flatten (vc
->table
, variable_in_context
, vlist
, 0);
3611 sort_variables (ret
);
3615 #if defined (ARRAY_VARS)
3616 /* Return non-zero if the variable VAR is visible and an array. */
3618 visible_array_vars (var
)
3621 return (invisible_p (var
) == 0 && array_p (var
));
3625 all_array_variables ()
3627 return (vapply (visible_array_vars
));
3629 #endif /* ARRAY_VARS */
3632 all_variables_matching_prefix (prefix
)
3635 SHELL_VAR
**varlist
;
3637 int vind
, rind
, plen
;
3639 plen
= STRLEN (prefix
);
3640 varlist
= all_visible_variables ();
3641 for (vind
= 0; varlist
&& varlist
[vind
]; vind
++)
3643 if (varlist
== 0 || vind
== 0)
3644 return ((char **)NULL
);
3645 rlist
= strvec_create (vind
+ 1);
3646 for (vind
= rind
= 0; varlist
[vind
]; vind
++)
3648 if (plen
== 0 || STREQN (prefix
, varlist
[vind
]->name
, plen
))
3649 rlist
[rind
++] = savestring (varlist
[vind
]->name
);
3651 rlist
[rind
] = (char *)0;
3657 /* **************************************************************** */
3659 /* Managing temporary variable scopes */
3661 /* **************************************************************** */
3663 /* Make variable NAME have VALUE in the temporary environment. */
3665 bind_tempenv_variable (name
, value
)
3671 var
= temporary_env
? hash_lookup (name
, temporary_env
) : (SHELL_VAR
*)NULL
;
3675 FREE (value_cell (var
));
3676 var_setvalue (var
, savestring (value
));
3677 INVALIDATE_EXPORTSTR (var
);
3683 /* Find a variable in the temporary environment that is named NAME.
3684 Return the SHELL_VAR *, or NULL if not found. */
3686 find_tempenv_variable (name
)
3689 return (temporary_env
? hash_lookup (name
, temporary_env
) : (SHELL_VAR
*)NULL
);
3692 char **tempvar_list
;
3695 /* Push the variable described by (SHELL_VAR *)DATA down to the next
3696 variable context from the temporary environment. */
3698 push_temp_var (data
)
3702 HASH_TABLE
*binding_table
;
3704 var
= (SHELL_VAR
*)data
;
3706 binding_table
= shell_variables
->table
;
3707 if (binding_table
== 0)
3709 if (shell_variables
== global_variables
)
3710 /* shouldn't happen */
3711 binding_table
= shell_variables
->table
= global_variables
->table
= hash_create (0);
3713 binding_table
= shell_variables
->table
= hash_create (TEMPENV_HASH_BUCKETS
);
3716 v
= bind_variable_internal (var
->name
, value_cell (var
), binding_table
, 0, 0);
3718 /* XXX - should we set the context here? It shouldn't matter because of how
3719 assign_in_env works, but might want to check. */
3720 if (binding_table
== global_variables
->table
) /* XXX */
3721 var
->attributes
&= ~(att_tempvar
|att_propagate
);
3724 var
->attributes
|= att_propagate
;
3725 if (binding_table
== shell_variables
->table
)
3726 shell_variables
->flags
|= VC_HASTMPVAR
;
3728 v
->attributes
|= var
->attributes
;
3730 if (find_special_var (var
->name
) >= 0)
3731 tempvar_list
[tvlist_ind
++] = savestring (var
->name
);
3733 dispose_variable (var
);
3737 propagate_temp_var (data
)
3742 var
= (SHELL_VAR
*)data
;
3743 if (tempvar_p (var
) && (var
->attributes
& att_propagate
))
3744 push_temp_var (data
);
3747 if (find_special_var (var
->name
) >= 0)
3748 tempvar_list
[tvlist_ind
++] = savestring (var
->name
);
3749 dispose_variable (var
);
3753 /* Free the storage used in the hash table for temporary
3754 environment variables. PUSHF is a function to be called
3755 to free each hash table entry. It takes care of pushing variables
3756 to previous scopes if appropriate. PUSHF stores names of variables
3757 that require special handling (e.g., IFS) on tempvar_list, so this
3758 function can call stupidly_hack_special_variables on all the
3759 variables in the list when the temporary hash table is destroyed. */
3761 dispose_temporary_env (pushf
)
3762 sh_free_func_t
*pushf
;
3766 tempvar_list
= strvec_create (HASH_ENTRIES (temporary_env
) + 1);
3767 tempvar_list
[tvlist_ind
= 0] = 0;
3769 hash_flush (temporary_env
, pushf
);
3770 hash_dispose (temporary_env
);
3771 temporary_env
= (HASH_TABLE
*)NULL
;
3773 tempvar_list
[tvlist_ind
] = 0;
3775 array_needs_making
= 1;
3778 sv_ifs ("IFS"); /* XXX here for now -- check setifs in assign_in_env */
3780 for (i
= 0; i
< tvlist_ind
; i
++)
3781 stupidly_hack_special_variables (tempvar_list
[i
]);
3783 strvec_dispose (tempvar_list
);
3789 dispose_used_env_vars ()
3793 dispose_temporary_env (propagate_temp_var
);
3794 maybe_make_export_env ();
3798 /* Take all of the shell variables in the temporary environment HASH_TABLE
3799 and make shell variables from them at the current variable context. */
3801 merge_temporary_env ()
3804 dispose_temporary_env (push_temp_var
);
3807 /* **************************************************************** */
3809 /* Creating and manipulating the environment */
3811 /* **************************************************************** */
3813 static inline char *
3814 mk_env_string (name
, value
)
3815 const char *name
, *value
;
3817 int name_len
, value_len
;
3820 name_len
= strlen (name
);
3821 value_len
= STRLEN (value
);
3822 p
= (char *)xmalloc (2 + name_len
+ value_len
);
3825 if (value
&& *value
)
3826 strcpy (p
+ name_len
+ 1, value
);
3828 p
[name_len
+ 1] = '\0';
3843 internal_error (_("%s has null exportstr"), v
->name
);
3846 if (legal_variable_starter ((unsigned char)*s
) == 0)
3848 internal_error (_("invalid character %d in exportstr for %s"), *s
, v
->name
);
3851 for (s
= v
->exportstr
+ 1; s
&& *s
; s
++)
3855 if (legal_variable_char ((unsigned char)*s
) == 0)
3857 internal_error (_("invalid character %d in exportstr for %s"), *s
, v
->name
);
3863 internal_error (_("no `=' in exportstr for %s"), v
->name
);
3871 make_env_array_from_var_list (vars
)
3874 register int i
, list_index
;
3875 register SHELL_VAR
*var
;
3876 char **list
, *value
;
3878 list
= strvec_create ((1 + strvec_len ((char **)vars
)));
3880 #define USE_EXPORTSTR (value == var->exportstr)
3882 for (i
= 0, list_index
= 0; var
= vars
[i
]; i
++)
3884 #if defined (__CYGWIN__)
3885 /* We don't use the exportstr stuff on Cygwin at all. */
3886 INVALIDATE_EXPORTSTR (var
);
3889 value
= var
->exportstr
;
3890 else if (function_p (var
))
3891 value
= named_function_string ((char *)NULL
, function_cell (var
), 0);
3892 #if defined (ARRAY_VARS)
3893 else if (array_p (var
))
3895 value
= array_to_assignment_string (array_cell (var
));
3897 continue; /* XXX array vars cannot yet be exported */
3898 # endif /* ARRAY_EXPORT */
3899 else if (assoc_p (var
))
3901 value
= assoc_to_assignment_string (assoc_cell (var
));
3903 continue; /* XXX associative array vars cannot yet be exported */
3907 value
= value_cell (var
);
3911 /* Gee, I'd like to get away with not using savestring() if we're
3912 using the cached exportstr... */
3913 list
[list_index
] = USE_EXPORTSTR
? savestring (value
)
3914 : mk_env_string (var
->name
, value
);
3916 if (USE_EXPORTSTR
== 0)
3917 SAVE_EXPORTSTR (var
, list
[list_index
]);
3920 #undef USE_EXPORTSTR
3923 #if defined (ARRAY_VARS)
3924 if (array_p (var
) || assoc_p (var
))
3931 list
[list_index
] = (char *)NULL
;
3935 /* Make an array of assignment statements from the hash table
3936 HASHED_VARS which contains SHELL_VARs. Only visible, exported
3937 variables are eligible. */
3939 make_var_export_array (vcxt
)
3946 vars
= map_over (visible_and_exported
, vcxt
);
3948 vars
= map_over (export_environment_candidate
, vcxt
);
3952 return (char **)NULL
;
3954 list
= make_env_array_from_var_list (vars
);
3961 make_func_export_array ()
3966 vars
= map_over_funcs (visible_and_exported
);
3968 return (char **)NULL
;
3970 list
= make_env_array_from_var_list (vars
);
3976 /* Add ENVSTR to the end of the exported environment, EXPORT_ENV. */
3977 #define add_to_export_env(envstr,do_alloc) \
3980 if (export_env_index >= (export_env_size - 1)) \
3982 export_env_size += 16; \
3983 export_env = strvec_resize (export_env, export_env_size); \
3984 environ = export_env; \
3986 export_env[export_env_index++] = (do_alloc) ? savestring (envstr) : envstr; \
3987 export_env[export_env_index] = (char *)NULL; \
3990 /* Add ASSIGN to EXPORT_ENV, or supercede a previous assignment in the
3991 array with the same left-hand side. Return the new EXPORT_ENV. */
3993 add_or_supercede_exported_var (assign
, do_alloc
)
4000 equal_offset
= assignment (assign
, 0);
4001 if (equal_offset
== 0)
4002 return (export_env
);
4004 /* If this is a function, then only supersede the function definition.
4005 We do this by including the `=() {' in the comparison, like
4006 initialize_shell_variables does. */
4007 if (assign
[equal_offset
+ 1] == '(' &&
4008 strncmp (assign
+ equal_offset
+ 2, ") {", 3) == 0) /* } */
4011 for (i
= 0; i
< export_env_index
; i
++)
4013 if (STREQN (assign
, export_env
[i
], equal_offset
+ 1))
4015 free (export_env
[i
]);
4016 export_env
[i
] = do_alloc
? savestring (assign
) : assign
;
4017 return (export_env
);
4020 add_to_export_env (assign
, do_alloc
);
4021 return (export_env
);
4025 add_temp_array_to_env (temp_array
, do_alloc
, do_supercede
)
4027 int do_alloc
, do_supercede
;
4031 if (temp_array
== 0)
4034 for (i
= 0; temp_array
[i
]; i
++)
4037 export_env
= add_or_supercede_exported_var (temp_array
[i
], do_alloc
);
4039 add_to_export_env (temp_array
[i
], do_alloc
);
4045 /* Make the environment array for the command about to be executed, if the
4046 array needs making. Otherwise, do nothing. If a shell action could
4047 change the array that commands receive for their environment, then the
4048 code should `array_needs_making++'.
4050 The order to add to the array is:
4052 list of var contexts whose head is shell_variables
4055 This is the shell variable lookup order. We add only new variable
4056 names at each step, which allows local variables and variables in
4057 the temporary environments to shadow variables in the global (or
4058 any previous) scope.
4062 n_shell_variables ()
4067 for (n
= 0, vc
= shell_variables
; vc
; vc
= vc
->down
)
4068 n
+= HASH_ENTRIES (vc
->table
);
4078 v
= find_variable (name
);
4079 if (v
&& exported_p (v
))
4081 array_needs_making
= 1;
4082 maybe_make_export_env ();
4089 maybe_make_export_env ()
4091 register char **temp_array
;
4095 if (array_needs_making
)
4098 strvec_flush (export_env
);
4100 /* Make a guess based on how many shell variables and functions we
4101 have. Since there will always be array variables, and array
4102 variables are not (yet) exported, this will always be big enough
4103 for the exported variables and functions. */
4104 new_size
= n_shell_variables () + HASH_ENTRIES (shell_functions
) + 1 +
4105 HASH_ENTRIES (temporary_env
);
4106 if (new_size
> export_env_size
)
4108 export_env_size
= new_size
;
4109 export_env
= strvec_resize (export_env
, export_env_size
);
4110 environ
= export_env
;
4112 export_env
[export_env_index
= 0] = (char *)NULL
;
4114 /* Make a dummy variable context from the temporary_env, stick it on
4115 the front of shell_variables, call make_var_export_array on the
4116 whole thing to flatten it, and convert the list of SHELL_VAR *s
4117 to the form needed by the environment. */
4120 tcxt
= new_var_context ((char *)NULL
, 0);
4121 tcxt
->table
= temporary_env
;
4122 tcxt
->down
= shell_variables
;
4125 tcxt
= shell_variables
;
4127 temp_array
= make_var_export_array (tcxt
);
4129 add_temp_array_to_env (temp_array
, 0, 0);
4131 if (tcxt
!= shell_variables
)
4134 #if defined (RESTRICTED_SHELL)
4135 /* Restricted shells may not export shell functions. */
4136 temp_array
= restricted
? (char **)0 : make_func_export_array ();
4138 temp_array
= make_func_export_array ();
4141 add_temp_array_to_env (temp_array
, 0, 0);
4143 array_needs_making
= 0;
4147 /* This is an efficiency hack. PWD and OLDPWD are auto-exported, so
4148 we will need to remake the exported environment every time we
4149 change directories. `_' is always put into the environment for
4150 every external command, so without special treatment it will always
4151 cause the environment to be remade.
4153 If there is no other reason to make the exported environment, we can
4154 just update the variables in place and mark the exported environment
4155 as no longer needing a remake. */
4157 update_export_env_inplace (env_prefix
, preflen
, value
)
4164 evar
= (char *)xmalloc (STRLEN (value
) + preflen
+ 1);
4165 strcpy (evar
, env_prefix
);
4167 strcpy (evar
+ preflen
, value
);
4168 export_env
= add_or_supercede_exported_var (evar
, 0);
4171 /* We always put _ in the environment as the name of this command. */
4173 put_command_name_into_env (command_name
)
4176 update_export_env_inplace ("_=", 2, command_name
);
4179 /* **************************************************************** */
4181 /* Managing variable contexts */
4183 /* **************************************************************** */
4185 /* Allocate and return a new variable context with NAME and FLAGS.
4186 NAME can be NULL. */
4189 new_var_context (name
, flags
)
4195 vc
= (VAR_CONTEXT
*)xmalloc (sizeof (VAR_CONTEXT
));
4196 vc
->name
= name
? savestring (name
) : (char *)NULL
;
4197 vc
->scope
= variable_context
;
4200 vc
->up
= vc
->down
= (VAR_CONTEXT
*)NULL
;
4201 vc
->table
= (HASH_TABLE
*)NULL
;
4206 /* Free a variable context and its data, including the hash table. Dispose
4207 all of the variables. */
4209 dispose_var_context (vc
)
4216 delete_all_variables (vc
->table
);
4217 hash_dispose (vc
->table
);
4223 /* Set VAR's scope level to the current variable context. */
4228 return (var
->context
= variable_context
);
4231 /* Make a new variable context with NAME and FLAGS and a HASH_TABLE of
4232 temporary variables, and push it onto shell_variables. This is
4233 for shell functions. */
4235 push_var_context (name
, flags
, tempvars
)
4238 HASH_TABLE
*tempvars
;
4242 vc
= new_var_context (name
, flags
);
4243 vc
->table
= tempvars
;
4246 /* Have to do this because the temp environment was created before
4247 variable_context was incremented. */
4248 flatten (tempvars
, set_context
, (VARLIST
*)NULL
, 0);
4249 vc
->flags
|= VC_HASTMPVAR
;
4251 vc
->down
= shell_variables
;
4252 shell_variables
->up
= vc
;
4254 return (shell_variables
= vc
);
4258 push_func_var (data
)
4263 var
= (SHELL_VAR
*)data
;
4265 if (tempvar_p (var
) && (posixly_correct
|| (var
->attributes
& att_propagate
)))
4267 /* Make sure we have a hash table to store the variable in while it is
4268 being propagated down to the global variables table. Create one if
4270 if ((vc_isfuncenv (shell_variables
) || vc_istempenv (shell_variables
)) && shell_variables
->table
== 0)
4271 shell_variables
->table
= hash_create (0);
4272 /* XXX - should we set v->context here? */
4273 v
= bind_variable_internal (var
->name
, value_cell (var
), shell_variables
->table
, 0, 0);
4274 if (shell_variables
== global_variables
)
4275 var
->attributes
&= ~(att_tempvar
|att_propagate
);
4277 shell_variables
->flags
|= VC_HASTMPVAR
;
4278 v
->attributes
|= var
->attributes
;
4281 stupidly_hack_special_variables (var
->name
); /* XXX */
4283 dispose_variable (var
);
4286 /* Pop the top context off of VCXT and dispose of it, returning the rest of
4291 VAR_CONTEXT
*ret
, *vcxt
;
4293 vcxt
= shell_variables
;
4294 if (vc_isfuncenv (vcxt
) == 0)
4296 internal_error (_("pop_var_context: head of shell_variables not a function context"));
4300 if (ret
= vcxt
->down
)
4302 ret
->up
= (VAR_CONTEXT
*)NULL
;
4303 shell_variables
= ret
;
4305 hash_flush (vcxt
->table
, push_func_var
);
4306 dispose_var_context (vcxt
);
4309 internal_error (_("pop_var_context: no global_variables context"));
4312 /* Delete the HASH_TABLEs for all variable contexts beginning at VCXT, and
4313 all of the VAR_CONTEXTs except GLOBAL_VARIABLES. */
4315 delete_all_contexts (vcxt
)
4320 for (v
= vcxt
; v
!= global_variables
; v
= t
)
4323 dispose_var_context (v
);
4326 delete_all_variables (global_variables
->table
);
4327 shell_variables
= global_variables
;
4330 /* **************************************************************** */
4332 /* Pushing and Popping temporary variable scopes */
4334 /* **************************************************************** */
4337 push_scope (flags
, tmpvars
)
4339 HASH_TABLE
*tmpvars
;
4341 return (push_var_context ((char *)NULL
, flags
, tmpvars
));
4345 push_exported_var (data
)
4350 var
= (SHELL_VAR
*)data
;
4352 /* If a temp var had its export attribute set, or it's marked to be
4353 propagated, bind it in the previous scope before disposing it. */
4354 /* XXX - This isn't exactly right, because all tempenv variables have the
4355 export attribute set. */
4357 if (exported_p (var
) || (var
->attributes
& att_propagate
))
4359 if (tempvar_p (var
) && exported_p (var
) && (var
->attributes
& att_propagate
))
4362 var
->attributes
&= ~att_tempvar
; /* XXX */
4363 v
= bind_variable_internal (var
->name
, value_cell (var
), shell_variables
->table
, 0, 0);
4364 if (shell_variables
== global_variables
)
4365 var
->attributes
&= ~att_propagate
;
4366 v
->attributes
|= var
->attributes
;
4369 stupidly_hack_special_variables (var
->name
); /* XXX */
4371 dispose_variable (var
);
4375 pop_scope (is_special
)
4378 VAR_CONTEXT
*vcxt
, *ret
;
4380 vcxt
= shell_variables
;
4381 if (vc_istempscope (vcxt
) == 0)
4383 internal_error (_("pop_scope: head of shell_variables not a temporary environment scope"));
4389 ret
->up
= (VAR_CONTEXT
*)NULL
;
4391 shell_variables
= ret
;
4393 /* Now we can take care of merging variables in VCXT into set of scopes
4394 whose head is RET (shell_variables). */
4399 hash_flush (vcxt
->table
, push_func_var
);
4401 hash_flush (vcxt
->table
, push_exported_var
);
4402 hash_dispose (vcxt
->table
);
4406 sv_ifs ("IFS"); /* XXX here for now */
4409 /* **************************************************************** */
4411 /* Pushing and Popping function contexts */
4413 /* **************************************************************** */
4415 static WORD_LIST
**dollar_arg_stack
= (WORD_LIST
**)NULL
;
4416 static int dollar_arg_stack_slots
;
4417 static int dollar_arg_stack_index
;
4419 /* XXX - we might want to consider pushing and popping the `getopts' state
4420 when we modify the positional parameters. */
4422 push_context (name
, is_subshell
, tempvars
)
4423 char *name
; /* function name */
4425 HASH_TABLE
*tempvars
;
4427 if (is_subshell
== 0)
4428 push_dollar_vars ();
4430 push_var_context (name
, VC_FUNCENV
, tempvars
);
4433 /* Only called when subshell == 0, so we don't need to check, and can
4434 unconditionally pop the dollar vars off the stack. */
4442 sv_ifs ("IFS"); /* XXX here for now */
4445 /* Save the existing positional parameters on a stack. */
4449 if (dollar_arg_stack_index
+ 2 > dollar_arg_stack_slots
)
4451 dollar_arg_stack
= (WORD_LIST
**)
4452 xrealloc (dollar_arg_stack
, (dollar_arg_stack_slots
+= 10)
4453 * sizeof (WORD_LIST
*));
4455 dollar_arg_stack
[dollar_arg_stack_index
++] = list_rest_of_args ();
4456 dollar_arg_stack
[dollar_arg_stack_index
] = (WORD_LIST
*)NULL
;
4459 /* Restore the positional parameters from our stack. */
4463 if (!dollar_arg_stack
|| dollar_arg_stack_index
== 0)
4466 remember_args (dollar_arg_stack
[--dollar_arg_stack_index
], 1);
4467 dispose_words (dollar_arg_stack
[dollar_arg_stack_index
]);
4468 dollar_arg_stack
[dollar_arg_stack_index
] = (WORD_LIST
*)NULL
;
4469 set_dollar_vars_unchanged ();
4473 dispose_saved_dollar_vars ()
4475 if (!dollar_arg_stack
|| dollar_arg_stack_index
== 0)
4478 dispose_words (dollar_arg_stack
[dollar_arg_stack_index
]);
4479 dollar_arg_stack
[dollar_arg_stack_index
] = (WORD_LIST
*)NULL
;
4482 /* Manipulate the special BASH_ARGV and BASH_ARGC variables. */
4488 #if defined (ARRAY_VARS) && defined (DEBUGGER)
4489 SHELL_VAR
*bash_argv_v
, *bash_argc_v
;
4490 ARRAY
*bash_argv_a
, *bash_argc_a
;
4495 GET_ARRAY_FROM_VAR ("BASH_ARGV", bash_argv_v
, bash_argv_a
);
4496 GET_ARRAY_FROM_VAR ("BASH_ARGC", bash_argc_v
, bash_argc_a
);
4498 for (l
= list
, i
= 0; l
; l
= l
->next
, i
++)
4499 array_push (bash_argv_a
, l
->word
->word
);
4502 array_push (bash_argc_a
, t
);
4504 #endif /* ARRAY_VARS && DEBUGGER */
4507 /* Remove arguments from BASH_ARGV array. Pop top element off BASH_ARGC
4508 array and use that value as the count of elements to remove from
4513 #if defined (ARRAY_VARS) && defined (DEBUGGER)
4514 SHELL_VAR
*bash_argv_v
, *bash_argc_v
;
4515 ARRAY
*bash_argv_a
, *bash_argc_a
;
4519 GET_ARRAY_FROM_VAR ("BASH_ARGV", bash_argv_v
, bash_argv_a
);
4520 GET_ARRAY_FROM_VAR ("BASH_ARGC", bash_argc_v
, bash_argc_a
);
4522 ce
= array_shift (bash_argc_a
, 1, 0);
4523 if (ce
== 0 || legal_number (element_value (ce
), &i
) == 0)
4527 array_pop (bash_argv_a
);
4528 array_dispose_element (ce
);
4529 #endif /* ARRAY_VARS && DEBUGGER */
4532 /*************************************************
4534 * Functions to manage special variables *
4536 *************************************************/
4538 /* Extern declarations for variables this code has to manage. */
4539 extern int eof_encountered
, eof_encountered_limit
, ignoreeof
;
4541 #if defined (READLINE)
4542 extern int hostname_list_initialized
;
4545 /* An alist of name.function for each special variable. Most of the
4546 functions don't do much, and in fact, this would be faster with a
4547 switch statement, but by the end of this file, I am sick of switch
4550 #define SET_INT_VAR(name, intvar) intvar = find_variable (name) != 0
4552 /* This table will be sorted with qsort() the first time it's accessed. */
4553 struct name_and_function
{
4555 sh_sv_func_t
*function
;
4558 static struct name_and_function special_vars
[] = {
4559 { "BASH_COMPAT", sv_shcompat
},
4560 { "BASH_XTRACEFD", sv_xtracefd
},
4562 #if defined (JOB_CONTROL)
4563 { "CHILD_MAX", sv_childmax
},
4566 #if defined (READLINE)
4567 # if defined (STRICT_POSIX)
4568 { "COLUMNS", sv_winsize
},
4570 { "COMP_WORDBREAKS", sv_comp_wordbreaks
},
4573 { "FUNCNEST", sv_funcnest
},
4575 { "GLOBIGNORE", sv_globignore
},
4577 #if defined (HISTORY)
4578 { "HISTCONTROL", sv_history_control
},
4579 { "HISTFILESIZE", sv_histsize
},
4580 { "HISTIGNORE", sv_histignore
},
4581 { "HISTSIZE", sv_histsize
},
4582 { "HISTTIMEFORMAT", sv_histtimefmt
},
4585 #if defined (__CYGWIN__)
4586 { "HOME", sv_home
},
4589 #if defined (READLINE)
4590 { "HOSTFILE", sv_hostfile
},
4594 { "IGNOREEOF", sv_ignoreeof
},
4596 { "LANG", sv_locale
},
4597 { "LC_ALL", sv_locale
},
4598 { "LC_COLLATE", sv_locale
},
4599 { "LC_CTYPE", sv_locale
},
4600 { "LC_MESSAGES", sv_locale
},
4601 { "LC_NUMERIC", sv_locale
},
4602 { "LC_TIME", sv_locale
},
4604 #if defined (READLINE) && defined (STRICT_POSIX)
4605 { "LINES", sv_winsize
},
4608 { "MAIL", sv_mail
},
4609 { "MAILCHECK", sv_mail
},
4610 { "MAILPATH", sv_mail
},
4612 { "OPTERR", sv_opterr
},
4613 { "OPTIND", sv_optind
},
4615 { "PATH", sv_path
},
4616 { "POSIXLY_CORRECT", sv_strict_posix
},
4618 #if defined (READLINE)
4619 { "TERM", sv_terminal
},
4620 { "TERMCAP", sv_terminal
},
4621 { "TERMINFO", sv_terminal
},
4622 #endif /* READLINE */
4624 { "TEXTDOMAIN", sv_locale
},
4625 { "TEXTDOMAINDIR", sv_locale
},
4627 #if defined (HAVE_TZSET)
4631 #if defined (HISTORY) && defined (BANG_HISTORY)
4632 { "histchars", sv_histchars
},
4633 #endif /* HISTORY && BANG_HISTORY */
4635 { "ignoreeof", sv_ignoreeof
},
4637 { (char *)0, (sh_sv_func_t
*)0 }
4640 #define N_SPECIAL_VARS (sizeof (special_vars) / sizeof (special_vars[0]) - 1)
4643 sv_compare (sv1
, sv2
)
4644 struct name_and_function
*sv1
, *sv2
;
4648 if ((r
= sv1
->name
[0] - sv2
->name
[0]) == 0)
4649 r
= strcmp (sv1
->name
, sv2
->name
);
4654 find_special_var (name
)
4659 for (i
= 0; special_vars
[i
].name
; i
++)
4661 r
= special_vars
[i
].name
[0] - name
[0];
4663 r
= strcmp (special_vars
[i
].name
, name
);
4667 /* Can't match any of rest of elements in sorted list. Take this out
4668 if it causes problems in certain environments. */
4674 /* The variable in NAME has just had its state changed. Check to see if it
4675 is one of the special ones where something special happens. */
4677 stupidly_hack_special_variables (name
)
4680 static int sv_sorted
= 0;
4683 if (sv_sorted
== 0) /* shouldn't need, but it's fairly cheap. */
4685 qsort (special_vars
, N_SPECIAL_VARS
, sizeof (special_vars
[0]),
4686 (QSFUNC
*)sv_compare
);
4690 i
= find_special_var (name
);
4692 (*(special_vars
[i
].function
)) (name
);
4695 /* Special variables that need hooks to be run when they are unset as part
4696 of shell reinitialization should have their sv_ functions run here. */
4698 reinit_special_variables ()
4700 #if defined (READLINE)
4701 sv_comp_wordbreaks ("COMP_WORDBREAKS");
4703 sv_globignore ("GLOBIGNORE");
4704 sv_opterr ("OPTERR");
4713 v
= find_variable ("IFS");
4717 /* What to do just after the PATH variable has changed. */
4726 /* What to do just after one of the MAILxxxx variables has changed. NAME
4727 is the name of the variable. This is called with NAME set to one of
4728 MAIL, MAILCHECK, or MAILPATH. */
4733 /* If the time interval for checking the files has changed, then
4734 reset the mail timer. Otherwise, one of the pathname vars
4735 to the users mailbox has changed, so rebuild the array of
4737 if (name
[4] == 'C') /* if (strcmp (name, "MAILCHECK") == 0) */
4738 reset_mail_timer ();
4742 remember_mail_dates ();
4753 v
= find_variable (name
);
4756 else if (legal_number (value_cell (v
), &num
) == 0)
4762 /* What to do when GLOBIGNORE changes. */
4764 sv_globignore (name
)
4767 if (privileged_mode
== 0)
4768 setup_glob_ignore (name
);
4771 #if defined (READLINE)
4773 sv_comp_wordbreaks (name
)
4778 sv
= find_variable (name
);
4780 reset_completer_word_break_chars ();
4783 /* What to do just after one of the TERMxxx variables has changed.
4784 If we are an interactive shell, then try to reset the terminal
4785 information in readline. */
4790 if (interactive_shell
&& no_line_editing
== 0)
4791 rl_reset_terminal (get_string_value ("TERM"));
4800 v
= find_variable (name
);
4802 clear_hostname_list ();
4804 hostname_list_initialized
= 0;
4807 #if defined (STRICT_POSIX)
4808 /* In strict posix mode, we allow assignments to LINES and COLUMNS (and values
4809 found in the initial environment) to override the terminal size reported by
4819 if (posixly_correct
== 0 || interactive_shell
== 0 || no_line_editing
)
4822 v
= find_variable (name
);
4823 if (v
== 0 || var_isnull (v
))
4824 rl_reset_screen_size ();
4827 if (legal_number (value_cell (v
), &xd
) == 0)
4829 winsize_assignment
= 1;
4830 d
= xd
; /* truncate */
4831 if (name
[0] == 'L') /* LINES */
4832 rl_set_screen_size (d
, -1);
4834 rl_set_screen_size (-1, d
);
4835 winsize_assignment
= 0;
4838 #endif /* STRICT_POSIX */
4839 #endif /* READLINE */
4841 /* Update the value of HOME in the export environment so tilde expansion will
4843 #if defined (__CYGWIN__)
4847 array_needs_making
= 1;
4848 maybe_make_export_env ();
4852 #if defined (HISTORY)
4853 /* What to do after the HISTSIZE or HISTFILESIZE variables change.
4854 If there is a value for this HISTSIZE (and it is numeric), then stifle
4855 the history. Otherwise, if there is NO value for this variable,
4856 unstifle the history. If name is HISTFILESIZE, and its value is
4857 numeric, truncate the history file to hold no more than that many
4867 temp
= get_string_value (name
);
4871 if (legal_number (temp
, &num
))
4874 if (hmax
< 0 && name
[4] == 'S')
4875 unstifle_history (); /* unstifle history if HISTSIZE < 0 */
4876 else if (name
[4] == 'S')
4878 stifle_history (hmax
);
4879 hmax
= where_history ();
4880 if (history_lines_this_session
> hmax
)
4881 history_lines_this_session
= hmax
;
4883 else if (hmax
>= 0) /* truncate HISTFILE if HISTFILESIZE >= 0 */
4885 history_truncate_file (get_string_value ("HISTFILE"), hmax
);
4886 if (hmax
<= history_lines_in_file
)
4887 history_lines_in_file
= hmax
;
4891 else if (name
[4] == 'S')
4892 unstifle_history ();
4895 /* What to do after the HISTIGNORE variable changes. */
4897 sv_histignore (name
)
4900 setup_history_ignore (name
);
4903 /* What to do after the HISTCONTROL variable changes. */
4905 sv_history_control (name
)
4912 history_control
= 0;
4913 temp
= get_string_value (name
);
4915 if (temp
== 0 || *temp
== 0)
4919 while (val
= extract_colon_unit (temp
, &tptr
))
4921 if (STREQ (val
, "ignorespace"))
4922 history_control
|= HC_IGNSPACE
;
4923 else if (STREQ (val
, "ignoredups"))
4924 history_control
|= HC_IGNDUPS
;
4925 else if (STREQ (val
, "ignoreboth"))
4926 history_control
|= HC_IGNBOTH
;
4927 else if (STREQ (val
, "erasedups"))
4928 history_control
|= HC_ERASEDUPS
;
4934 #if defined (BANG_HISTORY)
4935 /* Setting/unsetting of the history expansion character. */
4942 temp
= get_string_value (name
);
4945 history_expansion_char
= *temp
;
4946 if (temp
[0] && temp
[1])
4948 history_subst_char
= temp
[1];
4950 history_comment_char
= temp
[2];
4955 history_expansion_char
= '!';
4956 history_subst_char
= '^';
4957 history_comment_char
= '#';
4960 #endif /* BANG_HISTORY */
4963 sv_histtimefmt (name
)
4968 if (v
= find_variable (name
))
4970 if (history_comment_char
== 0)
4971 history_comment_char
= '#';
4973 history_write_timestamps
= (v
!= 0);
4975 #endif /* HISTORY */
4977 #if defined (HAVE_TZSET)
4982 if (chkexport (name
))
4987 /* If the variable exists, then the value of it can be the number
4988 of times we actually ignore the EOF. The default is small,
4989 (smaller than csh, anyway). */
4997 eof_encountered
= 0;
4999 tmp_var
= find_variable (name
);
5000 ignoreeof
= tmp_var
!= 0;
5001 temp
= tmp_var
? value_cell (tmp_var
) : (char *)NULL
;
5003 eof_encountered_limit
= (*temp
&& all_digits (temp
)) ? atoi (temp
) : 10;
5004 set_shellopts (); /* make sure `ignoreeof' is/is not in $SHELLOPTS */
5014 tt
= get_string_value ("OPTIND");
5019 /* According to POSIX, setting OPTIND=1 resets the internal state
5021 if (s
< 0 || s
== 1)
5035 tt
= get_string_value ("OPTERR");
5036 sh_opterr
= (tt
&& *tt
) ? atoi (tt
) : 1;
5040 sv_strict_posix (name
)
5043 SET_INT_VAR (name
, posixly_correct
);
5044 posix_initialize (posixly_correct
);
5045 #if defined (READLINE)
5046 if (interactive_shell
)
5047 posix_readline_initialize (posixly_correct
);
5048 #endif /* READLINE */
5049 set_shellopts (); /* make sure `posix' is/is not in $SHELLOPTS */
5059 v
= get_string_value (name
);
5060 if (name
[0] == 'L' && name
[1] == 'A') /* LANG */
5061 r
= set_lang (name
, v
);
5063 r
= set_locale_var (name
, v
); /* LC_*, TEXTDOMAIN* */
5066 if (r
== 0 && posixly_correct
)
5067 last_command_exit_value
= 1;
5071 #if defined (ARRAY_VARS)
5073 set_pipestatus_array (ps
, nproc
)
5081 char *t
, tbuf
[INT_STRLEN_BOUND(int) + 1];
5083 v
= find_variable ("PIPESTATUS");
5085 v
= make_new_array_variable ("PIPESTATUS");
5086 if (array_p (v
) == 0)
5087 return; /* Do nothing if not an array variable. */
5090 if (a
== 0 || array_num_elements (a
) == 0)
5092 for (i
= 0; i
< nproc
; i
++) /* was ps[i] != -1, not i < nproc */
5094 t
= inttostr (ps
[i
], tbuf
, sizeof (tbuf
));
5095 array_insert (a
, i
, t
);
5101 if (array_num_elements (a
) == nproc
&& nproc
== 1)
5103 ae
= element_forw (a
->head
);
5104 free (element_value (ae
));
5105 ae
->value
= itos (ps
[0]);
5107 else if (array_num_elements (a
) <= nproc
)
5109 /* modify in array_num_elements members in place, then add */
5111 for (i
= 0; i
< array_num_elements (a
); i
++)
5113 ae
= element_forw (ae
);
5114 free (element_value (ae
));
5115 ae
->value
= itos (ps
[i
]);
5118 for ( ; i
< nproc
; i
++)
5120 t
= inttostr (ps
[i
], tbuf
, sizeof (tbuf
));
5121 array_insert (a
, i
, t
);
5126 /* deleting elements. it's faster to rebuild the array. */
5128 for (i
= 0; ps
[i
] != -1; i
++)
5130 t
= inttostr (ps
[i
], tbuf
, sizeof (tbuf
));
5131 array_insert (a
, i
, t
);
5137 save_pipestatus_array ()
5142 v
= find_variable ("PIPESTATUS");
5143 if (v
== 0 || array_p (v
) == 0 || array_cell (v
) == 0)
5144 return ((ARRAY
*)NULL
);
5147 a2
= array_copy (array_cell (v
));
5153 restore_pipestatus_array (a
)
5159 v
= find_variable ("PIPESTATUS");
5160 /* XXX - should we still assign even if existing value is NULL? */
5161 if (v
== 0 || array_p (v
) == 0 || array_cell (v
) == 0)
5164 a2
= array_cell (v
);
5165 var_setarray (v
, a
);
5172 set_pipestatus_from_exit (s
)
5175 #if defined (ARRAY_VARS)
5176 static int v
[2] = { 0, -1 };
5179 set_pipestatus_array (v
, 1);
5192 v
= find_variable (name
);
5200 if (t
== 0 || *t
== 0)
5204 fd
= (int)strtol (t
, &e
, 10);
5205 if (e
!= t
&& *e
== '\0' && sh_validfd (fd
))
5207 fp
= fdopen (fd
, "w");
5209 internal_error (_("%s: %s: cannot open as FILE"), name
, value_cell (v
));
5211 xtrace_set (fd
, fp
);
5214 internal_error (_("%s: %s: invalid value for trace file descriptor"), name
, value_cell (v
));
5218 #define MIN_COMPAT_LEVEL 31
5226 int tens
, ones
, compatval
;
5228 v
= find_variable (name
);
5231 shell_compatibility_level
= DEFAULT_COMPAT_LEVEL
;
5232 set_compatibility_opts ();
5235 val
= value_cell (v
);
5236 if (val
== 0 || *val
== '\0')
5238 shell_compatibility_level
= DEFAULT_COMPAT_LEVEL
;
5239 set_compatibility_opts ();
5242 /* Handle decimal-like compatibility version specifications: 4.2 */
5243 if (isdigit (val
[0]) && val
[1] == '.' && isdigit (val
[2]) && val
[3] == 0)
5245 tens
= val
[0] - '0';
5246 ones
= val
[2] - '0';
5247 compatval
= tens
*10 + ones
;
5249 /* Handle integer-like compatibility version specifications: 42 */
5250 else if (isdigit (val
[0]) && isdigit (val
[1]) && val
[2] == 0)
5252 tens
= val
[0] - '0';
5253 ones
= val
[1] - '0';
5254 compatval
= tens
*10 + ones
;
5259 internal_error (_("%s: %s: compatibility value out of range"), name
, val
);
5260 shell_compatibility_level
= DEFAULT_COMPAT_LEVEL
;
5261 set_compatibility_opts ();
5265 if (compatval
< MIN_COMPAT_LEVEL
|| compatval
> DEFAULT_COMPAT_LEVEL
)
5268 shell_compatibility_level
= compatval
;
5269 set_compatibility_opts ();
5272 #if defined (JOB_CONTROL)
5280 tt
= get_string_value (name
);
5281 s
= (tt
&& *tt
) ? atoi (tt
) : 0;