#include "config.h"
#include "bashtypes.h"
#include "posixstat.h"
#include "posixtime.h"
#include <stdio.h>
#include "chartypes.h"
#include "bashansi.h"
#include "bashintl.h"
#include "shell.h"
#include "parser.h"
#include "flags.h"
#include "execute_cmd.h"
#include "findcmd.h"
#include "mailcheck.h"
#include "input.h"
#include "hashcmd.h"
#include "pathexp.h"
#include "alias.h"
#include "jobs.h"
#include "version.h"
#include "builtins/getopt.h"
#include "builtins/common.h"
#include "builtins/builtext.h"
#include <tilde/tilde.h>

Data Structures
struct	saved_dollar_vars

struct	name_and_function

Macros
#define	NEED_XTRACE_SET_DECL

#define	VARIABLES_HASH_BUCKETS 1024 /* must be power of two */

#define	FUNCTIONS_HASH_BUCKETS 512

#define	TEMPENV_HASH_BUCKETS 4 /* must be power of two */

#define	BASHFUNC_PREFIX "BASH_FUNC_"

#define	BASHFUNC_PREFLEN 10 /* == strlen(BASHFUNC_PREFIX */

#define	BASHFUNC_SUFFIX "%%"

#define	BASHFUNC_SUFFLEN 2 /* == strlen(BASHFUNC_SUFFIX) */

#define	FV_FORCETEMPENV 0x01

#define	FV_SKIPINVISIBLE 0x02

#define	INIT_DYNAMIC_VAR(var, val, gfunc, afunc)

#define	INIT_DYNAMIC_ARRAY_VAR(var, gfunc, afunc)

#define	INIT_DYNAMIC_ASSOC_VAR(var, gfunc, afunc)

#define	FIND_OR_MAKE_VARIABLE(name, entry)

#define	USE_EXPORTSTR (value == var->exportstr)

#define	add_to_export_env(envstr, do_alloc)

#define	SET_INT_VAR(name, intvar) intvar = find_variable (name) != 0

#define	N_SPECIAL_VARS (sizeof (special_vars) / sizeof (special_vars[0]) - 1)

#define	MIN_COMPAT_LEVEL 31

Functions
static void create_variable_tables	__P ((void))

static SHELL_VAR *null_assign	__P ((SHELL_VAR , char , arrayind_t, char *))

static SHELL_VAR *get_self	__P ((SHELL_VAR *))

static void sbrand	__P ((unsigned long))

static SHELL_VAR *bind_invalid_envvar	__P ((const char , char , int))

static int var_sametype	__P ((SHELL_VAR , SHELL_VAR ))

static SHELL_VAR *hash_lookup	__P ((const char , HASH_TABLE ))

static SHELL_VAR *new_shell_variable	__P ((const char *))

static SHELL_VAR *bind_variable_internal	__P ((const char , char , HASH_TABLE *, int, int))

static void free_variable_hash_data	__P ((char *))

static VARLIST *vlist_alloc	__P ((int))

static VARLIST *vlist_realloc	__P ((VARLIST *, int))

static void vlist_add	__P ((VARLIST , SHELL_VAR , int))

static void flatten	__P ((HASH_TABLE , sh_var_map_func_t , VARLIST *, int))

static int qsort_var_comp	__P ((SHELL_VAR , SHELL_VAR ))

static SHELL_VAR **vapply	__P ((sh_var_map_func_t *))

static SHELL_VAR *find_variable_internal	__P ((const char *, int))

static SHELL_VAR *find_nameref_at_context	__P ((SHELL_VAR , VAR_CONTEXT ))

static SHELL_VAR *find_variable_nameref_context	__P ((SHELL_VAR , VAR_CONTEXT , VAR_CONTEXT **))

static SHELL_VAR *bind_tempenv_variable	__P ((const char , char ))

static void dispose_temporary_env	__P ((sh_free_func_t *))

static char *mk_env_string	__P ((const char , const char , int))

static char **make_env_array_from_var_list	__P ((SHELL_VAR **))

static char **make_var_export_array	__P ((VAR_CONTEXT *))

static void add_temp_array_to_env	__P ((char **, int, int))

static void push_posix_tempvar_internal	__P ((SHELL_VAR *, int))

static void	create_variable_tables ()

void	initialize_shell_variables (char **env, int privmode)

static void	set_machine_vars ()

char *	sh_get_home_dir ()

static void	set_home_var ()

static void	set_shell_var ()

static char *	get_bash_name ()

void	adjust_shell_level (int change)

static void	initialize_shell_level ()

void	set_pwd ()

void	set_ppid ()

static void	uidset ()

void	sh_set_lines_and_columns (int lines, int cols)

void	print_var_list (SHELL_VAR **list)

void	print_func_list (SHELL_VAR **list)

void	print_assignment (SHELL_VAR *var)

void	print_var_value (SHELL_VAR *var, int quote)

void	print_var_function (SHELL_VAR *var)

static SHELL_VAR *	null_assign (SHELL_VAR self, char value, arrayind_t unused, char *key)

static SHELL_VAR *	get_self (SHELL_VAR *self)

static SHELL_VAR *	assign_seconds (SHELL_VAR self, char value, arrayind_t unused, char *key)

static SHELL_VAR *	get_seconds (SHELL_VAR *var)

static SHELL_VAR *	init_seconds_var ()

static int	brand ()

static void	sbrand (unsigned long seed)

static void	seedrand ()

static SHELL_VAR *	assign_random (SHELL_VAR self, char value, arrayind_t unused, char *key)

int	get_random_number ()

static SHELL_VAR *	get_random (SHELL_VAR *var)

static SHELL_VAR *	assign_lineno (SHELL_VAR var, char value, arrayind_t unused, char *key)

static SHELL_VAR *	get_lineno (SHELL_VAR *var)

static SHELL_VAR *	assign_subshell (SHELL_VAR var, char value, arrayind_t unused, char *key)

static SHELL_VAR *	get_subshell (SHELL_VAR *var)

static SHELL_VAR *	get_epochseconds (SHELL_VAR *var)

static SHELL_VAR *	get_epochrealtime (SHELL_VAR *var)

static SHELL_VAR *	get_bashpid (SHELL_VAR *var)

static SHELL_VAR *	get_bash_argv0 (SHELL_VAR *var)

static SHELL_VAR *	assign_bash_argv0 (SHELL_VAR var, char value, arrayind_t unused, char *key)

static SHELL_VAR *	get_bash_command (SHELL_VAR *var)

static SHELL_VAR *	get_funcname (SHELL_VAR *self)

void	make_funcname_visible (int on_or_off)

static SHELL_VAR *	init_funcname_var ()

static void	initialize_dynamic_variables ()

static SHELL_VAR *	hash_lookup (char name, HASH_TABLE hashed_vars) const

SHELL_VAR *	var_lookup (char name, VAR_CONTEXT vcontext) const

SHELL_VAR *	find_variable_internal (char *name, int flags) const

SHELL_VAR *	find_variable_nameref (SHELL_VAR *v)

SHELL_VAR *	find_variable_last_nameref (char *name, int vflags) const

SHELL_VAR *	find_global_variable_last_nameref (char *name, int vflags) const

static SHELL_VAR *	find_nameref_at_context (SHELL_VAR v, VAR_CONTEXT vc)

static SHELL_VAR *	find_variable_nameref_context (SHELL_VAR v, VAR_CONTEXT vc, VAR_CONTEXT **nvcp)

static SHELL_VAR *	find_variable_last_nameref_context (SHELL_VAR v, VAR_CONTEXT vc, VAR_CONTEXT **nvcp)

SHELL_VAR *	find_variable_nameref_for_create (char *name, int flags) const

SHELL_VAR *	find_variable_nameref_for_assignment (char *name, int flags) const

char *	nameref_transform_name (char *name, int flags)

SHELL_VAR *	find_variable_tempenv (char *name) const

SHELL_VAR *	find_variable_notempenv (char *name) const

SHELL_VAR *	find_global_variable (char *name) const

SHELL_VAR *	find_global_variable_noref (char *name) const

SHELL_VAR *	find_shell_variable (char *name) const

SHELL_VAR *	find_variable (char *name) const

SHELL_VAR *	find_variable_no_invisible (char *name) const

SHELL_VAR *	find_variable_for_assignment (char *name) const

SHELL_VAR *	find_variable_noref (char *name) const

SHELL_VAR *	find_function (char *name) const

FUNCTION_DEF *	find_function_def (char *name) const

char *	get_variable_value (SHELL_VAR *var)

char *	get_string_value (char *var_name) const

char *	sh_get_env_value (char *v) const

static int	var_sametype (SHELL_VAR v1, SHELL_VAR v2)

int	validate_inherited_value (SHELL_VAR *var, int type)

SHELL_VAR *	set_if_not (char name, char value)

SHELL_VAR *	make_local_variable (char *name, int flags) const

static SHELL_VAR *	new_shell_variable (char *name) const

static SHELL_VAR *	make_new_variable (char name, HASH_TABLE table) const

char *	make_variable_value (SHELL_VAR var, char value, int flags)

static int	can_optimize_assignment (SHELL_VAR entry, char value, int aflags)

static SHELL_VAR *	optimized_assignment (SHELL_VAR entry, char value, int aflags)

static SHELL_VAR *	bind_variable_internal (char name, char value, HASH_TABLE *table, int hflags, int aflags) const

SHELL_VAR *	bind_variable (char name, char value, int flags) const

SHELL_VAR *	bind_global_variable (char name, char value, int flags) const

static SHELL_VAR *	bind_invalid_envvar (char name, char value, int flags) const

SHELL_VAR *	bind_variable_value (SHELL_VAR var, char value, int aflags)

SHELL_VAR *	bind_int_variable (char lhs, char rhs, int flags)

SHELL_VAR *	bind_var_to_int (char *var, intmax_t val)

SHELL_VAR *	bind_function (char name, COMMAND value) const

int	assign_in_env (WORD_DESC *word, int flags)

static void	dispose_variable_value (SHELL_VAR *var)

void	dispose_variable (SHELL_VAR *var)

int	unbind_variable (char *name) const

int	unbind_nameref (char *name) const

int	unbind_variable_noref (char *name) const

int	check_unbind_variable (char *name) const

int	unbind_func (char *name) const

int	delete_var (char name, VAR_CONTEXT vc) const

int	makunbound (char name, VAR_CONTEXT vc) const

void	kill_all_local_variables ()

static void	free_variable_hash_data (char *data)

void	delete_all_variables (HASH_TABLE *hashed_vars)

void	set_var_read_only (char *name)

static VARLIST *	vlist_alloc (int nentries)

static VARLIST *	vlist_realloc (VARLIST *vlist, int n)

static void	vlist_add (VARLIST vlist, SHELL_VAR var, int flags)

SHELL_VAR **	map_over (sh_var_map_func_t function, VAR_CONTEXT vc)

SHELL_VAR **	map_over_funcs (sh_var_map_func_t *function)

static void	flatten (HASH_TABLE var_hash_table, sh_var_map_func_t func, VARLIST *vlist, int flags)

void	sort_variables (SHELL_VAR **array)

static int	qsort_var_comp (SHELL_VAR var1, SHELL_VAR var2)

static SHELL_VAR **	vapply (sh_var_map_func_t *func)

static SHELL_VAR **	fapply (sh_var_map_func_t *func)

SHELL_VAR **	all_shell_variables ()

SHELL_VAR **	all_shell_functions ()

static int	visible_var (SHELL_VAR *var)

SHELL_VAR **	all_visible_functions ()

SHELL_VAR **	all_visible_variables ()

static int	visible_and_exported (SHELL_VAR *var)

static int	export_environment_candidate (SHELL_VAR *var)

static int	local_and_exported (SHELL_VAR *var)

SHELL_VAR **	all_exported_variables ()

SHELL_VAR **	local_exported_variables ()

static int	variable_in_context (SHELL_VAR *var)

SHELL_VAR **	all_local_variables ()

char **	all_variables_matching_prefix (char *prefix) const

static SHELL_VAR *	bind_tempenv_variable (char name, char value) const

SHELL_VAR *	find_tempenv_variable (char *name) const

static void	push_posix_temp_var (char *data)

static void	push_temp_var (char *data)

static void	propagate_temp_var (char *data)

static void	dispose_temporary_env (sh_free_func_t *pushf)

void	dispose_used_env_vars ()

void	merge_temporary_env ()

void	flush_temporary_env ()

static char *	mk_env_string (char name, char value, int isfunc) const

static char **	make_env_array_from_var_list (SHELL_VAR **vars)

static char **	make_var_export_array (VAR_CONTEXT *vcxt)

static char **	make_func_export_array ()

char **	add_or_supercede_exported_var (char *assign, int do_alloc)

static void	add_temp_array_to_env (char **temp_array, int do_alloc, int do_supercede)

static int	n_shell_variables ()

int	chkexport (char *name)

void	maybe_make_export_env ()

void	update_export_env_inplace (char env_prefix, int preflen, char value)

void	put_command_name_into_env (char *command_name)

VAR_CONTEXT *	new_var_context (char *name, int flags)

void	dispose_var_context (VAR_CONTEXT *vc)

static int	set_context (SHELL_VAR *var)

VAR_CONTEXT *	push_var_context (char name, int flags, HASH_TABLE tempvars)

static void	push_posix_tempvar_internal (SHELL_VAR *var, int isbltin)

static void	push_func_var (char *data)

static void	push_builtin_var (char *data)

void	pop_var_context ()

void	delete_all_contexts (VAR_CONTEXT *vcxt)

VAR_CONTEXT *	push_scope (int flags, HASH_TABLE *tmpvars)

static void	push_exported_var (char *data)

void	pop_scope (int is_special)

static char **	save_dollar_vars ()

static void	restore_dollar_vars (char **args)

static void	free_dollar_vars ()

static void	free_saved_dollar_vars (char **args)

void	push_context (char name, int is_subshell, HASH_TABLE tempvars)

void	pop_context ()

void	push_dollar_vars ()

void	pop_dollar_vars ()

void	dispose_saved_dollar_vars ()

void	init_bash_argv ()

void	save_bash_argv ()

void	push_args (WORD_LIST *list)

void	pop_args ()

static int	sv_compare (struct name_and_function sv1, struct name_and_function sv2)

static int	find_special_var (char *name) const

void	stupidly_hack_special_variables (char *name)

void	reinit_special_variables ()

void	sv_ifs (char *name)

void	sv_path (char *name)

void	sv_mail (char *name)

void	sv_funcnest (char *name)

void	sv_execignore (char *name)

void	sv_globignore (char *name)

void	sv_ignoreeof (char *name)

void	sv_optind (char *name)

void	sv_opterr (char *name)

void	sv_strict_posix (char *name)

void	sv_locale (char *name)

void	set_pipestatus_from_exit (int s)

void	sv_xtracefd (char *name)

void	sv_shcompat (char *name)

Variables
char **	environ

time_t	shell_start_time

VAR_CONTEXT *	global_variables = (VAR_CONTEXT *) 0x0

VAR_CONTEXT *	shell_variables = (VAR_CONTEXT *) 0x0

HASH_TABLE *	shell_functions = (HASH_TABLE *) 0x0

HASH_TABLE *	invalid_env = (HASH_TABLE *) 0x0

int	variable_context = 0

int	localvar_inherit = 0

int	localvar_unset = 0

HASH_TABLE *	temporary_env = (HASH_TABLE *) 0x0

int	tempenv_assign_error

char *	dollar_vars [10]

WORD_LIST *	rest_of_args = (WORD_LIST *) 0x0

pid_t	dollar_dollar_pid

int	array_needs_making = 1

int	shell_level = 0

char **	export_env = (char **) 0x0

static int	export_env_index

static int	export_env_size

SHELL_VAR	nameref_invalid_value

static SHELL_VAR	nameref_maxloop_value

static HASH_TABLE *	last_table_searched

static intmax_t	seconds_value_assigned

static unsigned long	rseed = 1

static int	last_random_value

static int	seeded_subshell = 0

static char *	static_shell_name = 0

char **	tempvar_list

int	tvlist_ind

static struct saved_dollar_vars *	dollar_arg_stack = (struct saved_dollar_vars *) 0x0

static int	dollar_arg_stack_slots

static int	dollar_arg_stack_index

static struct name_and_function	special_vars []

Data Structure Documentation

◆ saved_dollar_vars

struct saved_dollar_vars

Definition at line 5328 of file variables.c.

Data Fields
char **	first_ten
WORD_LIST *	rest

◆ name_and_function

struct name_and_function

Definition at line 5554 of file variables.c.

Data Fields
char *	name
sh_sv_func_t *	function

Macro Definition Documentation

◆ NEED_XTRACE_SET_DECL

#define NEED_XTRACE_SET_DECL

Definition at line 47 of file variables.c.

◆ VARIABLES_HASH_BUCKETS

#define VARIABLES_HASH_BUCKETS 1024 /* must be power of two */

Definition at line 83 of file variables.c.

Referenced by create_variable_tables(), push_posix_temp_var(), push_posix_tempvar_internal(), and push_temp_var().

◆ FUNCTIONS_HASH_BUCKETS

#define FUNCTIONS_HASH_BUCKETS 512

Definition at line 84 of file variables.c.

Referenced by create_variable_tables().

◆ TEMPENV_HASH_BUCKETS

#define TEMPENV_HASH_BUCKETS 4 /* must be power of two */

Definition at line 85 of file variables.c.

Referenced by assign_in_env(), make_local_variable(), and push_temp_var().

◆ BASHFUNC_PREFIX

#define BASHFUNC_PREFIX "BASH_FUNC_"

Definition at line 87 of file variables.c.

Referenced by initialize_shell_variables(), and mk_env_string().

◆ BASHFUNC_PREFLEN

#define BASHFUNC_PREFLEN 10 /* == strlen(BASHFUNC_PREFIX */

Definition at line 88 of file variables.c.

Referenced by initialize_shell_variables(), and mk_env_string().

◆ BASHFUNC_SUFFIX

#define BASHFUNC_SUFFIX "%%"

Definition at line 89 of file variables.c.

Referenced by initialize_shell_variables(), and mk_env_string().

◆ BASHFUNC_SUFFLEN

#define BASHFUNC_SUFFLEN 2 /* == strlen(BASHFUNC_SUFFIX) */

Definition at line 90 of file variables.c.

Referenced by initialize_shell_variables(), and mk_env_string().

◆ FV_FORCETEMPENV

#define FV_FORCETEMPENV 0x01

Definition at line 94 of file variables.c.

Referenced by find_variable(), find_variable_for_assignment(), find_variable_internal(), find_variable_last_nameref(), find_variable_nameref(), find_variable_no_invisible(), find_variable_noref(), and find_variable_tempenv().

◆ FV_SKIPINVISIBLE

#define FV_SKIPINVISIBLE 0x02

Definition at line 95 of file variables.c.

Referenced by find_variable_internal(), and find_variable_no_invisible().

◆ INIT_DYNAMIC_VAR

#define INIT_DYNAMIC_VAR	(	var,
		val,
		gfunc,
		afunc
	)

Value:

do \
    { \
      v = bind_variable (var, (val), 0); \
      v->dynamic_value = gfunc; \
      v->assign_func = afunc; \
    } \
  while (0)

Definition at line 1165 of file variables.c.

Referenced by init_funcname_var(), init_seconds_var(), and initialize_dynamic_variables().

◆ INIT_DYNAMIC_ARRAY_VAR

#define INIT_DYNAMIC_ARRAY_VAR	(	var,
		gfunc,
		afunc
	)

Value:

do \
    { \
      v = make_new_array_variable (var); \
      v->dynamic_value = gfunc; \
      v->assign_func = afunc; \
    } \
  while (0)

Definition at line 1174 of file variables.c.

Referenced by get_self(), and init_funcname_var().

◆ INIT_DYNAMIC_ASSOC_VAR

#define INIT_DYNAMIC_ASSOC_VAR	(	var,
		gfunc,
		afunc
	)

Value:

do \
    { \
      v = make_new_assoc_variable (var); \
      v->dynamic_value = gfunc; \
      v->assign_func = afunc; \
    } \
  while (0)

Definition at line 1183 of file variables.c.

Referenced by get_self().

◆ FIND_OR_MAKE_VARIABLE

#define FIND_OR_MAKE_VARIABLE	(	name,
		entry
	)

Value:

do \
    { \
      entry = find_variable (name); \
      if (!entry) \
    { \
      entry = bind_variable (name, "", 0); \
      if (!no_invisible_vars && entry) entry->attributes |= att_invisible; \
    } \
    } \
  while (0)

Definition at line 3981 of file variables.c.

Referenced by set_var_read_only().

◆ USE_EXPORTSTR

#define USE_EXPORTSTR (value == var->exportstr)

Referenced by make_env_array_from_var_list().

◆ add_to_export_env

#define add_to_export_env	(	envstr,
		do_alloc
	)

Value:

do \
  { \
    if (export_env_index >= (export_env_size - 1)) \
      { \
    export_env_size += 16; \
    export_env = strvec_resize (export_env, export_env_size); \
    environ = export_env; \
      } \
    export_env[export_env_index++] = (do_alloc) ? savestring (envstr) : envstr; \
    export_env[export_env_index] = (char *)NULL; \
  } while (0)

Definition at line 4799 of file variables.c.

Referenced by add_or_supercede_exported_var(), and add_temp_array_to_env().

◆ SET_INT_VAR

#define SET_INT_VAR	(	name,
		intvar
	)	intvar = find_variable (name) != 0

Definition at line 5551 of file variables.c.

◆ N_SPECIAL_VARS

#define N_SPECIAL_VARS (sizeof (special_vars) / sizeof (special_vars[0]) - 1)

Definition at line 5643 of file variables.c.

Referenced by stupidly_hack_special_variables().

◆ MIN_COMPAT_LEVEL

#define MIN_COMPAT_LEVEL 31

Definition at line 6240 of file variables.c.

Function Documentation

◆ __P() [1/26]

static void create_variable_tables __P ( (void) )

static

◆ __P() [2/26]

static SHELL_VAR* null_assign __P ( (SHELL_VAR *, char *, arrayind_t, char *) )

static

◆ __P() [3/26]

static SHELL_VAR* get_self __P ( (SHELL_VAR *) )

static

◆ __P() [4/26]

static void sbrand __P ( (unsigned long) )

static

◆ __P() [5/26]

static SHELL_VAR* bind_invalid_envvar __P ( (const char *, char *, int) )

static

◆ __P() [6/26]

static int var_sametype __P ( (SHELL_VAR *, SHELL_VAR *) )

static

◆ __P() [7/26]

static SHELL_VAR* hash_lookup __P ( (const char *, HASH_TABLE *) )

static

◆ __P() [8/26]

static SHELL_VAR* new_shell_variable __P ( (const char *) )

static

◆ __P() [9/26]

static SHELL_VAR* bind_variable_internal __P ( (const char *, char *, HASH_TABLE *, int, int) )

static

◆ __P() [10/26]

static void free_variable_hash_data __P ( (char *) )

static

◆ __P() [11/26]

static VARLIST* vlist_alloc __P ( (int) )

static

◆ __P() [12/26]

static VARLIST* vlist_realloc __P ( (VARLIST *, int) )

static

◆ __P() [13/26]

static void vlist_add __P ( (VARLIST *, SHELL_VAR *, int) )

static

◆ __P() [14/26]

static void flatten __P ( (HASH_TABLE *, sh_var_map_func_t *, VARLIST *, int) )

static

◆ __P() [15/26]

static int qsort_var_comp __P ( (SHELL_VAR **, SHELL_VAR **) )

static

◆ __P() [16/26]

static SHELL_VAR** vapply __P ( (sh_var_map_func_t *) )

static

◆ __P() [17/26]

static SHELL_VAR* find_variable_internal __P ( (const char *, int) )

static

◆ __P() [18/26]

static SHELL_VAR* find_nameref_at_context __P ( (SHELL_VAR *, VAR_CONTEXT *) )

static

◆ __P() [19/26]

static SHELL_VAR* find_variable_nameref_context __P ( (SHELL_VAR *, VAR_CONTEXT *, VAR_CONTEXT **) )

static

◆ __P() [20/26]

static SHELL_VAR* bind_tempenv_variable __P ( (const char *, char *) )

static

◆ __P() [21/26]

static void dispose_temporary_env __P ( (sh_free_func_t *) )

static

◆ __P() [22/26]

static char* mk_env_string __P ( (const char *, const char *, int) )

inlinestatic

◆ __P() [23/26]

static char** make_env_array_from_var_list __P ( (SHELL_VAR **) )

static

◆ __P() [24/26]

static char** make_var_export_array __P ( (VAR_CONTEXT *) )

static

◆ __P() [25/26]

static void add_temp_array_to_env __P ( (char **, int, int) )

static

◆ __P() [26/26]

static void push_posix_tempvar_internal __P ( (SHELL_VAR *, int) )

inlinestatic

◆ create_variable_tables()

static void create_variable_tables ( )

static

Definition at line 314 of file variables.c.

References FUNCTIONS_HASH_BUCKETS, hash_create(), new_var_context(), NULL, var_context::scope, var_context::table, and VARIABLES_HASH_BUCKETS.

Referenced by bind_global_variable(), bind_variable(), initialize_shell_variables(), make_new_variable(), and set_if_not().

 {
   if (shell_variables == 0)
     {
       shell_variables = global_variables = new_var_context ((char *)NULL, 0);
       shell_variables->scope = 0;
       shell_variables->table = hash_create (VARIABLES_HASH_BUCKETS);
     }
 
   if (shell_functions == 0)
     shell_functions = hash_create (FUNCTIONS_HASH_BUCKETS);
 
 #if defined (DEBUGGER)
   if (shell_function_defs == 0)
     shell_function_defs = hash_create (FUNCTIONS_HASH_BUCKETS);
 #endif
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initialize_shell_variables()

void initialize_shell_variables	(	char **	env,
		int	privmode
	)

Definition at line 336 of file variables.c.

References _(), absolute_program(), array_needs_making, att_exported, att_imported, att_integer, att_invisible, att_readonly, bash_tilde_expand(), BASHFUNC_PREFIX, BASHFUNC_PREFLEN, BASHFUNC_SUFFIX, BASHFUNC_SUFFLEN, bind_invalid_envvar(), bind_variable(), c, CACHE_IMPORTSTR, command_execution_string, create_variable_tables(), current_user, DEFAULT_PATH_VALUE, dollar_dollar_pid, dollar_vars, user_info::euid, find_function(), find_variable(), free(), FREE, function_p, get_bash_name(), get_current_user_info(), getpid(), imported_p, initialize_dynamic_variables(), initialize_shell_level(), interactive_shell, last_command_exit_value, legal_identifier(), login_shell, variable::name, no_line_editing, NULL, parse_and_execute(), posixly_correct, primary_prompt, read_but_dont_execute, readonly_p, remember_on_history, report_error(), rl_prefer_env_winsize, secondary_prompt, seedrand(), set_auto_export, set_home_var(), set_if_not(), set_machine_vars(), set_ppid(), set_pwd(), set_shell_var(), setifs(), SEVAL_FUNCDEF, SEVAL_NOHIST, SEVAL_NONINT, SEVAL_ONECMD, sh_opterr, shell_version_string(), STREQ, STREQN, string, sv_funcnest(), sv_ignoreeof(), sv_shcompat(), sv_strict_posix(), sv_xtracefd(), user_info::uid, uidset(), VSETATTR, VUNSETATTR, and xmalloc().

Referenced by shell_initialize().

 {
   char *name, *string, *temp_string;
   int c, char_index, string_index, string_length, ro;
   SHELL_VAR *temp_var;
 
   create_variable_tables ();
 
   for (string_index = 0; env && (string = env[string_index++]); )
     {
       char_index = 0;
       name = string;
       while ((c = *string++) && c != '=')
     ;
       if (string[-1] == '=')
     char_index = string - name - 1;
 
       /* If there are weird things in the environment, like `=xxx' or a
      string without an `=', just skip them. */
       if (char_index == 0)
     continue;
 
       /* ASSERT(name[char_index] == '=') */
       name[char_index] = '\0';
       /* Now, name = env variable name, string = env variable value, and
      char_index == strlen (name) */
 
       temp_var = (SHELL_VAR *)NULL;
 
 #if defined (FUNCTION_IMPORT)
       /* If exported function, define it now.  Don't import functions from
      the environment in privileged mode. */
       if (privmode == 0 && read_but_dont_execute == 0 && 
           STREQN (BASHFUNC_PREFIX, name, BASHFUNC_PREFLEN) &&
           STREQ (BASHFUNC_SUFFIX, name + char_index - BASHFUNC_SUFFLEN) &&
       STREQN ("() {", string, 4))
     {
       size_t namelen;
       char *tname;      /* desired imported function name */
 
       namelen = char_index - BASHFUNC_PREFLEN - BASHFUNC_SUFFLEN;
 
       tname = name + BASHFUNC_PREFLEN;  /* start of func name */
       tname[namelen] = '\0';        /* now tname == func name */
 
       string_length = strlen (string);
       temp_string = (char *)xmalloc (namelen + string_length + 2);
 
       memcpy (temp_string, tname, namelen);
       temp_string[namelen] = ' ';
       memcpy (temp_string + namelen + 1, string, string_length + 1);
 
       /* Don't import function names that are invalid identifiers from the
          environment in posix mode, though we still allow them to be defined as
          shell variables. */
       if (absolute_program (tname) == 0 && (posixly_correct == 0 || legal_identifier (tname)))
         parse_and_execute (temp_string, tname, SEVAL_NONINT|SEVAL_NOHIST|SEVAL_FUNCDEF|SEVAL_ONECMD);
       else
         free (temp_string);     /* parse_and_execute does this */
 
       if (temp_var = find_function (tname))
         {
           VSETATTR (temp_var, (att_exported|att_imported));
           array_needs_making = 1;
         }
       else
         {
           if (temp_var = bind_invalid_envvar (name, string, 0))
         {
           VSETATTR (temp_var, (att_exported | att_imported | att_invisible));
           array_needs_making = 1;
         }
           last_command_exit_value = 1;
           report_error (_("error importing function definition for `%s'"), tname);
         }
 
       /* Restore original suffix */
       tname[namelen] = BASHFUNC_SUFFIX[0];
     }
       else
 #endif /* FUNCTION_IMPORT */
 #if defined (ARRAY_VARS)
 #  if ARRAY_EXPORT
       /* Array variables may not yet be exported. */
       if (*string == '(' && string[1] == '[' && string[strlen (string) - 1] == ')')
     {
       string_length = 1;
       temp_string = extract_array_assignment_list (string, &string_length);
       temp_var = assign_array_from_string (name, temp_string, 0);
       FREE (temp_string);
       VSETATTR (temp_var, (att_exported | att_imported));
       array_needs_making = 1;
     }
       else
 #  endif /* ARRAY_EXPORT */
 #endif
     {
       ro = 0;
       /* If we processed a command-line option that caused SHELLOPTS to be
          set, it may already be set (and read-only) by the time we process
          the shell's environment. */
       if (/* posixly_correct &&*/ STREQ (name, "SHELLOPTS"))
         {
           temp_var = find_variable ("SHELLOPTS");
           ro = temp_var && readonly_p (temp_var);
           if (temp_var)
         VUNSETATTR (temp_var, att_readonly);
         }
       if (legal_identifier (name))
         {
           temp_var = bind_variable (name, string, 0);
           if (temp_var)
         {
           VSETATTR (temp_var, (att_exported | att_imported));
           if (ro)
             VSETATTR (temp_var, att_readonly);
         }
         }
       else
         {
           temp_var = bind_invalid_envvar (name, string, 0);
           if (temp_var)
         VSETATTR (temp_var, (att_exported | att_imported | att_invisible));
         }
       if (temp_var)
         array_needs_making = 1;
     }
 
       name[char_index] = '=';
       /* temp_var can be NULL if it was an exported function with a syntax
      error (a different bug, but it still shouldn't dump core). */
       if (temp_var && function_p (temp_var) == 0)   /* XXX not yet */
     {
       CACHE_IMPORTSTR (temp_var, name);
     }
     }
 
   set_pwd ();
 
   /* Set up initial value of $_ */
   temp_var = set_if_not ("_", dollar_vars[0]);
 
   /* Remember this pid. */
   dollar_dollar_pid = getpid ();
 
   /* Now make our own defaults in case the vars that we think are
      important are missing. */
   temp_var = set_if_not ("PATH", DEFAULT_PATH_VALUE);
   temp_var = set_if_not ("TERM", "dumb");
 
 #if defined (__QNX__)
   /* set node id -- don't import it from the environment */
   {
     char node_name[22];
 #  if defined (__QNXNTO__)
     netmgr_ndtostr(ND2S_LOCAL_STR, ND_LOCAL_NODE, node_name, sizeof(node_name));
 #  else
     qnx_nidtostr (getnid (), node_name, sizeof (node_name));
 #  endif
     temp_var = bind_variable ("NODE", node_name, 0);
     if (temp_var)
       set_auto_export (temp_var);
   }
 #endif
 
   /* set up the prompts. */
   if (interactive_shell)
     {
 #if defined (PROMPT_STRING_DECODE)
       set_if_not ("PS1", primary_prompt);
 #else
       if (current_user.uid == -1)
     get_current_user_info ();
       set_if_not ("PS1", current_user.euid == 0 ? "# " : primary_prompt);
 #endif
       set_if_not ("PS2", secondary_prompt);
     }
 
   if (current_user.euid == 0)
     bind_variable ("PS4", "+ ", 0);
   else
     set_if_not ("PS4", "+ ");
 
   /* Don't allow IFS to be imported from the environment. */
   temp_var = bind_variable ("IFS", " \t\n", 0);
   setifs (temp_var);
 
   /* Magic machine types.  Pretty convenient. */
   set_machine_vars ();
 
   /* Default MAILCHECK for interactive shells.  Defer the creation of a
      default MAILPATH until the startup files are read, because MAIL
      names a mail file if MAILPATH is not set, and we should provide a
      default only if neither is set. */
   if (interactive_shell)
     {
       temp_var = set_if_not ("MAILCHECK", posixly_correct ? "600" : "60");
       VSETATTR (temp_var, att_integer);
     }
 
   /* Do some things with shell level. */
   initialize_shell_level ();
 
   set_ppid ();
 
   /* Initialize the `getopts' stuff. */
   temp_var = bind_variable ("OPTIND", "1", 0);
   VSETATTR (temp_var, att_integer);
   getopts_reset (0);
   bind_variable ("OPTERR", "1", 0);
   sh_opterr = 1;
 
   if (login_shell == 1 && posixly_correct == 0)
     set_home_var ();
 
   /* Get the full pathname to THIS shell, and set the BASH variable
      to it. */
   name = get_bash_name ();
   temp_var = bind_variable ("BASH", name, 0);
   free (name);
 
   /* Make the exported environment variable SHELL be the user's login
      shell.  Note that the `tset' command looks at this variable
      to determine what style of commands to output; if it ends in "csh",
      then C-shell commands are output, else Bourne shell commands. */
   set_shell_var ();
 
   /* Make a variable called BASH_VERSION which contains the version info. */
   bind_variable ("BASH_VERSION", shell_version_string (), 0);
 #if defined (ARRAY_VARS)
   make_vers_array ();
 #endif
 
   if (command_execution_string)
     bind_variable ("BASH_EXECUTION_STRING", command_execution_string, 0);
 
   /* Find out if we're supposed to be in Posix.2 mode via an
      environment variable. */
   temp_var = find_variable ("POSIXLY_CORRECT");
   if (!temp_var)
     temp_var = find_variable ("POSIX_PEDANTIC");
   if (temp_var && imported_p (temp_var))
     sv_strict_posix (temp_var->name);
 
 #if defined (HISTORY)
   /* Set history variables to defaults, and then do whatever we would
      do if the variable had just been set.  Do this only in the case
      that we are remembering commands on the history list. */
   if (remember_on_history)
     {
       name = bash_tilde_expand (posixly_correct ? "~/.sh_history" : "~/.bash_history", 0);
 
       set_if_not ("HISTFILE", name);
       free (name);
     }
 #endif /* HISTORY */
 
   /* Seed the random number generator. */
   seedrand ();
 
   /* Handle some "special" variables that we may have inherited from a
      parent shell. */
   if (interactive_shell)
     {
       temp_var = find_variable ("IGNOREEOF");
       if (!temp_var)
     temp_var = find_variable ("ignoreeof");
       if (temp_var && imported_p (temp_var))
     sv_ignoreeof (temp_var->name);
     }
 
 #if defined (HISTORY)
   if (interactive_shell && remember_on_history)
     {
       sv_history_control ("HISTCONTROL");
       sv_histignore ("HISTIGNORE");
       sv_histtimefmt ("HISTTIMEFORMAT");
     }
 #endif /* HISTORY */
 
 #if defined (READLINE) && defined (STRICT_POSIX)
   /* POSIXLY_CORRECT will be 1 here if the shell was compiled
      -DSTRICT_POSIX or if POSIXLY_CORRECT was supplied in the shell's
      environment */
   if (interactive_shell && posixly_correct && no_line_editing == 0)
     rl_prefer_env_winsize = 1;
 #endif /* READLINE && STRICT_POSIX */
 
      /*
       * 24 October 2001
       *
       * I'm tired of the arguing and bug reports.  Bash now leaves SSH_CLIENT
       * and SSH2_CLIENT alone.  I'm going to rely on the shell_level check in
       * isnetconn() to avoid running the startup files more often than wanted.
       * That will, of course, only work if the user's login shell is bash, so
       * I've made that behavior conditional on SSH_SOURCE_BASHRC being defined
       * in config-top.h.
       */
 #if 0
   temp_var = find_variable ("SSH_CLIENT");
   if (temp_var && imported_p (temp_var))
     {
       VUNSETATTR (temp_var, att_exported);
       array_needs_making = 1;
     }
   temp_var = find_variable ("SSH2_CLIENT");
   if (temp_var && imported_p (temp_var))
     {
       VUNSETATTR (temp_var, att_exported);
       array_needs_making = 1;
     }
 #endif
 
   /* Get the user's real and effective user ids. */
   uidset ();
 
   temp_var = find_variable ("BASH_XTRACEFD");
   if (temp_var && imported_p (temp_var))
     sv_xtracefd (temp_var->name);
 
   sv_shcompat ("BASH_COMPAT");
 
   /* Allow FUNCNEST to be inherited from the environment. */
   sv_funcnest ("FUNCNEST");
 
   /* Initialize the dynamic variables, and seed their values. */
   initialize_dynamic_variables ();
 }

Here is the caller graph for this function:

◆ set_machine_vars()

static void set_machine_vars ( )

static

Definition at line 674 of file variables.c.

References current_host_name, HOSTTYPE, MACHTYPE, OSTYPE, and set_if_not().

Referenced by initialize_shell_variables().

 {
   SHELL_VAR *temp_var;
 
   temp_var = set_if_not ("HOSTTYPE", HOSTTYPE);
   temp_var = set_if_not ("OSTYPE", OSTYPE);
   temp_var = set_if_not ("MACHTYPE", MACHTYPE);
 
   temp_var = set_if_not ("HOSTNAME", current_host_name);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sh_get_home_dir()

char* sh_get_home_dir ( void )

Definition at line 691 of file variables.c.

References current_user, get_current_user_info(), getpwuid(), getuid, user_info::home_dir, NULL, and savestring().

Referenced by set_home_var(), and tilde_expand_word().

 {
   if (current_user.home_dir == 0)
     get_current_user_info ();
   return current_user.home_dir;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_home_var()

static void set_home_var ( )

static

Definition at line 699 of file variables.c.

References att_exported, bind_variable(), find_variable(), sh_get_home_dir(), and VSETATTR.

Referenced by initialize_shell_variables().

 {
   SHELL_VAR *temp_var;
 
   temp_var = find_variable ("HOME");
   if (temp_var == 0)
     temp_var = bind_variable ("HOME", sh_get_home_dir (), 0);
 #if 0
   VSETATTR (temp_var, att_exported);
 #endif
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_shell_var()

static void set_shell_var ( )

static

Definition at line 714 of file variables.c.

References att_exported, bind_variable(), current_user, find_variable(), get_current_user_info(), user_info::shell, and VSETATTR.

Referenced by initialize_shell_variables().

 {
   SHELL_VAR *temp_var;
 
   temp_var = find_variable ("SHELL");
   if (temp_var == 0)
     {
       if (current_user.shell == 0)
     get_current_user_info ();
       temp_var = bind_variable ("SHELL", current_user.shell, 0);
     }
 #if 0
   VSETATTR (temp_var, att_exported);
 #endif
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_bash_name()

static char* get_bash_name ( )

static

Definition at line 731 of file variables.c.

References ABSPATH, current_user, file_status(), find_user_command(), free(), FS_EXECABLE, full_pathname(), get_current_user_info(), get_string_value(), login_shell, make_absolute(), PATH_CHECKDOTDOT, PATH_CHECKEXISTS, RELPATH, savestring(), sh_canonpath(), user_info::shell, shell_name, strcpy(), and xmalloc().

Referenced by initialize_shell_variables().

 {
   char *name;
 
   if ((login_shell == 1) && RELPATH(shell_name))
     {
       if (current_user.shell == 0)
     get_current_user_info ();
       name = savestring (current_user.shell);
     }
   else if (ABSPATH(shell_name))
     name = savestring (shell_name);
   else if (shell_name[0] == '.' && shell_name[1] == '/')
     {
       /* Fast path for common case. */
       char *cdir;
       int len;
 
       cdir = get_string_value ("PWD");
       if (cdir)
     {
       len = strlen (cdir);
       name = (char *)xmalloc (len + strlen (shell_name) + 1);
       strcpy (name, cdir);
       strcpy (name + len, shell_name + 1);
     }
       else
     name = savestring (shell_name);
     }
   else
     {
       char *tname;
       int s;
 
       tname = find_user_command (shell_name);
 
       if (tname == 0)
     {
       /* Try the current directory.  If there is not an executable
          there, just punt and use the login shell. */
       s = file_status (shell_name);
       if (s & FS_EXECABLE)
         {
           tname = make_absolute (shell_name, get_string_value ("PWD"));
           if (*shell_name == '.')
         {
           name = sh_canonpath (tname, PATH_CHECKDOTDOT|PATH_CHECKEXISTS);
           if (name == 0)
             name = tname;
           else
             free (tname);
         }
          else
         name = tname;
         }
       else
         {
           if (current_user.shell == 0)
         get_current_user_info ();
           name = savestring (current_user.shell);
         }
     }
       else
     {
       name = full_pathname (tname);
       free (tname);
     }
     }
 
   return (name);
 }

Here is the caller graph for this function:

◆ adjust_shell_level()

void adjust_shell_level ( int change )

Definition at line 804 of file variables.c.

References _(), bind_variable(), get_string_value(), internal_warning(), legal_number(), set_auto_export, and shell_level.

Referenced by execute_disk_command(), initialize_shell_level(), and push_builtin().

 {
   char new_level[5], *old_SHLVL;
   intmax_t old_level;
   SHELL_VAR *temp_var;
 
   old_SHLVL = get_string_value ("SHLVL");
   if (old_SHLVL == 0 || *old_SHLVL == '\0' || legal_number (old_SHLVL, &old_level) == 0)
     old_level = 0;
 
   shell_level = old_level + change;
   if (shell_level < 0)
     shell_level = 0;
   else if (shell_level >= 1000)
     {
       internal_warning (_("shell level (%d) too high, resetting to 1"), shell_level);
       shell_level = 1;
     }
 
   /* We don't need the full generality of itos here. */
   if (shell_level < 10)
     {
       new_level[0] = shell_level + '0';
       new_level[1] = '\0';
     }
   else if (shell_level < 100)
     {
       new_level[0] = (shell_level / 10) + '0';
       new_level[1] = (shell_level % 10) + '0';
       new_level[2] = '\0';
     }
   else if (shell_level < 1000)
     {
       new_level[0] = (shell_level / 100) + '0';
       old_level = shell_level % 100;
       new_level[1] = (old_level / 10) + '0';
       new_level[2] = (old_level % 10) + '0';
       new_level[3] = '\0';
     }
 
   temp_var = bind_variable ("SHLVL", new_level, 0);
   set_auto_export (temp_var);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initialize_shell_level()

static void initialize_shell_level ( )

static

Definition at line 850 of file variables.c.

References adjust_shell_level().

Referenced by initialize_shell_variables().

 {
   adjust_shell_level (1);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_pwd()

void set_pwd ( )

Definition at line 863 of file variables.c.

References att_exported, att_invisible, bind_variable(), file_isdir(), find_variable(), free(), get_working_directory(), imported_p, interactive_shell, login_shell, NULL, PATH_CHECKDOTDOT, PATH_CHECKEXISTS, posixly_correct, same_file(), set_auto_export, set_working_directory(), sh_canonpath(), value_cell, and VSETATTR.

Referenced by initialize_shell_variables().

 {
   SHELL_VAR *temp_var, *home_var;
   char *temp_string, *home_string, *current_dir;
 
   home_var = find_variable ("HOME");
   home_string = home_var ? value_cell (home_var) : (char *)NULL;
 
   temp_var = find_variable ("PWD");
   /* Follow posix rules for importing PWD */
   if (temp_var && imported_p (temp_var) &&
       (temp_string = value_cell (temp_var)) &&
       temp_string[0] == '/' &&
       same_file (temp_string, ".", (struct stat *)NULL, (struct stat *)NULL))
     {
       current_dir = sh_canonpath (temp_string, PATH_CHECKDOTDOT|PATH_CHECKEXISTS);
       if (current_dir == 0)
     current_dir = get_working_directory ("shell_init");
       else
     set_working_directory (current_dir);
       if (posixly_correct && current_dir)
     {
       temp_var = bind_variable ("PWD", current_dir, 0);
       set_auto_export (temp_var);
     }  
       free (current_dir);
     }
   else if (home_string && interactive_shell && login_shell &&
        same_file (home_string, ".", (struct stat *)NULL, (struct stat *)NULL))
     {
       set_working_directory (home_string);
       temp_var = bind_variable ("PWD", home_string, 0);
       set_auto_export (temp_var);
     }
   else
     {
       temp_string = get_working_directory ("shell-init");
       if (temp_string)
     {
       temp_var = bind_variable ("PWD", temp_string, 0);
       set_auto_export (temp_var);
       free (temp_string);
     }
     }
 
   /* According to the Single Unix Specification, v2, $OLDPWD is an
      `environment variable' and therefore should be auto-exported.  If we
      don't find OLDPWD in the environment, or it doesn't name a directory,
      make a dummy invisible variable for OLDPWD, and mark it as exported. */
   temp_var = find_variable ("OLDPWD");
 #if defined (OLDPWD_CHECK_DIRECTORY)
   if (temp_var == 0 || value_cell (temp_var) == 0 || file_isdir (value_cell (temp_var)) == 0)
 #else
   if (temp_var == 0 || value_cell (temp_var) == 0)
 #endif
     {
       temp_var = bind_variable ("OLDPWD", (char *)NULL, 0);
       VSETATTR (temp_var, (att_exported | att_invisible));
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_ppid()

void set_ppid ( )

Definition at line 926 of file variables.c.

References att_exported, att_integer, att_readonly, bind_variable(), find_variable(), INT_STRLEN_BOUND, inttostr(), VSETATTR, and VUNSETATTR.

Referenced by initialize_shell_variables(), and push_builtin().

 {
   char namebuf[INT_STRLEN_BOUND(pid_t) + 1], *name;
   SHELL_VAR *temp_var;
 
   name = inttostr (getppid (), namebuf, sizeof(namebuf));
   temp_var = find_variable ("PPID");
   if (temp_var)
     VUNSETATTR (temp_var, (att_readonly | att_exported));
   temp_var = bind_variable ("PPID", name, 0);
   VSETATTR (temp_var, (att_readonly | att_integer));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ uidset()

static void uidset ( )

static

Definition at line 940 of file variables.c.

References array_cell, att_integer, att_readonly, bind_variable(), build_version, current_user, dist_version, user_info::euid, find_variable(), INT_STRLEN_BOUND, inttostr(), MACHTYPE, patch_level, release_status, strchr(), strcpy(), user_info::uid, unbind_variable_noref(), and VSETATTR.

Referenced by initialize_shell_variables().

 {
   char buff[INT_STRLEN_BOUND(uid_t) + 1], *b;
   register SHELL_VAR *v;
 
   b = inttostr (current_user.uid, buff, sizeof (buff));
   v = find_variable ("UID");
   if (v == 0)
     {
       v = bind_variable ("UID", b, 0);
       VSETATTR (v, (att_readonly | att_integer));
     }
 
   if (current_user.euid != current_user.uid)
     b = inttostr (current_user.euid, buff, sizeof (buff));
 
   v = find_variable ("EUID");
   if (v == 0)
     {
       v = bind_variable ("EUID", b, 0);
       VSETATTR (v, (att_readonly | att_integer));
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sh_set_lines_and_columns()

void sh_set_lines_and_columns	(	int	lines,
		int	cols
	)

Definition at line 996 of file variables.c.

References bind_variable(), INT_STRLEN_BOUND, inttostr(), and val.

 {
   char val[INT_STRLEN_BOUND(int) + 1], *v;
 
 #if defined (READLINE)
   /* If we are currently assigning to LINES or COLUMNS, don't do anything. */
   if (winsize_assignment)
     return;
 #endif
 
   v = inttostr (lines, val, sizeof (val));
   bind_variable ("LINES", v, 0);
 
   v = inttostr (cols, val, sizeof (val));
   bind_variable ("COLUMNS", v, 0);
 }

Here is the call graph for this function:

◆ print_var_list()

void print_var_list ( SHELL_VAR ** list )

Definition at line 1023 of file variables.c.

References i, invisible_p, and print_assignment().

 {
   register int i;
   register SHELL_VAR *var;
 
   for (i = 0; list && (var = list[i]); i++)
     if (invisible_p (var) == 0)
       print_assignment (var);
 }

Here is the call graph for this function:

◆ print_func_list()

void print_func_list ( SHELL_VAR ** list )

Definition at line 1037 of file variables.c.

References i, and print_var_function().

 {
   register int i;
   register SHELL_VAR *var;
 
   for (i = 0; list && (var = list[i]); i++)
     {
       printf ("%s ", var->name);
       print_var_function (var);
       printf ("\n");
     }
 }

Here is the call graph for this function:

◆ print_assignment()

void print_assignment ( SHELL_VAR * var )

Definition at line 1055 of file variables.c.

References array_p, assoc_p, function_p, variable::name, print_var_function(), print_var_value(), and var_isset.

Referenced by print_var_list().

 {
   if (var_isset (var) == 0)
     return;
 
   if (function_p (var))
     {
       printf ("%s", var->name);
       print_var_function (var);
       printf ("\n");
     }
 #if defined (ARRAY_VARS)
   else if (array_p (var))
     print_array_assignment (var, 0);
   else if (assoc_p (var))
     print_assoc_assignment (var, 0);
 #endif /* ARRAY_VARS */
   else
     {
       printf ("%s=", var->name);
       print_var_value (var, 1);
       printf ("\n");
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ print_var_value()

void print_var_value	(	SHELL_VAR *	var,
		int	quote
	)

Definition at line 1086 of file variables.c.

References ansic_quote(), ansic_shouldquote(), free(), posixly_correct, sh_contains_shell_metas(), sh_single_quote(), t, value_cell, and var_isset.

Referenced by print_assignment(), and printenv_builtin().

 {
   char *t;
 
   if (var_isset (var) == 0)
     return;
 
   if (quote && posixly_correct == 0 && ansic_shouldquote (value_cell (var)))
     {
       t = ansic_quote (value_cell (var), 0, (int *)0);
       printf ("%s", t);
       free (t);
     }
   else if (quote && sh_contains_shell_metas (value_cell (var)))
     {
       t = sh_single_quote (value_cell (var));
       printf ("%s", t);
       free (t);
     }
   else
     printf ("%s", value_cell (var));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ print_var_function()

void print_var_function ( SHELL_VAR * var )

Definition at line 1114 of file variables.c.

References FUNC_EXTERNAL, FUNC_MULTILINE, function_cell, function_p, named_function_string(), NULL, and var_isset.

Referenced by print_assignment(), print_func_list(), and printenv_builtin().

 {
   char *x;
 
   if (function_p (var) && var_isset (var))
     {
       x = named_function_string ((char *)NULL, function_cell(var), FUNC_MULTILINE|FUNC_EXTERNAL);
       printf ("%s", x);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ null_assign()

static SHELL_VAR* null_assign	(	SHELL_VAR *	self,
		char *	value,
		arrayind_t	unused,
		char *	key
	)

static

Definition at line 1193 of file variables.c.

Referenced by init_funcname_var(), and initialize_dynamic_variables().

 {
   return (self);
 }

Here is the caller graph for this function:

◆ get_self()

static SHELL_VAR* get_self ( SHELL_VAR * self )

static

Definition at line 1217 of file variables.c.

References find_variable(), INIT_DYNAMIC_ARRAY_VAR, INIT_DYNAMIC_ASSOC_VAR, and VSETATTR.

Referenced by initialize_dynamic_variables().

 {
   return (self);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ assign_seconds()

static SHELL_VAR* assign_seconds	(	SHELL_VAR *	self,
		char *	value,
		arrayind_t	unused,
		char *	key
	)

static

Definition at line 1269 of file variables.c.

References legal_number(), NOW, and shell_start_time.

Referenced by init_seconds_var().

 {
   if (legal_number (value, &seconds_value_assigned) == 0)
     seconds_value_assigned = 0;
   shell_start_time = NOW;
   return (self);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_seconds()

static SHELL_VAR* get_seconds ( SHELL_VAR * var )

static

Definition at line 1282 of file variables.c.

References att_integer, FREE, itos(), NOW, p, shell_start_time, value_cell, var_setvalue, and VSETATTR.

Referenced by init_seconds_var().

 {
   time_t time_since_start;
   char *p;
 
   time_since_start = NOW - shell_start_time;
   p = itos(seconds_value_assigned + time_since_start);
 
   FREE (value_cell (var));
 
   VSETATTR (var, att_integer);
   var_setvalue (var, p);
   return (var);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_seconds_var()

static SHELL_VAR* init_seconds_var ( )

static

Definition at line 1299 of file variables.c.

References assign_seconds(), find_variable(), get_seconds(), INIT_DYNAMIC_VAR, legal_number(), NULL, and value_cell.

Referenced by initialize_dynamic_variables().

 {
   SHELL_VAR *v;
 
   v = find_variable ("SECONDS");
   if (v)
     {
       if (legal_number (value_cell(v), &seconds_value_assigned) == 0)
     seconds_value_assigned = 0;
     }
   INIT_DYNAMIC_VAR ("SECONDS", (v ? value_cell (v) : (char *)NULL), get_seconds, assign_seconds);
   return v;      
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ brand()

static int brand ( )

static

Definition at line 1324 of file variables.c.

Referenced by get_random_number().

 {
   /* From "Random number generators: good ones are hard to find",
      Park and Miller, Communications of the ACM, vol. 31, no. 10,
      October 1988, p. 1195. filtered through FreeBSD */
   long h, l;
 
   /* Can't seed with 0. */
   if (rseed == 0)
     rseed = 123459876;
   h = rseed / 127773;
   l = rseed % 127773;
   rseed = 16807 * l - 2836 * h;
 #if 0
   if (rseed < 0)
     rseed += 0x7fffffff;
 #endif
   return ((unsigned int)(rseed & 32767));   /* was % 32768 */
 }

Here is the caller graph for this function:

◆ sbrand()

static void sbrand ( unsigned long seed )

static

Definition at line 1346 of file variables.c.

Referenced by assign_random(), and seedrand().

 {
   rseed = seed;
   last_random_value = 0;
 }

Here is the caller graph for this function:

◆ seedrand()

static void seedrand ( )

static

Definition at line 1354 of file variables.c.

References getpid(), NULL, and sbrand().

Referenced by get_random_number(), and initialize_shell_variables().

 {
   struct timeval tv;
 
   gettimeofday (&tv, NULL);
   sbrand (tv.tv_sec ^ tv.tv_usec ^ getpid ());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ assign_random()

static SHELL_VAR* assign_random	(	SHELL_VAR *	self,
		char *	value,
		arrayind_t	unused,
		char *	key
	)

static

Definition at line 1363 of file variables.c.

References getpid(), NULL, sbrand(), and subshell_environment.

Referenced by initialize_dynamic_variables().

 {
   sbrand (strtoul (value, (char **)NULL, 10));
   if (subshell_environment)
     seeded_subshell = getpid ();
   return (self);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_random_number()

int get_random_number ( )

Definition at line 1376 of file variables.c.

References brand(), getpid(), seedrand(), and subshell_environment.

Referenced by get_random().

 {
   int rv, pid;
 
   /* Reset for command and process substitution. */
   pid = getpid ();
   if (subshell_environment && seeded_subshell != pid)
     {
       seedrand ();
       seeded_subshell = pid;
     }
 
   do
     rv = brand ();
   while (rv == last_random_value);
   return rv;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_random()

static SHELL_VAR* get_random ( SHELL_VAR * var )

static

Definition at line 1395 of file variables.c.

References att_integer, FREE, get_random_number(), itos(), p, value_cell, var_setvalue, and VSETATTR.

Referenced by initialize_dynamic_variables().

 {
   int rv;
   char *p;
 
   rv = get_random_number ();
   last_random_value = rv;
   p = itos (rv);
 
   FREE (value_cell (var));
 
   VSETATTR (var, att_integer);
   var_setvalue (var, p);
   return (var);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ assign_lineno()

static SHELL_VAR* assign_lineno	(	SHELL_VAR *	var,
		char *	value,
		arrayind_t	unused,
		char *	key
	)

static

Definition at line 1413 of file variables.c.

References legal_number(), line_number, and line_number_base.

Referenced by initialize_dynamic_variables().

 {
   intmax_t new_value;
 
   if (value == 0 || *value == '\0' || legal_number (value, &new_value) == 0)
     new_value = 0;
   line_number = line_number_base = new_value;
   return var;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_lineno()

static SHELL_VAR* get_lineno ( SHELL_VAR * var )

static

Definition at line 1429 of file variables.c.

References executing_line_number(), FREE, itos(), p, value_cell, and var_setvalue.

Referenced by initialize_dynamic_variables().

 {
   char *p;
   int ln;
 
   ln = executing_line_number ();
   p = itos (ln);
   FREE (value_cell (var));
   var_setvalue (var, p);
   return (var);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ assign_subshell()

static SHELL_VAR* assign_subshell	(	SHELL_VAR *	var,
		char *	value,
		arrayind_t	unused,
		char *	key
	)

static

Definition at line 1443 of file variables.c.

References legal_number(), and subshell_level.

Referenced by initialize_dynamic_variables().

 {
   intmax_t new_value;
 
   if (value == 0 || *value == '\0' || legal_number (value, &new_value) == 0)
     new_value = 0;
   subshell_level = new_value;
   return var;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_subshell()

static SHELL_VAR* get_subshell ( SHELL_VAR * var )

static

Definition at line 1458 of file variables.c.

References FREE, itos(), p, subshell_level, value_cell, and var_setvalue.

Referenced by initialize_dynamic_variables().

 {
   char *p;
 
   p = itos (subshell_level);
   FREE (value_cell (var));
   var_setvalue (var, p);
   return (var);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_epochseconds()

static SHELL_VAR* get_epochseconds ( SHELL_VAR * var )

static

Definition at line 1470 of file variables.c.

References FREE, itos(), NOW, p, value_cell, and var_setvalue.

Referenced by initialize_dynamic_variables().

 {
   intmax_t now;
   char *p;
 
   now = NOW;
   p = itos (now);
 
   FREE (value_cell (var));
   var_setvalue (var, p);
   return (var);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_epochrealtime()

static SHELL_VAR* get_epochrealtime ( SHELL_VAR * var )

static

Definition at line 1485 of file variables.c.

References FREE, locale_decpoint(), NULL, p, savestring(), snprintf(), value_cell, and var_setvalue.

Referenced by initialize_dynamic_variables().

 {
   char buf[32];
   char *p;
   struct timeval tv;
 
   gettimeofday (&tv, NULL);
   snprintf (buf, sizeof (buf), "%u%c%06u", (unsigned)tv.tv_sec,
                        locale_decpoint (),
                        (unsigned)tv.tv_usec);
 
   p = savestring (buf);
   FREE (value_cell (var));
   var_setvalue (var, p);
   return (var);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_bashpid()

static SHELL_VAR* get_bashpid ( SHELL_VAR * var )

static

Definition at line 1504 of file variables.c.

References att_integer, FREE, getpid(), itos(), p, value_cell, var_setvalue, and VSETATTR.

Referenced by initialize_dynamic_variables().

 {
   int pid;
   char *p;
 
   pid = getpid ();
   p = itos (pid);
 
   FREE (value_cell (var));
   VSETATTR (var, att_integer);  /* XXX - was also att_readonly */
   var_setvalue (var, p);
   return (var);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_bash_argv0()

static SHELL_VAR* get_bash_argv0 ( SHELL_VAR * var )

static

Definition at line 1520 of file variables.c.

References dollar_vars, FREE, p, savestring(), value_cell, and var_setvalue.

Referenced by initialize_dynamic_variables().

 {
   char *p;
 
   p = savestring (dollar_vars[0]);
   FREE (value_cell (var));
   var_setvalue (var, p);
   return var;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ assign_bash_argv0()

static SHELL_VAR* assign_bash_argv0	(	SHELL_VAR *	var,
		char *	value,
		arrayind_t	unused,
		char *	key
	)

static

Definition at line 1534 of file variables.c.

References dollar_vars, FREE, savestring(), shell_name, static_shell_name, strcpy(), STRLEN, and xrealloc().

Referenced by initialize_dynamic_variables().

 {
   size_t vlen;
 
   if (value == 0)
     return var;
 
   FREE (dollar_vars[0]);
   dollar_vars[0] = savestring (value);
 
   /* Need these gyrations because shell_name isn't dynamically allocated */
   vlen = STRLEN (value);
   static_shell_name = xrealloc (static_shell_name, vlen + 1);
   strcpy (static_shell_name, value);
   
   shell_name = static_shell_name;
   return var;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_bash_command()

static SHELL_VAR* get_bash_command ( SHELL_VAR * var )

static

Definition at line 1558 of file variables.c.

References _(), aliases, array_cell, assoc_cell, assoc_create, bash_readline_initialized, bucket_contents::data, debugging_mode, dispose_words(), executable_file(), find_user_command(), free(), FREE, get_group_list(), HASH_ENTRIES, hash_items, hashed_filenames, i, init_bash_argv(), itos(), bucket_contents::key, legal_alias_name(), hash_table::nbuckets, bucket_contents::next, NULL, p, pathdata, perform_hostname_completion, phash_insert(), report_error(), rl_basic_word_break_characters, rl_completer_word_break_characters, savestring(), sh_notfound(), strchr(), the_printed_command_except_trap, value_cell, var_setarray, var_setvalue, variable_context, and xmalloc().

Referenced by initialize_dynamic_variables().

 {
   char *p;
 
   if (the_printed_command_except_trap)
     p = savestring (the_printed_command_except_trap);
   else
     {
       p = (char *)xmalloc (1);
       p[0] = '\0';
     }
   FREE (value_cell (var));
   var_setvalue (var, p);
   return (var);
 }

Here is the caller graph for this function:

◆ get_funcname()

static SHELL_VAR* get_funcname ( SHELL_VAR * self )

static

Definition at line 1834 of file variables.c.

References FREE, variable::name, savestring(), t, this_shell_function, value_cell, var_setvalue, and variable_context.

Referenced by init_funcname_var().

 {
 #if ! defined (ARRAY_VARS)
   char *t;
   if (variable_context && this_shell_function)
     {
       FREE (value_cell (self));
       t = savestring (this_shell_function->name);
       var_setvalue (self, t);
     }
 #endif
   return (self);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_funcname_visible()

void make_funcname_visible ( int on_or_off )

Definition at line 1850 of file variables.c.

References att_invisible, variable::dynamic_value, find_variable(), VSETATTR, and VUNSETATTR.

Referenced by execute_function().

 {
   SHELL_VAR *v;
 
   v = find_variable ("FUNCNAME");
   if (v == 0 || v->dynamic_value == 0)
     return;
 
   if (on_or_off)
     VUNSETATTR (v, att_invisible);
   else
     VSETATTR (v, att_invisible);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_funcname_var()

static SHELL_VAR* init_funcname_var ( )

static

Definition at line 1866 of file variables.c.

References att_invisible, att_noassign, find_variable(), get_funcname(), INIT_DYNAMIC_ARRAY_VAR, INIT_DYNAMIC_VAR, NULL, null_assign(), and VSETATTR.

Referenced by initialize_dynamic_variables().

 {
   SHELL_VAR *v;
 
   v = find_variable ("FUNCNAME");
   if (v)
     return v;
 #if defined (ARRAY_VARS)
   INIT_DYNAMIC_ARRAY_VAR ("FUNCNAME", get_funcname, null_array_assign);
 #else
   INIT_DYNAMIC_VAR ("FUNCNAME", (char *)NULL, get_funcname, null_assign);
 #endif
   VSETATTR (v, att_invisible|att_noassign);
   return v;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initialize_dynamic_variables()

static void initialize_dynamic_variables ( )

static

Definition at line 1883 of file variables.c.

References assign_bash_argv0(), assign_lineno(), assign_random(), assign_subshell(), att_integer, att_noassign, att_nofree, att_nounset, att_regenerate, get_bash_argv0(), get_bash_command(), get_bashpid(), get_epochrealtime(), get_epochseconds(), get_lineno(), get_random(), get_self(), get_subshell(), INIT_DYNAMIC_VAR, init_funcname_var(), init_seconds_var(), NULL, null_assign(), and VSETATTR.

Referenced by initialize_shell_variables().

 {
   SHELL_VAR *v;
 
   v = init_seconds_var ();
 
   INIT_DYNAMIC_VAR ("BASH_ARGV0", (char *)NULL, get_bash_argv0, assign_bash_argv0);
 
   INIT_DYNAMIC_VAR ("BASH_COMMAND", (char *)NULL, get_bash_command, (sh_var_assign_func_t *)NULL);
   INIT_DYNAMIC_VAR ("BASH_SUBSHELL", (char *)NULL, get_subshell, assign_subshell);
 
   INIT_DYNAMIC_VAR ("RANDOM", (char *)NULL, get_random, assign_random);
   VSETATTR (v, att_integer);
   INIT_DYNAMIC_VAR ("LINENO", (char *)NULL, get_lineno, assign_lineno);
   VSETATTR (v, att_integer|att_regenerate);
 
   INIT_DYNAMIC_VAR ("BASHPID", (char *)NULL, get_bashpid, null_assign);
   VSETATTR (v, att_integer);
 
   INIT_DYNAMIC_VAR ("EPOCHSECONDS", (char *)NULL, get_epochseconds, null_assign);
   VSETATTR (v, att_regenerate);
   INIT_DYNAMIC_VAR ("EPOCHREALTIME", (char *)NULL, get_epochrealtime, null_assign);
   VSETATTR (v, att_regenerate);
 
 #if defined (HISTORY)
   INIT_DYNAMIC_VAR ("HISTCMD", (char *)NULL, get_histcmd, (sh_var_assign_func_t *)NULL);
   VSETATTR (v, att_integer);
 #endif
 
 #if defined (READLINE)
   INIT_DYNAMIC_VAR ("COMP_WORDBREAKS", (char *)NULL, get_comp_wordbreaks, assign_comp_wordbreaks);
 #endif
 
 #if defined (PUSHD_AND_POPD) && defined (ARRAY_VARS)
   v = init_dynamic_array_var ("DIRSTACK", get_dirstack, assign_dirstack, 0);
 #endif /* PUSHD_AND_POPD && ARRAY_VARS */
 
 #if defined (ARRAY_VARS)
   v = init_dynamic_array_var ("GROUPS", get_groupset, null_array_assign, att_noassign);
 
 #  if defined (DEBUGGER)
   v = init_dynamic_array_var ("BASH_ARGC", get_bashargcv, null_array_assign, att_noassign|att_nounset);
   v = init_dynamic_array_var ("BASH_ARGV", get_bashargcv, null_array_assign, att_noassign|att_nounset);
 #  endif /* DEBUGGER */
   v = init_dynamic_array_var ("BASH_SOURCE", get_self, null_array_assign, att_noassign|att_nounset);
   v = init_dynamic_array_var ("BASH_LINENO", get_self, null_array_assign, att_noassign|att_nounset);
 
   v = init_dynamic_assoc_var ("BASH_CMDS", get_hashcmd, assign_hashcmd, att_nofree);
 #  if defined (ALIAS)
   v = init_dynamic_assoc_var ("BASH_ALIASES", get_aliasvar, assign_aliasvar, att_nofree);
 #  endif
 #endif
 
   v = init_funcname_var ();
 }

Here is the caller graph for this function:

◆ hash_lookup()

static SHELL_VAR* hash_lookup	(	char *	name,
		HASH_TABLE *	hashed_vars
	)		const

static

Definition at line 1950 of file variables.c.

References bucket_contents::data, hash_search(), and NULL.

Referenced by assign_in_env(), bind_tempenv_variable(), bind_variable(), bind_variable_internal(), find_function(), find_function_def(), find_nameref_at_context(), find_tempenv_variable(), find_variable_internal(), and var_lookup().

 {
   BUCKET_CONTENTS *bucket;
 
   bucket = hash_search (name, hashed_vars, 0);
   /* If we find the name in HASHED_VARS, set LAST_TABLE_SEARCHED to that
      table. */
   if (bucket)
     last_table_searched = hashed_vars;
   return (bucket ? (SHELL_VAR *)bucket->data : (SHELL_VAR *)NULL);
 }

Here is the call graph for this function:

◆ var_lookup()

SHELL_VAR* var_lookup	(	char *	name,
		VAR_CONTEXT *	vcontext
	)		const

Definition at line 1965 of file variables.c.

References var_context::down, hash_lookup(), NULL, and var_context::table.

Referenced by find_global_variable(), find_global_variable_noref(), find_shell_variable(), find_variable_internal(), unbind_nameref(), unbind_variable(), and unbind_variable_noref().

 {
   VAR_CONTEXT *vc;
   SHELL_VAR *v;
 
   v = (SHELL_VAR *)NULL;
   for (vc = vcontext; vc; vc = vc->down)
     if (v = hash_lookup (name, vc->table))
       break;
 
   return v;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_variable_internal()

SHELL_VAR* find_variable_internal	(	char *	name,
		int	flags
	)		const

Definition at line 1988 of file variables.c.

References var_context::down, variable::dynamic_value, expanding_redir, FV_FORCETEMPENV, FV_SKIPINVISIBLE, hash_lookup(), invisible_p, NULL, subshell_environment, var_context::table, and var_lookup().

Referenced by find_variable(), find_variable_for_assignment(), find_variable_last_nameref(), find_variable_nameref(), find_variable_no_invisible(), find_variable_noref(), find_variable_notempenv(), and find_variable_tempenv().

 {
   SHELL_VAR *var;
   int search_tempenv, force_tempenv;
   VAR_CONTEXT *vc;
 
   var = (SHELL_VAR *)NULL;
 
   force_tempenv = (flags & FV_FORCETEMPENV);
 
   /* If explicitly requested, first look in the temporary environment for
      the variable.  This allows constructs such as "foo=x eval 'echo $foo'"
      to get the `exported' value of $foo.  This happens if we are executing
      a function or builtin, or if we are looking up a variable in a
      "subshell environment". */
   search_tempenv = force_tempenv || (expanding_redir == 0 && subshell_environment);
 
   if (search_tempenv && temporary_env)      
     var = hash_lookup (name, temporary_env);
 
   if (var == 0)
     {
       if ((flags & FV_SKIPINVISIBLE) == 0)
     var = var_lookup (name, shell_variables);
       else
     {
       /* essentially var_lookup expanded inline so we can check for
          att_invisible */
       for (vc = shell_variables; vc; vc = vc->down)
         {
           var = hash_lookup (name, vc->table);
           if (var && invisible_p (var))
         var = 0;
           if (var)
         break;
         }
     }
     }
 
   if (var == 0)
     return ((SHELL_VAR *)NULL);
 
   return (var->dynamic_value ? (*(var->dynamic_value)) (var) : var);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_variable_nameref()

SHELL_VAR* find_variable_nameref ( SHELL_VAR * v )

Definition at line 2038 of file variables.c.

References _(), assigning_in_environment, variable::context, executing_builtin, expanding_redir, find_global_variable_noref(), find_variable_internal(), flags, FV_FORCETEMPENV, internal_warning(), variable::name, nameref_cell, NAMEREF_MAX, nameref_p, and variable_context.

Referenced by find_global_variable(), find_shell_variable(), find_variable(), find_variable_for_assignment(), find_variable_no_invisible(), find_variable_notempenv(), find_variable_tempenv(), and unbind_variable().

 {
   int level, flags;
   char *newname;
   SHELL_VAR *orig, *oldv;
 
   level = 0;
   orig = v;
   while (v && nameref_p (v))
     {
       level++;
       if (level > NAMEREF_MAX)
     return ((SHELL_VAR *)0);    /* error message here? */
       newname = nameref_cell (v);
       if (newname == 0 || *newname == '\0')
     return ((SHELL_VAR *)0);
       oldv = v;
       flags = 0;
       if (expanding_redir == 0 && (assigning_in_environment || executing_builtin))
     flags |= FV_FORCETEMPENV;
       /* We don't handle array subscripts here. */
       v = find_variable_internal (newname, flags);
       if (v == orig || v == oldv)
     {
       internal_warning (_("%s: circular name reference"), orig->name);
 #if 1
       /* XXX - provisional change - circular refs go to
          global scope for resolution, without namerefs. */
       if (variable_context && v->context)
         return (find_global_variable_noref (v->name));
       else
 #endif
       return ((SHELL_VAR *)0);
     }
     }
   return v;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_variable_last_nameref()

SHELL_VAR* find_variable_last_nameref	(	char *	name,
		int	vflags
	)		const

Definition at line 2079 of file variables.c.

References assigning_in_environment, executing_builtin, expanding_redir, find_variable_internal(), find_variable_noref(), flags, FV_FORCETEMPENV, invisible_p, nameref_cell, NAMEREF_MAX, and nameref_p.

Referenced by assign_in_env(), bind_variable_internal(), execute_for_command(), find_variable_nameref_for_assignment(), find_variable_nameref_for_create(), nameref_transform_name(), param_expand(), parameter_brace_expand_indir(), parameter_brace_expand_word(), parameter_brace_find_indir(), and redir_varvalue().

 {
   SHELL_VAR *v, *nv;
   char *newname;
   int level, flags;
 
   nv = v = find_variable_noref (name);
   level = 0;
   while (v && nameref_p (v))
     {
       level++;
       if (level > NAMEREF_MAX)
         return ((SHELL_VAR *)0);    /* error message here? */
       newname = nameref_cell (v);
       if (newname == 0 || *newname == '\0')
     return ((vflags && invisible_p (v)) ? v : (SHELL_VAR *)0);
       nv = v;
       flags = 0;
       if (expanding_redir == 0 && (assigning_in_environment || executing_builtin))
     flags |= FV_FORCETEMPENV;
       /* We don't accommodate array subscripts here. */
       v = find_variable_internal (newname, flags);
     }
   return nv;
 }

Here is the call graph for this function:

◆ find_global_variable_last_nameref()

SHELL_VAR* find_global_variable_last_nameref	(	char *	name,
		int	vflags
	)		const

Definition at line 2109 of file variables.c.

References find_global_variable_noref(), invisible_p, nameref_cell, NAMEREF_MAX, and nameref_p.

Referenced by nameref_transform_name().

 {
   SHELL_VAR *v, *nv;
   char *newname;
   int level;
 
   nv = v = find_global_variable_noref (name);
   level = 0;
   while (v && nameref_p (v))
     {
       level++;
       if (level > NAMEREF_MAX)
         return ((SHELL_VAR *)0);    /* error message here? */
       newname = nameref_cell (v);
       if (newname == 0 || *newname == '\0')
     return ((vflags && invisible_p (v)) ? v : (SHELL_VAR *)0);
       nv = v;
       /* We don't accommodate array subscripts here. */
       v = find_global_variable_noref (newname);
     }
   return nv;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_nameref_at_context()

static SHELL_VAR* find_nameref_at_context	(	SHELL_VAR *	v,
		VAR_CONTEXT *	vc
	)

static

Definition at line 2135 of file variables.c.

References hash_lookup(), nameref_cell, NAMEREF_MAX, nameref_p, NULL, and var_context::table.

Referenced by find_variable_last_nameref_context(), and find_variable_nameref_context().

 {
   SHELL_VAR *nv, *nv2;
   char *newname;
   int level;
 
   nv = v;
   level = 1;
   while (nv && nameref_p (nv))
     {
       level++;
       if (level > NAMEREF_MAX)
         return (&nameref_maxloop_value);
       newname = nameref_cell (nv);
       if (newname == 0 || *newname == '\0')
         return ((SHELL_VAR *)NULL);      
       nv2 = hash_lookup (newname, vc->table);
       if (nv2 == 0)
         break;
       nv = nv2;
     }
   return nv;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_variable_nameref_context()

static SHELL_VAR* find_variable_nameref_context	(	SHELL_VAR *	v,
		VAR_CONTEXT *	vc,
		VAR_CONTEXT **	nvcp
	)

static

Definition at line 2167 of file variables.c.

References var_context::down, find_nameref_at_context(), nameref_p, and NULL.

Referenced by bind_variable().

 {
   SHELL_VAR *nv, *nv2;
   VAR_CONTEXT *nvc;
 
   /* Look starting at the current context all the way `up' */
   for (nv = v, nvc = vc; nvc; nvc = nvc->down)
     {
       nv2 = find_nameref_at_context (nv, nvc);
       if (nv2 == &nameref_maxloop_value)
     return (nv2);           /* XXX */
       if (nv2 == 0)
         continue;
       nv = nv2;
       if (*nvcp)
         *nvcp = nvc;
       if (nameref_p (nv) == 0)
         break;
     }
   return (nameref_p (nv) ? (SHELL_VAR *)NULL : nv);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_variable_last_nameref_context()

static SHELL_VAR* find_variable_last_nameref_context	(	SHELL_VAR *	v,
		VAR_CONTEXT *	vc,
		VAR_CONTEXT **	nvcp
	)

static

Definition at line 2198 of file variables.c.

References var_context::down, find_nameref_at_context(), nameref_p, and NULL.

Referenced by bind_variable().

 {
   SHELL_VAR *nv, *nv2;
   VAR_CONTEXT *nvc;
 
   /* Look starting at the current context all the way `up' */
   for (nv = v, nvc = vc; nvc; nvc = nvc->down)
     {
       nv2 = find_nameref_at_context (nv, nvc);
       if (nv2 == &nameref_maxloop_value)
     return (nv2);           /* XXX */
       if (nv2 == 0)
     continue;
       nv = nv2;
       if (*nvcp)
         *nvcp = nvc;
     }
   return (nameref_p (nv) ? nv : (SHELL_VAR *)NULL);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_variable_nameref_for_create()

SHELL_VAR* find_variable_nameref_for_create	(	char *	name,
		int	flags
	)		const

Definition at line 2222 of file variables.c.

References _(), att_nameref, find_variable_last_nameref(), internal_warning(), INVALID_NAMEREF_VALUE, invisible_p, legal_identifier(), nameref_cell, nameref_p, sh_invalidid(), and VUNSETATTR.

Referenced by execute_in_subshell().

 {
   SHELL_VAR *var;
 
   /* See if we have a nameref pointing to a variable that hasn't been
      created yet. */
   var = find_variable_last_nameref (name, 1);
   if ((flags&1) && var && nameref_p (var) && invisible_p (var))
     {
       internal_warning (_("%s: removing nameref attribute"), name);
       VUNSETATTR (var, att_nameref);
     }
   if (var && nameref_p (var))
     {
       if (legal_identifier (nameref_cell (var)) == 0)
     {
       sh_invalidid (nameref_cell (var) ? nameref_cell (var) : "");
       return ((SHELL_VAR *)INVALID_NAMEREF_VALUE);
     }
     }
   return (var);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_variable_nameref_for_assignment()

SHELL_VAR* find_variable_nameref_for_assignment	(	char *	name,
		int	flags
	)		const

Definition at line 2248 of file variables.c.

References _(), att_nameref, find_variable_last_nameref(), internal_warning(), INVALID_NAMEREF_VALUE, invisible_p, nameref_cell, nameref_p, sh_invalidid(), valid_nameref_value(), and VUNSETATTR.

 {
   SHELL_VAR *var;
 
   /* See if we have a nameref pointing to a variable that hasn't been
      created yet. */
   var = find_variable_last_nameref (name, 1);
   if (var && nameref_p (var) && invisible_p (var))  /* XXX - flags */
     {
       internal_warning (_("%s: removing nameref attribute"), name);
       VUNSETATTR (var, att_nameref);
     }
   if (var && nameref_p (var))
     {
       if (valid_nameref_value (nameref_cell (var), 1) == 0)
     {
       sh_invalidid (nameref_cell (var) ? nameref_cell (var) : "");
       return ((SHELL_VAR *)INVALID_NAMEREF_VALUE);
     }
     }
   return (var);
 }

Here is the call graph for this function:

◆ nameref_transform_name()

char* nameref_transform_name	(	char *	name,
		int	flags
	)

Definition at line 2279 of file variables.c.

References ASS_CHKLOCAL, ASS_MKGLOBAL, ASS_MKLOCAL, variable::context, find_global_variable_last_nameref(), find_variable_last_nameref(), nameref_cell, nameref_p, valid_nameref_value(), and variable_context.

Referenced by strip_trailing_ifs_whitespace().

 {
   SHELL_VAR *v;
   char *newname;
 
   v = 0;
   if (flags & ASS_MKLOCAL)
     {
       v = find_variable_last_nameref (name, 1);
       /* If we're making local variables, only follow namerefs that point to
      non-existant variables at the same variable context. */
       if (v && v->context != variable_context)
     v = 0;
     }
   else if (flags & ASS_MKGLOBAL)
     v = (flags & ASS_CHKLOCAL) ? find_variable_last_nameref (name, 1)
                    : find_global_variable_last_nameref (name, 1);
   if (v && nameref_p (v) && valid_nameref_value (nameref_cell (v), 1))
     return nameref_cell (v);
   return name;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_variable_tempenv()

SHELL_VAR* find_variable_tempenv ( char * name ) const

Definition at line 2305 of file variables.c.

References find_variable_internal(), find_variable_nameref(), FV_FORCETEMPENV, and nameref_p.

Referenced by _find_user_command_internal(), and search_for_command().

 {
   SHELL_VAR *var;
 
   var = find_variable_internal (name, FV_FORCETEMPENV);
   if (var && nameref_p (var))
     var = find_variable_nameref (var);
   return (var);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_variable_notempenv()

SHELL_VAR* find_variable_notempenv ( char * name ) const

Definition at line 2318 of file variables.c.

References find_variable_internal(), find_variable_nameref(), and nameref_p.

 {
   SHELL_VAR *var;
 
   var = find_variable_internal (name, 0);
   if (var && nameref_p (var))
     var = find_variable_nameref (var);
   return (var);
 }

Here is the call graph for this function:

◆ find_global_variable()

SHELL_VAR* find_global_variable ( char * name ) const

Definition at line 2330 of file variables.c.

References variable::dynamic_value, find_variable_nameref(), nameref_p, NULL, and var_lookup().

Referenced by bind_variable_internal(), and strip_trailing_ifs_whitespace().

 {
   SHELL_VAR *var;
 
   var = var_lookup (name, global_variables);
   if (var && nameref_p (var))
     var = find_variable_nameref (var);
 
   if (var == 0)
     return ((SHELL_VAR *)NULL);
 
   return (var->dynamic_value ? (*(var->dynamic_value)) (var) : var);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_global_variable_noref()

SHELL_VAR* find_global_variable_noref ( char * name ) const

Definition at line 2346 of file variables.c.

References variable::dynamic_value, NULL, and var_lookup().

Referenced by find_global_variable_last_nameref(), and find_variable_nameref().

 {
   SHELL_VAR *var;
 
   var = var_lookup (name, global_variables);
 
   if (var == 0)
     return ((SHELL_VAR *)NULL);
 
   return (var->dynamic_value ? (*(var->dynamic_value)) (var) : var);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_shell_variable()

SHELL_VAR* find_shell_variable ( char * name ) const

Definition at line 2360 of file variables.c.

References variable::dynamic_value, find_variable_nameref(), nameref_p, NULL, and var_lookup().

 {
   SHELL_VAR *var;
 
   var = var_lookup (name, shell_variables);
   if (var && nameref_p (var))
     var = find_variable_nameref (var);
 
   if (var == 0)
     return ((SHELL_VAR *)NULL);
 
   return (var->dynamic_value ? (*(var->dynamic_value)) (var) : var);
 }

Here is the call graph for this function:

◆ find_variable()

SHELL_VAR* find_variable ( char * name ) const

Definition at line 2377 of file variables.c.

References assigning_in_environment, executing_builtin, expanding_redir, find_variable_internal(), find_variable_nameref(), flags, FV_FORCETEMPENV, and nameref_p.

Referenced by assign_in_env(), bind_int_variable(), check_unbind_variable(), chkexport(), execute_for_command(), execute_function(), execute_in_subshell(), expr_bind_variable(), expr_streval(), get_name_for_error(), get_self(), get_string_value(), get_var_and_type(), init_funcname_var(), init_seconds_var(), initialize_shell_variables(), make_funcname_visible(), make_local_variable(), param_expand(), parameter_brace_expand_length(), parameter_brace_expand_word(), parameter_brace_transform(), printenv_builtin(), read_command(), redir_varvalue(), run_startup_files(), set_home_var(), set_if_not(), set_ppid(), set_pwd(), set_shell_var(), strip_trailing_ifs_whitespace(), strlong(), sv_funcnest(), sv_globignore(), sv_ifs(), sv_ignoreeof(), sv_locale(), sv_optind(), sv_shcompat(), sv_strict_posix(), sv_xtracefd(), uidset(), and unary_test().

 {
   SHELL_VAR *v;
   int flags;
 
   last_table_searched = 0;
   flags = 0;
   if (expanding_redir == 0 && (assigning_in_environment || executing_builtin))
     flags |= FV_FORCETEMPENV;
   v = find_variable_internal (name, flags);
   if (v && nameref_p (v))
     v = find_variable_nameref (v);
   return v;
 }

Here is the call graph for this function:

◆ find_variable_no_invisible()

SHELL_VAR* find_variable_no_invisible ( char * name ) const

Definition at line 2397 of file variables.c.

References assigning_in_environment, executing_builtin, expanding_redir, find_variable_internal(), find_variable_nameref(), flags, FV_FORCETEMPENV, FV_SKIPINVISIBLE, and nameref_p.

 {
   SHELL_VAR *v;
   int flags;
 
   last_table_searched = 0;
   flags = FV_SKIPINVISIBLE;
   if (expanding_redir == 0 && (assigning_in_environment || executing_builtin))
     flags |= FV_FORCETEMPENV;
   v = find_variable_internal (name, flags);
   if (v && nameref_p (v))
     v = find_variable_nameref (v);
   return v;
 }

Here is the call graph for this function:

◆ find_variable_for_assignment()

SHELL_VAR* find_variable_for_assignment ( char * name ) const

Definition at line 2416 of file variables.c.

References assigning_in_environment, executing_builtin, expanding_redir, find_variable_internal(), find_variable_nameref(), flags, FV_FORCETEMPENV, and nameref_p.

 {
   SHELL_VAR *v;
   int flags;
 
   last_table_searched = 0;
   flags = 0;
   if (expanding_redir == 0 && (assigning_in_environment || executing_builtin))
     flags |= FV_FORCETEMPENV;
   v = find_variable_internal (name, flags);
   if (v && nameref_p (v))
     v = find_variable_nameref (v);
   return v;
 }

Here is the call graph for this function:

◆ find_variable_noref()

SHELL_VAR* find_variable_noref ( char * name ) const

Definition at line 2433 of file variables.c.

References assigning_in_environment, executing_builtin, expanding_redir, find_variable_internal(), flags, and FV_FORCETEMPENV.

Referenced by bind_variable_internal(), find_variable_last_nameref(), make_local_variable(), and unary_test().

 {
   SHELL_VAR *v;
   int flags;
 
   flags = 0;
   if (expanding_redir == 0 && (assigning_in_environment || executing_builtin))
     flags |= FV_FORCETEMPENV;
   v = find_variable_internal (name, flags);
   return v;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_function()

SHELL_VAR* find_function ( char * name ) const

Definition at line 2449 of file variables.c.

References hash_lookup().

Referenced by bind_function(), execute_disk_command(), execute_intern_function(), execute_simple_command(), expand_word_list_internal(), initialize_shell_variables(), and set_var_read_only().

 {
   return (hash_lookup (name, shell_functions));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_function_def()

FUNCTION_DEF* find_function_def ( char * name ) const

Definition at line 2458 of file variables.c.

References hash_lookup().

Referenced by bind_function(), and execute_function().

 {
 #if defined (DEBUGGER)
   return ((FUNCTION_DEF *)hash_lookup (name, shell_function_defs));
 #else
   return ((FUNCTION_DEF *)0);
 #endif
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_variable_value()

char* get_variable_value ( SHELL_VAR * var )

Definition at line 2471 of file variables.c.

References array_cell, array_p, assoc_cell, assoc_p, NULL, and value_cell.

Referenced by expr_streval(), get_string_value(), make_variable_value(), redir_varvalue(), and sv_optind().

 {
   if (var == 0)
     return ((char *)NULL);
 #if defined (ARRAY_VARS)
   else if (array_p (var))
     return (array_reference (array_cell (var), 0));
   else if (assoc_p (var))
     return (assoc_reference (assoc_cell (var), "0"));
 #endif
   else
     return (value_cell (var));
 }

Here is the caller graph for this function:

◆ get_string_value()

char* get_string_value ( char * var_name ) const

Definition at line 2492 of file variables.c.

References find_variable(), get_variable_value(), and NULL.

Referenced by adjust_shell_level(), bash_special_tilde_expansions(), check_mail(), current_working_directory(), default_columns(), execute_command_internal(), execute_for_command(), execute_prompt_command(), execute_simple_command(), get_bash_name(), get_locale_var(), get_tmpdir(), indirection_level_string(), job_working_directory(), main(), polite_directory_format(), remember_mail_dates(), run_startup_files(), send_pwd_to_eterm(), set_default_lang(), set_default_locale_vars(), setup_glob_ignore(), setup_ignore_patterns(), sh_get_env_value(), sh_makepath(), strftime(), strlong(), sv_globignore(), sv_locale(), sv_opterr(), sv_shcompat(), time_to_check_mail(), trim_pathname(), user_command_matches(), and yyparse().

 {
   SHELL_VAR *var;
 
   var = find_variable (var_name);
   return ((var) ? get_variable_value (var) : (char *)NULL);
 }

Here is the call graph for this function:

◆ sh_get_env_value()

char* sh_get_env_value ( char * v ) const

Definition at line 2503 of file variables.c.

References get_string_value().

 {
   return get_string_value (v);
 }

Here is the call graph for this function:

◆ var_sametype()

static int var_sametype	(	SHELL_VAR *	v1,
		SHELL_VAR *	v2
	)

static

Definition at line 2516 of file variables.c.

References array_p, and assoc_p.

 {
   if (v1 == 0 || v2 == 0)
     return 0;
 #if defined (ARRAY_VARS)
   else if (assoc_p (v1) && assoc_p (v2))
     return 1;
   else if (array_p (v1) && array_p (v2))
     return 1;
   else if (array_p (v1) || array_p (v2))
     return 0;
   else if (assoc_p (v1) || assoc_p (v2))
     return 0;
 #endif
   else
     return 1;
 }

◆ validate_inherited_value()

int validate_inherited_value	(	SHELL_VAR *	var,
		int	type
	)

Definition at line 2537 of file variables.c.

References array_p, assoc_p, att_array, and att_assoc.

 {
 #if defined (ARRAY_VARS)
   if (type == att_array && assoc_p (var))
     return 0;
   else if (type == att_assoc && array_p (var))
     return 0;
   else
 #endif
   return 1; /* should we run convert_var_to_array here or let the caller? */
 }

◆ set_if_not()

SHELL_VAR* set_if_not	(	char *	name,
		char *	value
	)

Definition at line 2553 of file variables.c.

References bind_variable_internal(), create_variable_tables(), find_variable(), HASH_NOSRCH, and var_context::table.

Referenced by initialize_shell_variables(), and set_machine_vars().

 {
   SHELL_VAR *v;
 
   if (shell_variables == 0)
     create_variable_tables ();
 
   v = find_variable (name);
   if (v == 0)
     v = bind_variable_internal (name, value, global_variables->table, HASH_NOSRCH, 0);
   return (v);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_local_variable()

SHELL_VAR* make_local_variable	(	char *	name,
		int	flags
	)		const

Definition at line 2569 of file variables.c.

References _(), array_cell, array_p, variable::assign_func, assoc_cell, assoc_copy, assoc_p, att_exported, att_invisible, att_local, att_nameref, variable::attributes, builtin_error(), variable::context, var_context::down, variable::dynamic_value, exported_p, find_variable(), find_variable_noref(), var_context::flags, hash_create(), ifsname, internal_error(), local_p, localvar_inherit, make_new_variable(), MKLOC_INHERIT, nameref_p, no_invisible_vars, noassign_p, NULL, readonly_p, savestring(), var_context::scope, setifs(), sh_readonly(), var_context::table, TEMPENV_HASH_BUCKETS, tempvar_p, value_cell, var_setarray, var_setassoc, var_setvalue, variable_context, VC_HASLOCAL, vc_isfuncenv, VSETATTR, and VUNSETATTR.

Referenced by make_new_variable().

 {
   SHELL_VAR *new_var, *old_var, *old_ref;
   VAR_CONTEXT *vc;
   int was_tmpvar;
   char *old_value;
 
   /* We don't want to follow the nameref chain when making local variables; we
      just want to create them. */
   old_ref = find_variable_noref (name);
   if (old_ref && nameref_p (old_ref) == 0)
     old_ref = 0;
   /* local foo; local foo;  is a no-op. */
   old_var = find_variable (name);
   if (old_ref == 0 && old_var && local_p (old_var) && old_var->context == variable_context)
     return (old_var);
 
   /* local -n foo; local -n foo;  is a no-op. */
   if (old_ref && local_p (old_ref) && old_ref->context == variable_context)
     return (old_ref);
 
   /* From here on, we want to use the refvar, not the variable it references */
   if (old_ref)
     old_var = old_ref;
 
   was_tmpvar = old_var && tempvar_p (old_var);
   /* If we're making a local variable in a shell function, the temporary env
      has already been merged into the function's variable context stack.  We
      can assume that a temporary var in the same context appears in the same
      VAR_CONTEXT and can safely be returned without creating a new variable
      (which results in duplicate names in the same VAR_CONTEXT->table */
   /* We can't just test tmpvar_p because variables in the temporary env given
      to a shell function appear in the function's local variable VAR_CONTEXT
      but retain their tempvar attribute.  We want temporary variables that are
      found in temporary_env, hence the test for last_table_searched, which is
      set in hash_lookup and only (so far) checked here. */
   if (was_tmpvar && old_var->context == variable_context && last_table_searched != temporary_env)
     {
       VUNSETATTR (old_var, att_invisible);  /* XXX */
       return (old_var);
     }
 
   /* If we want to change to "inherit the old variable's value" semantics,
      here is where to save the old value. */
   old_value = was_tmpvar ? value_cell (old_var) : (char *)NULL;
 
   for (vc = shell_variables; vc; vc = vc->down)
     if (vc_isfuncenv (vc) && vc->scope == variable_context)
       break;
 
   if (vc == 0)
     {
       internal_error (_("make_local_variable: no function context at current scope"));
       return ((SHELL_VAR *)NULL);
     }
   else if (vc->table == 0)
     vc->table = hash_create (TEMPENV_HASH_BUCKETS);
 
   /* Since this is called only from the local/declare/typeset code, we can
      call builtin_error here without worry (of course, it will also work
      for anything that sets this_command_name).  Variables with the `noassign'
      attribute may not be made local.  The test against old_var's context
      level is to disallow local copies of readonly global variables (since I
      believe that this could be a security hole).  Readonly copies of calling
      function local variables are OK. */
   if (old_var && (noassign_p (old_var) ||
          (readonly_p (old_var) && old_var->context == 0)))
     {
       if (readonly_p (old_var))
     sh_readonly (name);
       else if (noassign_p (old_var))
     builtin_error (_("%s: variable may not be assigned value"), name);
 #if 0
       /* Let noassign variables through with a warning */
       if (readonly_p (old_var))
 #endif
     return ((SHELL_VAR *)NULL);
     }
 
   if (old_var == 0)
     new_var = make_new_variable (name, vc->table);
   else
     {
       new_var = make_new_variable (name, vc->table);
 
       /* If we found this variable in one of the temporary environments,
      inherit its value.  Watch to see if this causes problems with
      things like `x=4 local x'. XXX - see above for temporary env
      variables with the same context level as variable_context */
       /* XXX - we should only do this if the variable is not an array. */
       /* If we want to change the local variable semantics to "inherit
      the old variable's value" here is where to set it.  And we would
      need to use copy_variable (currently unused) to do it for all
      possible variable values. */
       if (was_tmpvar)
     var_setvalue (new_var, savestring (old_value));
       else if (localvar_inherit || (flags & MKLOC_INHERIT))
     {
       /* This may not make sense for nameref variables that are shadowing
          variables with the same name, but we don't know that yet. */
 #if defined (ARRAY_VARS)
       if (assoc_p (old_var))
         var_setassoc (new_var, assoc_copy (assoc_cell (old_var)));
       else if (array_p (old_var))
         var_setarray (new_var, array_copy (array_cell (old_var)));
       else if (value_cell (old_var))
 #else
       if (value_cell (old_var))
 #endif
         var_setvalue (new_var, savestring (value_cell (old_var)));
       else
         var_setvalue (new_var, (char *)NULL);
     }
 
       if (localvar_inherit || (flags & MKLOC_INHERIT))
     {
       /* It doesn't make sense to inherit the nameref attribute */
       new_var->attributes = old_var->attributes & ~att_nameref;
       new_var->dynamic_value = old_var->dynamic_value;
       new_var->assign_func = old_var->assign_func;
     }
       else
     /* We inherit the export attribute, but no others. */
     new_var->attributes = exported_p (old_var) ? att_exported : 0;
     }
 
   vc->flags |= VC_HASLOCAL;
 
   new_var->context = variable_context;
   VSETATTR (new_var, att_local);
 
   if (ifsname (name))
     setifs (new_var);
 
   /* value_cell will be 0 if localvar_inherit == 0 or there was no old variable
      with the same name or the old variable was invisible */
   if (was_tmpvar == 0 && no_invisible_vars == 0 && value_cell (new_var) == 0)
     VSETATTR (new_var, att_invisible);  /* XXX */
   return (new_var);
 }

Here is the caller graph for this function:

◆ new_shell_variable()

static SHELL_VAR* new_shell_variable ( char * name ) const

static

Definition at line 2714 of file variables.c.

References variable::assign_func, variable::attributes, CLEAR_EXPORTSTR, variable::context, variable::dynamic_value, variable::name, NULL, savestring(), var_setvalue, and xmalloc().

Referenced by bind_function(), and make_new_variable().

 {
   SHELL_VAR *entry;
 
   entry = (SHELL_VAR *)xmalloc (sizeof (SHELL_VAR));
 
   entry->name = savestring (name);
   var_setvalue (entry, (char *)NULL);
   CLEAR_EXPORTSTR (entry);
 
   entry->dynamic_value = (sh_var_value_func_t *)NULL;
   entry->assign_func = (sh_var_assign_func_t *)NULL;
 
   entry->attributes = 0;
 
   /* Always assume variables are to be made at toplevel!
      make_local_variable has the responsibility of changing the
      variable context. */
   entry->context = 0;
 
   return (entry);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_new_variable()

static SHELL_VAR* make_new_variable	(	char *	name,
		HASH_TABLE *	table
	)		const

static

Definition at line 2741 of file variables.c.

References array_create(), array_p, assoc_create, assoc_p, att_array, att_assoc, create_variable_tables(), bucket_contents::data, dispose_variable_value(), hash_insert(), HASH_NOSRCH, internal_warning(), localvar_inherit, make_local_variable(), new_shell_variable(), PTR_T, savestring(), var_context::table, var_setarray, var_setassoc, VSETATTR, and VUNSETATTR.

Referenced by assign_in_env(), bind_variable_internal(), and make_local_variable().

 {
   SHELL_VAR *entry;
   BUCKET_CONTENTS *elt;
 
   entry = new_shell_variable (name);
 
   /* Make sure we have a shell_variables hash table to add to. */
   if (shell_variables == 0)
     create_variable_tables ();
 
   elt = hash_insert (savestring (name), table, HASH_NOSRCH);
   elt->data = (PTR_T)entry;
 
   return entry;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_variable_value()

char* make_variable_value	(	SHELL_VAR *	var,
		char *	value,
		int	flags
	)

Definition at line 2869 of file variables.c.

References ASS_APPEND, ASS_NOEVAL, ASS_NOLONGJMP, capcase_p, CASE_CAPITALIZE, CASE_LOWER, CASE_UPPER, DISCARD, evalexp(), free(), get_variable_value(), integer_p, itos(), jump_to_top_level(), lowercase_p, NULL, savestring(), sh_modcase(), strcpy(), STRLEN, top_level_cleanup(), uppercase_p, value_cell, and xmalloc().

Referenced by assign_in_env(), bind_variable_internal(), and bind_variable_value().

 {
   char *retval, *oval;
   intmax_t lval, rval;
   int expok, olen, op;
 
   /* If this variable has had its type set to integer (via `declare -i'),
      then do expression evaluation on it and store the result.  The
      functions in expr.c (evalexp()) and bind_int_variable() are responsible
      for turning off the integer flag if they don't want further
      evaluation done.  Callers that find it inconvenient to do this can set
      the ASS_NOEVAL flag.  For the special case of arithmetic expression
      evaluation, the caller can set ASS_NOLONGJMP to avoid jumping out to
      top_level. */
   if ((flags & ASS_NOEVAL) == 0 && integer_p (var))
     {
       if (flags & ASS_APPEND)
     {
       oval = value_cell (var);
       lval = evalexp (oval, 0, &expok); /* ksh93 seems to do this */
       if (expok == 0)
         {
           if (flags & ASS_NOLONGJMP)
         goto make_value;
           else
         {
           top_level_cleanup ();
           jump_to_top_level (DISCARD);
         }
         }
     }
       rval = evalexp (value, 0, &expok);
       if (expok == 0)
     {
       if (flags & ASS_NOLONGJMP)
         goto make_value;
       else
         {
           top_level_cleanup ();
           jump_to_top_level (DISCARD);
         }
     }
       /* This can be fooled if the variable's value changes while evaluating
      `rval'.  We can change it if we move the evaluation of lval to here. */
       if (flags & ASS_APPEND)
     rval += lval;
       retval = itos (rval);
     }
 #if defined (CASEMOD_ATTRS)
   else if ((flags & ASS_NOEVAL) == 0 && (capcase_p (var) || uppercase_p (var) || lowercase_p (var)))
     {
       if (flags & ASS_APPEND)
     {
       oval = get_variable_value (var);
       if (oval == 0)    /* paranoia */
         oval = "";
       olen = STRLEN (oval);
       retval = (char *)xmalloc (olen + (value ? STRLEN (value) : 0) + 1);
       strcpy (retval, oval);
       if (value)
         strcpy (retval+olen, value);
     }
       else if (*value)
     retval = savestring (value);
       else
     {
       retval = (char *)xmalloc (1);
       retval[0] = '\0';
     }
       op = capcase_p (var) ? CASE_CAPITALIZE
              : (uppercase_p (var) ? CASE_UPPER : CASE_LOWER);
       oval = sh_modcase (retval, (char *)0, op);
       free (retval);
       retval = oval;
     }
 #endif /* CASEMOD_ATTRS */
   else if (value)
     {
 make_value:
       if (flags & ASS_APPEND)
     {
       oval = get_variable_value (var);
       if (oval == 0)    /* paranoia */
         oval = "";
       olen = STRLEN (oval);
       retval = (char *)xmalloc (olen + (value ? STRLEN (value) : 0) + 1);
       strcpy (retval, oval);
       if (value)
         strcpy (retval+olen, value);
     }
       else if (*value)
     retval = savestring (value);
       else
     {
       retval = (char *)xmalloc (1);
       retval[0] = '\0';
     }
     }
   else
     retval = (char *)NULL;
 
   return retval;
 }

Here is the caller graph for this function:

◆ can_optimize_assignment()

static int can_optimize_assignment	(	SHELL_VAR *	entry,
		char *	value,
		int	aflags
	)

static

Definition at line 2978 of file variables.c.

References array_p, ASS_APPEND, assoc_p, capcase_p, integer_p, lowercase_p, noassign_p, readonly_p, and uppercase_p.

Referenced by bind_variable_internal().

 {
   if ((aflags & ASS_APPEND) == 0)
     return 0;
 #if defined (ARRAY_VARS)
   if (array_p (entry) || assoc_p (entry))
     return 0;
 #endif
   if (integer_p (entry) || uppercase_p (entry) || lowercase_p (entry) || capcase_p (entry))
     return 0;
   if (readonly_p (entry) || noassign_p (entry))
     return 0;
   return 1;
 }

Here is the caller graph for this function:

◆ optimized_assignment()

static SHELL_VAR* optimized_assignment	(	SHELL_VAR *	entry,
		char *	value,
		int	aflags
	)

static

Definition at line 2998 of file variables.c.

References strcpy(), STRLEN, value_cell, var_setvalue, and xrealloc().

Referenced by bind_variable_internal().

 {
   size_t len, vlen;
   char *v, *new;
 
   v = value_cell (entry);
   len = STRLEN (v);
   vlen = STRLEN (value);
 
   new = (char *)xrealloc (v, len + vlen + 8);   /* for now */
   if (vlen == 1)
     {
       new[len] = *value;
       new[len+1] = '\0';
     }
   else
     strcpy (new + len, value);
   var_setvalue (entry, new);
   return entry;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bind_variable_internal()

static SHELL_VAR* bind_variable_internal	(	char *	name,
		char *	value,
		HASH_TABLE *	table,
		int	hflags,
		int	aflags
	)		const

static

Definition at line 3026 of file variables.c.

References _(), array_cell, array_needs_making, array_p, ASS_APPEND, ASS_FORCE, ASS_NAMEREF, variable::assign_func, assoc_cell, assoc_p, att_exported, att_invisible, att_nameref, can_optimize_assignment(), err_readonly(), exported_p, find_global_variable(), find_variable_last_nameref(), find_variable_noref(), free(), FREE, hash_lookup(), HASH_NOSRCH, internal_warning(), INVALIDATE_EXPORTSTR, invisible_p, make_new_variable(), make_variable_value(), mark_modified_vars, variable::name, name_cell, nameref_cell, nameref_p, noassign_p, NULL, optimized_assignment(), readonly_p, savestring(), sh_invalidid(), var_context::table, valid_nameref_value(), value_cell, var_setvalue, VSETATTR, and VUNSETATTR.

Referenced by bind_global_variable(), bind_invalid_envvar(), bind_variable(), push_exported_var(), push_posix_temp_var(), push_posix_tempvar_internal(), push_temp_var(), and set_if_not().

 {
   char *newval, *tname;
   SHELL_VAR *entry, *tentry;
 
   entry = (hflags & HASH_NOSRCH) ? (SHELL_VAR *)NULL : hash_lookup (name, table);
   /* Follow the nameref chain here if this is the global variables table */
   if (entry && nameref_p (entry) && (invisible_p (entry) == 0) && table == global_variables->table)
     {
       entry = find_global_variable (entry->name);
       /* Let's see if we have a nameref referencing a variable that hasn't yet
      been created. */
       if (entry == 0)
     entry = find_variable_last_nameref (name, 0);   /* XXX */
       if (entry == 0)                   /* just in case */
         return (entry);
     }
 
   /* The first clause handles `declare -n ref; ref=x;' or `declare -n ref;
      declare -n ref' */
   if (entry && invisible_p (entry) && nameref_p (entry))
     {
       if ((aflags & ASS_FORCE) == 0 && value && valid_nameref_value (value, 0) == 0)
     {
       sh_invalidid (value);
       return ((SHELL_VAR *)NULL);
     }
       goto assign_value;
     }
   else if (entry && nameref_p (entry))
     {
       newval = nameref_cell (entry);    /* XXX - newval can't be NULL here */
       if (valid_nameref_value (newval, 0) == 0)
     {
       sh_invalidid (newval);
       return ((SHELL_VAR *)NULL);
     }
 #if defined (ARRAY_VARS)
       /* declare -n foo=x[2] ; foo=bar */
       if (valid_array_reference (newval, 0))
     {
       tname = array_variable_name (newval, 0, (char **)0, (int *)0);
       if (tname && (tentry = find_variable_noref (tname)) && nameref_p (tentry))
         {
           /* nameref variables can't be arrays */
           internal_warning (_("%s: removing nameref attribute"), name_cell (tentry));
           FREE (value_cell (tentry));       /* XXX - bash-4.3 compat */
           var_setvalue (tentry, (char *)NULL);
           VUNSETATTR (tentry, att_nameref);
         }
       free (tname);
           /* XXX - should it be aflags? */
       entry = assign_array_element (newval, make_variable_value (entry, value, aflags), aflags|ASS_NAMEREF);
       if (entry == 0)
         return entry;
     }
       else
 #endif
     {
       entry = make_new_variable (newval, table);
       var_setvalue (entry, make_variable_value (entry, value, aflags));
     }
     }
   else if (entry == 0)
     {
       entry = make_new_variable (name, table);
       var_setvalue (entry, make_variable_value (entry, value, aflags)); /* XXX */
     }
   else if (entry->assign_func)  /* array vars have assign functions now */
     {
       INVALIDATE_EXPORTSTR (entry);
       newval = (aflags & ASS_APPEND) ? make_variable_value (entry, value, aflags) : value;
       if (assoc_p (entry))
     entry = (*(entry->assign_func)) (entry, newval, -1, savestring ("0"));
       else if (array_p (entry))
     entry = (*(entry->assign_func)) (entry, newval, 0, 0);
       else
     entry = (*(entry->assign_func)) (entry, newval, -1, 0);
       if (newval != value)
     free (newval);
       return (entry);
     }
   else
     {
 assign_value:
       if ((readonly_p (entry) && (aflags & ASS_FORCE) == 0) || noassign_p (entry))
     {
       if (readonly_p (entry))
         err_readonly (name_cell (entry));
       return (entry);
     }
 
       /* Variables which are bound are visible. */
       VUNSETATTR (entry, att_invisible);
 
       /* If we can optimize the assignment, do so and return.  Right now, we
      optimize appends to string variables. */
       if (can_optimize_assignment (entry, value, aflags))
     {
       INVALIDATE_EXPORTSTR (entry);
       optimized_assignment (entry, value, aflags);
 
       if (mark_modified_vars)
         VSETATTR (entry, att_exported);
 
       if (exported_p (entry))
         array_needs_making = 1;
 
       return (entry);
     }
 
 #if defined (ARRAY_VARS)
       if (assoc_p (entry) || array_p (entry))
         newval = make_array_variable_value (entry, 0, "0", value, aflags);
       else
 #endif
       newval = make_variable_value (entry, value, aflags);  /* XXX */
 
       /* Invalidate any cached export string */
       INVALIDATE_EXPORTSTR (entry);
 
 #if defined (ARRAY_VARS)
       /* XXX -- this bears looking at again -- XXX */
       /* If an existing array variable x is being assigned to with x=b or
      `read x' or something of that nature, silently convert it to
      x[0]=b or `read x[0]'. */
       if (assoc_p (entry))
     {
       assoc_insert (assoc_cell (entry), savestring ("0"), newval);
       free (newval);
     }
       else if (array_p (entry))
     {
       array_insert (array_cell (entry), 0, newval);
       free (newval);
     }
       else
 #endif
     {
       FREE (value_cell (entry));
       var_setvalue (entry, newval);
     }
     }
 
   if (mark_modified_vars)
     VSETATTR (entry, att_exported);
 
   if (exported_p (entry))
     array_needs_making = 1;
 
   return (entry);
 }

Here is the caller graph for this function:

◆ bind_variable()

SHELL_VAR* bind_variable	(	char *	name,
		char *	value,
		int	flags
	)		const

Definition at line 3188 of file variables.c.

References _(), ASS_NAMEREF, bind_tempenv_variable(), bind_variable_internal(), bind_variable_value(), create_variable_tables(), var_context::down, find_variable_last_nameref_context(), find_variable_nameref_context(), hash_lookup(), internal_warning(), variable::name, nameref_cell, nameref_p, var_context::table, vc_isbltnenv, and vc_isfuncenv.

Referenced by adjust_shell_level(), bind_int_variable(), bind_lastarg(), check_mail(), do_assignment_internal(), execute_for_command(), execute_in_subshell(), initialize_shell_variables(), main(), parameter_brace_expand_rhs(), run_startup_files(), set_home_var(), set_ppid(), set_pwd(), set_shell_var(), sh_set_lines_and_columns(), strlong(), uidset(), and yyparse().

 {
   SHELL_VAR *v, *nv;
   VAR_CONTEXT *vc, *nvc;
 
   if (shell_variables == 0)
     create_variable_tables ();
 
   /* If we have a temporary environment, look there first for the variable,
      and, if found, modify the value there before modifying it in the
      shell_variables table.  This allows sourced scripts to modify values
      given to them in a temporary environment while modifying the variable
      value that the caller sees. */
   if (temporary_env && value)       /* XXX - can value be null here? */
     bind_tempenv_variable (name, value);
 
   /* XXX -- handle local variables here. */
   for (vc = shell_variables; vc; vc = vc->down)
     {
       if (vc_isfuncenv (vc) || vc_isbltnenv (vc))
     {
       v = hash_lookup (name, vc->table);
       nvc = vc;
       if (v && nameref_p (v))
         {
           nv = find_variable_nameref_context (v, vc, &nvc);
           if (nv == 0)
         {
           nv = find_variable_last_nameref_context (v, vc, &nvc);
           if (nv && nameref_p (nv))
             {
               /* If this nameref variable doesn't have a value yet,
              set the value.  Otherwise, assign using the value as
              normal. */
               if (nameref_cell (nv) == 0)
             return (bind_variable_internal (nv->name, value, nvc->table, 0, flags));
 #if defined (ARRAY_VARS)
               else if (valid_array_reference (nameref_cell (nv), 0))
             return (assign_array_element (nameref_cell (nv), value, flags));
               else
 #endif
               return (bind_variable_internal (nameref_cell (nv), value, nvc->table, 0, flags));
             }
           else if (nv == &nameref_maxloop_value)
             {
               internal_warning (_("%s: circular name reference"), v->name);
 #if 0
               return (bind_variable_value (v, value, flags|ASS_NAMEREF));
 #else
               v = 0;    /* backwards compat */
 #endif
             }
           else
             v = nv;
         }
           else if (nv == &nameref_maxloop_value)
         {
           internal_warning (_("%s: circular name reference"), v->name);
 #if 0
           return (bind_variable_value (v, value, flags|ASS_NAMEREF));
 #else
           v = 0;    /* backwards compat */
 #endif
         }
           else
             v = nv;
         }
       if (v)
         return (bind_variable_internal (v->name, value, nvc->table, 0, flags));
     }
     }
   /* bind_variable_internal will handle nameref resolution in this case */
   return (bind_variable_internal (name, value, global_variables->table, 0, flags));
 }

Here is the call graph for this function:

◆ bind_global_variable()

SHELL_VAR* bind_global_variable	(	char *	name,
		char *	value,
		int	flags
	)		const

Definition at line 3267 of file variables.c.

References bind_variable_internal(), create_variable_tables(), and var_context::table.

 {
   if (shell_variables == 0)
     create_variable_tables ();
 
   /* bind_variable_internal will handle nameref resolution in this case */
   return (bind_variable_internal (name, value, global_variables->table, 0, flags));
 }

Here is the call graph for this function:

◆ bind_invalid_envvar()

static SHELL_VAR* bind_invalid_envvar	(	char *	name,
		char *	value,
		int	flags
	)		const

static

Definition at line 3280 of file variables.c.

References bind_variable_internal(), hash_create(), and HASH_NOSRCH.

Referenced by initialize_shell_variables().

 {
   if (invalid_env == 0)
     invalid_env = hash_create (64); /* XXX */
   return (bind_variable_internal (name, value, invalid_env, HASH_NOSRCH, flags));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bind_variable_value()

SHELL_VAR* bind_variable_value	(	SHELL_VAR *	var,
		char *	value,
		int	aflags
	)

Definition at line 3296 of file variables.c.

References _(), array_needs_making, ASS_APPEND, ASS_FORCE, ASS_NAMEREF, variable::assign_func, att_exported, att_invisible, check_selfref(), exported_p, free(), FREE, internal_error(), internal_warning(), INVALIDATE_EXPORTSTR, invisible_p, make_variable_value(), mark_modified_vars, name_cell, NULL, t, valid_nameref_value(), value_cell, var_setvalue, variable_context, VSETATTR, and VUNSETATTR.

Referenced by bind_variable(), and execute_for_command().

 {
   char *t;
   int invis;
 
   invis = invisible_p (var);
   VUNSETATTR (var, att_invisible);
 
   if (var->assign_func)
     {
       /* If we're appending, we need the old value, so use
      make_variable_value */
       t = (aflags & ASS_APPEND) ? make_variable_value (var, value, aflags) : value;
       (*(var->assign_func)) (var, t, -1, 0);
       if (t != value && t)
     free (t);      
     }
   else
     {
       t = make_variable_value (var, value, aflags);
       if ((aflags & (ASS_NAMEREF|ASS_FORCE)) == ASS_NAMEREF && check_selfref (name_cell (var), t, 0))
     {
       if (variable_context)
         internal_warning (_("%s: circular name reference"), name_cell (var));
       else
         {
           internal_error (_("%s: nameref variable self references not allowed"), name_cell (var));
           free (t);
           if (invis)
         VSETATTR (var, att_invisible);  /* XXX */
           return ((SHELL_VAR *)NULL);
         }
     }
       if ((aflags & ASS_NAMEREF) && (valid_nameref_value (t, 0) == 0))
     {
       free (t);
       if (invis)
         VSETATTR (var, att_invisible);  /* XXX */
       return ((SHELL_VAR *)NULL);
     }
       FREE (value_cell (var));
       var_setvalue (var, t);
     }
 
   INVALIDATE_EXPORTSTR (var);
 
   if (mark_modified_vars)
     VSETATTR (var, att_exported);
 
   if (exported_p (var))
     array_needs_making = 1;
 
   return (var);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bind_int_variable()

SHELL_VAR* bind_int_variable	(	char *	lhs,
		char *	rhs,
		int	flags
	)

Definition at line 3365 of file variables.c.

References _(), array_p, ASS_NOEXPAND, att_integer, att_invisible, bind_variable(), find_variable(), integer_p, internal_warning(), legal_identifier(), nameref_p, NULL, sh_invalidid(), VSETATTR, and VUNSETATTR.

Referenced by bind_var_to_int(), and expr_bind_variable().

 {
   register SHELL_VAR *v;
   int isint, isarr, implicitarray;
 
   isint = isarr = implicitarray = 0;
 #if defined (ARRAY_VARS)
   if (valid_array_reference (lhs, (flags & ASS_NOEXPAND) != 0))
     {
       isarr = 1;
       v = array_variable_part (lhs, (flags & ASS_NOEXPAND) != 0, (char **)0, (int *)0);
     }
   else if (legal_identifier (lhs) == 0)
     {
       sh_invalidid (lhs);
       return ((SHELL_VAR *)NULL);      
     }
   else
 #endif
     v = find_variable (lhs);
 
   if (v)
     {
       isint = integer_p (v);
       VUNSETATTR (v, att_integer);
 #if defined (ARRAY_VARS)
       if (array_p (v) && isarr == 0)
     implicitarray = 1;
 #endif
     }
 
 #if defined (ARRAY_VARS)
   if (isarr)
     v = assign_array_element (lhs, rhs, flags);
   else if (implicitarray)
     v = bind_array_variable (lhs, 0, rhs, 0);   /* XXX - check on flags */
   else
 #endif
     v = bind_variable (lhs, rhs, 0);    /* why not use bind_variable_value? */
 
   if (v)
     {
       if (isint)
     VSETATTR (v, att_integer);
       VUNSETATTR (v, att_invisible);
     }
 
   if (v && nameref_p (v))
     internal_warning (_("%s: assigning integer to name reference"), lhs);
      
   return (v);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bind_var_to_int()

SHELL_VAR* bind_var_to_int	(	char *	var,
		intmax_t	val
	)

Definition at line 3421 of file variables.c.

References bind_int_variable(), fmtulong(), INT_STRLEN_BOUND, and p.

Referenced by redir_varassign().

 {
   char ibuf[INT_STRLEN_BOUND (intmax_t) + 1], *p;
 
   p = fmtulong (val, 10, ibuf, sizeof (ibuf), 0);
   return (bind_int_variable (var, p, 0));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bind_function()

SHELL_VAR* bind_function	(	char *	name,
		COMMAND *	value
	)		const

Definition at line 3434 of file variables.c.

References array_needs_making, att_exported, att_function, att_invisible, function_def::command, copy_command(), copy_function_def(), copy_function_def_contents(), bucket_contents::data, dispose_command(), dispose_function_def_contents(), exported_p, find_function(), find_function_def(), flags, function_cell, hash_insert(), HASH_NOSRCH, INVALIDATE_EXPORTSTR, it_functions, mark_modified_vars, new_shell_variable(), PTR_T, savestring(), var_isset, var_setfunc, VSETATTR, and VUNSETATTR.

Referenced by execute_intern_function().

 {
   SHELL_VAR *entry;
 
   entry = find_function (name);
   if (entry == 0)
     {
       BUCKET_CONTENTS *elt;
 
       elt = hash_insert (savestring (name), shell_functions, HASH_NOSRCH);
       entry = new_shell_variable (name);
       elt->data = (PTR_T)entry;
     }
   else
     INVALIDATE_EXPORTSTR (entry);
 
   if (var_isset (entry))
     dispose_command (function_cell (entry));
 
   if (value)
     var_setfunc (entry, copy_command (value));
   else
     var_setfunc (entry, 0);
 
   VSETATTR (entry, att_function);
 
   if (mark_modified_vars)
     VSETATTR (entry, att_exported);
 
   VUNSETATTR (entry, att_invisible);        /* Just to be sure */
 
   if (exported_p (entry))
     array_needs_making = 1;
 
 #if defined (PROGRAMMABLE_COMPLETION)
   set_itemlist_dirty (&it_functions);
 #endif
 
   return (entry);
 }

Here is the caller graph for this function:

◆ assign_in_env()

int assign_in_env	(	WORD_DESC *	word,
		int	flags
	)

Definition at line 3518 of file variables.c.

References array_cell, array_needs_making, array_p, ASS_APPEND, variable::assign_func, assignment(), assoc_cell, assoc_copy, assoc_p, att_exported, att_tempvar, variable::attributes, variable::context, copy_command(), COPY_EXPORTSTR, variable::dynamic_value, echo_command_at_execute, err_readonly(), expand_assignment_string_to_string(), variable::exportstr, find_variable(), find_variable_last_nameref(), free(), FREE, function_cell, function_p, hash_create(), hash_lookup(), INVALIDATE_EXPORTSTR, legal_identifier(), make_new_variable(), make_variable_value(), mk_env_string(), variable::name, name_cell, nameref_cell, nameref_p, noassign_p, NULL, readonly_p, savestring(), sh_invalidid(), string, stupidly_hack_special_variables(), temp, TEMPENV_HASH_BUCKETS, valid_nameref_value(), value_cell, var_setarray, var_setassoc, var_setfunc, var_setref, var_setvalue, variable_context, word_desc::word, xmalloc(), and xtrace_print_assignment().

Referenced by expand_word_list_internal().

 {
   int offset, aflags;
   char *name, *temp, *value, *newname;
   SHELL_VAR *var;
   const char *string;
 
   string = word->word;
 
   aflags = 0;
   offset = assignment (string, 0);
   newname = name = savestring (string);
   value = (char *)NULL;
 
   if (name[offset] == '=')
     {
       name[offset] = 0;
 
       /* don't ignore the `+' when assigning temporary environment */
       if (name[offset - 1] == '+')
     {
       name[offset - 1] = '\0';
       aflags |= ASS_APPEND;
     }
 
       if (legal_identifier (name) == 0)
     {
       sh_invalidid (name);
       return (0);
     }
   
       var = find_variable (name);
       if (var == 0)
     {
       var = find_variable_last_nameref (name, 1);
       /* If we're assigning a value to a nameref variable in the temp
          environment, and the value of the nameref is valid for assignment,
          but the variable does not already exist, assign to the nameref
          target and add the target to the temporary environment.  This is
          what ksh93 does */
       if (var && nameref_p (var) && valid_nameref_value (nameref_cell (var), 1))
         {
           newname = nameref_cell (var);
           var = 0;      /* don't use it for append */
         }
     }
       else
         newname = name_cell (var);  /* no-op if not nameref */
       
       if (var && (readonly_p (var) || noassign_p (var)))
     {
       if (readonly_p (var))
         err_readonly (name);
       free (name);
       return (0);
     }
       temp = name + offset + 1;
 
       value = expand_assignment_string_to_string (temp, 0);
 
       if (var && (aflags & ASS_APPEND))
     {
       if (value == 0)
         {
           value = (char *)xmalloc (1);  /* like do_assignment_internal */
           value[0] = '\0';
         }
       temp = make_variable_value (var, value, aflags);
       FREE (value);
       value = temp;
     }
     }
 
   if (temporary_env == 0)
     temporary_env = hash_create (TEMPENV_HASH_BUCKETS);
 
   var = hash_lookup (newname, temporary_env);
   if (var == 0)
     var = make_new_variable (newname, temporary_env);
   else
     FREE (value_cell (var));
 
   if (value == 0)
     {
       value = (char *)xmalloc (1);  /* see above */
       value[0] = '\0';
     }
 
   var_setvalue (var, value);
   var->attributes |= (att_exported|att_tempvar);
   var->context = variable_context;  /* XXX */
 
   INVALIDATE_EXPORTSTR (var);
   var->exportstr = mk_env_string (newname, value, 0);
 
   array_needs_making = 1;
 
   if (flags)
     stupidly_hack_special_variables (newname);
 
   if (echo_command_at_execute)
     /* The Korn shell prints the `+ ' in front of assignment statements,
     so we do too. */
     xtrace_print_assignment (name, value, 0, 1);
 
   free (name);
   return 1;
 }

Here is the caller graph for this function:

◆ dispose_variable_value()

static void dispose_variable_value ( SHELL_VAR * var )

static

Definition at line 3684 of file variables.c.

References array_cell, array_p, assoc_cell, assoc_p, dispose_command(), FREE, function_cell, function_p, nameref_cell, nameref_p, and value_cell.

Referenced by dispose_variable(), and make_new_variable().

 {
   if (function_p (var))
     dispose_command (function_cell (var));
 #if defined (ARRAY_VARS)
   else if (array_p (var))
     array_dispose (array_cell (var));
   else if (assoc_p (var))
     assoc_dispose (assoc_cell (var));
 #endif
   else if (nameref_p (var))
     FREE (nameref_cell (var));
   else
     FREE (value_cell (var));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dispose_variable()

void dispose_variable ( SHELL_VAR * var )

Definition at line 3702 of file variables.c.

References array_needs_making, dispose_variable_value(), exported_p, free(), FREE_EXPORTSTR, variable::name, and nofree_p.

Referenced by delete_var(), execute_for_command(), free_variable_hash_data(), makunbound(), propagate_temp_var(), push_exported_var(), push_posix_temp_var(), push_posix_tempvar_internal(), push_temp_var(), and unbind_func().

 {
   if (var == 0)
     return;
 
   if (nofree_p (var) == 0)
     dispose_variable_value (var);
 
   FREE_EXPORTSTR (var);
 
   free (var->name);
 
   if (exported_p (var))
     array_needs_making = 1;
 
   free (var);
 }

Here is the call graph for this function:

◆ unbind_variable()

int unbind_variable ( char * name ) const

Definition at line 3724 of file variables.c.

References find_variable_nameref(), makunbound(), variable::name, nameref_p, NULL, and var_lookup().

Referenced by check_mail(), check_unbind_variable(), enable_mypid_builtin_unload(), execute_for_command(), execute_in_subshell(), main(), and stat_builtin().

 {
   SHELL_VAR *v, *nv;
   int r;
 
   v = var_lookup (name, shell_variables);
   nv = (v && nameref_p (v)) ? find_variable_nameref (v) : (SHELL_VAR *)NULL;
 
   r = nv ? makunbound (nv->name, shell_variables) : makunbound (name, shell_variables);
   return r;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unbind_nameref()

int unbind_nameref ( char * name ) const

Definition at line 3739 of file variables.c.

References makunbound(), nameref_p, and var_lookup().

 {
   SHELL_VAR *v;
 
   v = var_lookup (name, shell_variables);
   if (v && nameref_p (v))
     return makunbound (name, shell_variables);
   return 0;
 }

Here is the call graph for this function:

◆ unbind_variable_noref()

int unbind_variable_noref ( char * name ) const

Definition at line 3752 of file variables.c.

References makunbound(), and var_lookup().

Referenced by execute_in_subshell(), and uidset().

 {
   SHELL_VAR *v;
 
   v = var_lookup (name, shell_variables);
   if (v)
     return makunbound (name, shell_variables);
   return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_unbind_variable()

int check_unbind_variable ( char * name ) const

Definition at line 3764 of file variables.c.

References _(), find_variable(), internal_error(), readonly_p, and unbind_variable().

Referenced by execute_in_subshell().

 {
   SHELL_VAR *v;
 
   v = find_variable (name);
   if (v && readonly_p (v))
     {
       internal_error (_("%s: cannot unset: readonly %s"), name, "variable");
       return -1;
     }
   return (unbind_variable (name));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unbind_func()

int unbind_func ( char * name ) const

Definition at line 3780 of file variables.c.

References array_needs_making, bucket_contents::data, dispose_function_def(), dispose_variable(), exported_p, free(), hash_remove(), if(), it_functions, and bucket_contents::key.

 {
   BUCKET_CONTENTS *elt;
   SHELL_VAR *func;
 
   elt = hash_remove (name, shell_functions, 0);
 
   if (elt == 0)
     return -1;
 
 #if defined (PROGRAMMABLE_COMPLETION)
   set_itemlist_dirty (&it_functions);
 #endif
 
   func = (SHELL_VAR *)elt->data;
   if (func)
     {
       if (exported_p (func))
     array_needs_making++;
       dispose_variable (func);
     }
 
   free (elt->key);
   free (elt);
 
   return 0;  
 }

Here is the call graph for this function:

◆ delete_var()

int delete_var	(	char *	name,
		VAR_CONTEXT *	vc
	)		const

Definition at line 3834 of file variables.c.

References bucket_contents::data, dispose_variable(), var_context::down, free(), hash_remove(), bucket_contents::key, NULL, and var_context::table.

 {
   BUCKET_CONTENTS *elt;
   SHELL_VAR *old_var;
   VAR_CONTEXT *v;
 
   for (elt = (BUCKET_CONTENTS *)NULL, v = vc; v; v = v->down)
     if (elt = hash_remove (name, v->table, 0))
       break;
 
   if (elt == 0)
     return (-1);
 
   old_var = (SHELL_VAR *)elt->data;
   free (elt->key);
   free (elt);
 
   dispose_variable (old_var);
   return (0);
 }

Here is the call graph for this function:

◆ makunbound()

int makunbound	(	char *	name,
		VAR_CONTEXT *	vc
	)		const

Definition at line 3862 of file variables.c.

References array_cell, array_needs_making, array_p, assoc_cell, assoc_p, att_exported, att_invisible, att_local, variable::attributes, variable::context, bucket_contents::data, dispose_variable(), var_context::down, exported_p, free(), FREE, hash_insert(), hash_remove(), if(), INVALIDATE_EXPORTSTR, bucket_contents::key, local_p, localvar_unset, variable::name, nameref_cell, nameref_p, nofree_p, NULL, PTR_T, savestring(), stupidly_hack_special_variables(), t, var_context::table, tempvar_p, value_cell, var_setvalue, variable_context, and VSETATTR.

Referenced by unbind_nameref(), unbind_variable(), and unbind_variable_noref().

 {
   BUCKET_CONTENTS *elt, *new_elt;
   SHELL_VAR *old_var;
   VAR_CONTEXT *v;
   char *t;
 
   for (elt = (BUCKET_CONTENTS *)NULL, v = vc; v; v = v->down)
     if (elt = hash_remove (name, v->table, 0))
       break;
 
   if (elt == 0)
     return (-1);
 
   old_var = (SHELL_VAR *)elt->data;
 
   if (old_var && exported_p (old_var))
     array_needs_making++;
 
   /* If we're unsetting a local variable and we're still executing inside
      the function, just mark the variable as invisible.  The function
      eventually called by pop_var_context() will clean it up later.  This
      must be done so that if the variable is subsequently assigned a new
      value inside the function, the `local' attribute is still present.
      We also need to add it back into the correct hash table. */
   if (old_var && local_p (old_var) &&
     (old_var->context == variable_context || (localvar_unset && old_var->context < variable_context)))
     {
       if (nofree_p (old_var))
     var_setvalue (old_var, (char *)NULL);
 #if defined (ARRAY_VARS)
       else if (array_p (old_var))
     array_dispose (array_cell (old_var));
       else if (assoc_p (old_var))
     assoc_dispose (assoc_cell (old_var));
 #endif
       else if (nameref_p (old_var))
     FREE (nameref_cell (old_var));
       else
     FREE (value_cell (old_var));
       /* Reset the attributes.  Preserve the export attribute if the variable
      came from a temporary environment.  Make sure it stays local, and
      make it invisible. */ 
       old_var->attributes = (exported_p (old_var) && tempvar_p (old_var)) ? att_exported : 0;
       VSETATTR (old_var, att_local);
       VSETATTR (old_var, att_invisible);
       var_setvalue (old_var, (char *)NULL);
       INVALIDATE_EXPORTSTR (old_var);
 
       new_elt = hash_insert (savestring (old_var->name), v->table, 0);
       new_elt->data = (PTR_T)old_var;
       stupidly_hack_special_variables (old_var->name);
 
       free (elt->key);
       free (elt);
       return (0);
     }
 
   /* Have to save a copy of name here, because it might refer to
      old_var->name.  If so, stupidly_hack_special_variables will
      reference freed memory. */
   t = savestring (name);
 
   free (elt->key);
   free (elt);
 
   dispose_variable (old_var);
   stupidly_hack_special_variables (t);
   free (t);
 
   return (0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ kill_all_local_variables()

void kill_all_local_variables ( )

Definition at line 3939 of file variables.c.

References delete_all_variables(), var_context::down, hash_dispose(), NULL, var_context::scope, var_context::table, variable_context, vc_haslocals, and vc_isfuncenv.

 {
   VAR_CONTEXT *vc;
 
   for (vc = shell_variables; vc; vc = vc->down)
     if (vc_isfuncenv (vc) && vc->scope == variable_context)
       break;
   if (vc == 0)
     return;     /* XXX */
 
   if (vc->table && vc_haslocals (vc))
     {
       delete_all_variables (vc->table);
       hash_dispose (vc->table);
     }
   vc->table = (HASH_TABLE *)NULL;
 }

Here is the call graph for this function:

◆ free_variable_hash_data()

static void free_variable_hash_data ( char * data )

static

Definition at line 3958 of file variables.c.

References dispose_variable().

Referenced by delete_all_variables(), and flush_temporary_env().

 {
   SHELL_VAR *var;
 
   var = (SHELL_VAR *)data;
   dispose_variable (var);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ delete_all_variables()

void delete_all_variables ( HASH_TABLE * hashed_vars )

Definition at line 3969 of file variables.c.

References free_variable_hash_data(), and hash_flush().

Referenced by delete_all_contexts(), dispose_var_context(), kill_all_local_variables(), and shell_reinitialize().

 {
   hash_flush (hashed_vars, free_variable_hash_data);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_var_read_only()

void set_var_read_only ( char * name )

Definition at line 3996 of file variables.c.

References att_readonly, find_function(), FIND_OR_MAKE_VARIABLE, set_auto_export, and VSETATTR.

Referenced by run_startup_files().

 {
   SHELL_VAR *entry;
 
   FIND_OR_MAKE_VARIABLE (name, entry);
   VSETATTR (entry, att_readonly);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vlist_alloc()

static VARLIST* vlist_alloc ( int nentries )

static

Definition at line 4051 of file variables.c.

References _vlist::list, _vlist::list_len, _vlist::list_size, NULL, and xmalloc().

Referenced by all_local_variables(), map_over(), map_over_funcs(), and vlist_realloc().

 {
   VARLIST  *vlist;
 
   vlist = (VARLIST *)xmalloc (sizeof (VARLIST));
   vlist->list = (SHELL_VAR **)xmalloc ((nentries + 1) * sizeof (SHELL_VAR *));
   vlist->list_size = nentries;
   vlist->list_len = 0;
   vlist->list[0] = (SHELL_VAR *)NULL;
 
   return vlist;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vlist_realloc()

static VARLIST* vlist_realloc	(	VARLIST *	vlist,
		int	n
	)

static

Definition at line 4066 of file variables.c.

References _vlist::list, _vlist::list_size, n, vlist_alloc(), and xrealloc().

Referenced by vlist_add().

 {
   if (vlist == 0)
     return (vlist = vlist_alloc (n));
   if (n > vlist->list_size)
     {
       vlist->list_size = n;
       vlist->list = (SHELL_VAR **)xrealloc (vlist->list, (vlist->list_size + 1) * sizeof (SHELL_VAR *));
     }
   return vlist;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vlist_add()

static void vlist_add	(	VARLIST *	vlist,
		SHELL_VAR *	var,
		int	flags
	)

static

Definition at line 4081 of file variables.c.

References i, _vlist::list, _vlist::list_len, _vlist::list_size, variable::name, NULL, STREQ, and vlist_realloc().

Referenced by flatten().

 {
   register int i;
 
   for (i = 0; i < vlist->list_len; i++)
     if (STREQ (var->name, vlist->list[i]->name))
       break;
   if (i < vlist->list_len)
     return;
 
   if (i >= vlist->list_size)
     vlist = vlist_realloc (vlist, vlist->list_size + 16);
 
   vlist->list[vlist->list_len++] = var;
   vlist->list[vlist->list_len] = (SHELL_VAR *)NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ map_over()

SHELL_VAR** map_over	(	sh_var_map_func_t *	function,
		VAR_CONTEXT *	vc
	)

Definition at line 4105 of file variables.c.

References var_context::down, flatten(), free(), HASH_ENTRIES, _vlist::list, NULL, var_context::table, and vlist_alloc().

Referenced by make_var_export_array(), and vapply().

 {
   VAR_CONTEXT *v;
   VARLIST *vlist;
   SHELL_VAR **ret;
   int nentries;
 
   for (nentries = 0, v = vc; v; v = v->down)
     nentries += HASH_ENTRIES (v->table);
 
   if (nentries == 0)
     return (SHELL_VAR **)NULL;
 
   vlist = vlist_alloc (nentries);
 
   for (v = vc; v; v = v->down)
     flatten (v->table, function, vlist, 0);
 
   ret = vlist->list;
   free (vlist);
   return ret;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ map_over_funcs()

SHELL_VAR** map_over_funcs ( sh_var_map_func_t * function )

Definition at line 4131 of file variables.c.

References flatten(), free(), HASH_ENTRIES, _vlist::list, NULL, and vlist_alloc().

Referenced by fapply(), and make_func_export_array().

 {
   VARLIST *vlist;
   SHELL_VAR **ret;
 
   if (shell_functions == 0 || HASH_ENTRIES (shell_functions) == 0)
     return ((SHELL_VAR **)NULL);
 
   vlist = vlist_alloc (HASH_ENTRIES (shell_functions));
 
   flatten (shell_functions, function, vlist, 0);
 
   ret = vlist->list;
   free (vlist);
   return ret;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flatten()

static void flatten	(	HASH_TABLE *	var_hash_table,
		sh_var_map_func_t *	func,
		VARLIST *	vlist,
		int	flags
	)

static

Definition at line 4156 of file variables.c.

References bucket_contents::data, HASH_ENTRIES, hash_items, i, hash_table::nbuckets, bucket_contents::next, and vlist_add().

Referenced by all_local_variables(), map_over(), map_over_funcs(), and push_var_context().

 {
   register int i;
   register BUCKET_CONTENTS *tlist;
   int r;
   SHELL_VAR *var;
 
   if (var_hash_table == 0 || (HASH_ENTRIES (var_hash_table) == 0) || (vlist == 0 && func == 0))
     return;
 
   for (i = 0; i < var_hash_table->nbuckets; i++)
     {
       for (tlist = hash_items (i, var_hash_table); tlist; tlist = tlist->next)
     {
       var = (SHELL_VAR *)tlist->data;
 
       r = func ? (*func) (var) : 1;
       if (r && vlist)
         vlist_add (vlist, var, flags);
     }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sort_variables()

void sort_variables ( SHELL_VAR ** array )

Definition at line 4184 of file variables.c.

References qsort(), qsort_var_comp(), and strvec_len().

Referenced by all_local_variables(), fapply(), and vapply().

 {
   qsort (array, strvec_len ((char **)array), sizeof (SHELL_VAR *), (QSFUNC *)qsort_var_comp);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ qsort_var_comp()

static int qsort_var_comp	(	SHELL_VAR **	var1,
		SHELL_VAR **	var2
	)

static

Definition at line 4191 of file variables.c.

Referenced by sort_variables().

 {
   int result;
 
   if ((result = (*var1)->name[0] - (*var2)->name[0]) == 0)
     result = strcmp ((*var1)->name, (*var2)->name);
 
   return (result);
 }

Here is the caller graph for this function:

◆ vapply()

static SHELL_VAR** vapply ( sh_var_map_func_t * func )

static

Definition at line 4205 of file variables.c.

References list, map_over(), and sort_variables().

Referenced by all_exported_variables(), all_local_variables(), all_shell_variables(), all_visible_variables(), and local_exported_variables().

 {
   SHELL_VAR **list;
 
   list = map_over (func, shell_variables);
   if (list /* && posixly_correct */)
     sort_variables (list);
   return (list);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fapply()

static SHELL_VAR** fapply ( sh_var_map_func_t * func )

static

Definition at line 4219 of file variables.c.

References list, map_over_funcs(), and sort_variables().

Referenced by all_shell_functions(), and all_visible_functions().

 {
   SHELL_VAR **list;
 
   list = map_over_funcs (func);
   if (list /* && posixly_correct */)
     sort_variables (list);
   return (list);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ all_shell_variables()

SHELL_VAR** all_shell_variables ( )

Definition at line 4232 of file variables.c.

References NULL, and vapply().

 {
   return (vapply ((sh_var_map_func_t *)NULL));
 }

Here is the call graph for this function:

◆ all_shell_functions()

SHELL_VAR** all_shell_functions ( )

Definition at line 4239 of file variables.c.

References fapply(), and NULL.

 {
   return (fapply ((sh_var_map_func_t *)NULL));
 }

Here is the call graph for this function:

◆ visible_var()

static int visible_var ( SHELL_VAR * var )

static

Definition at line 4245 of file variables.c.

References invisible_p.

Referenced by all_visible_functions(), and all_visible_variables().

 {
   return (invisible_p (var) == 0);
 }

Here is the caller graph for this function:

◆ all_visible_functions()

SHELL_VAR** all_visible_functions ( )

Definition at line 4252 of file variables.c.

References fapply(), and visible_var().

 {
   return (fapply (visible_var));
 }

Here is the call graph for this function:

◆ all_visible_variables()

SHELL_VAR** all_visible_variables ( )

Definition at line 4258 of file variables.c.

References vapply(), and visible_var().

Referenced by all_variables_matching_prefix().

 {
   return (vapply (visible_var));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ visible_and_exported()

static int visible_and_exported ( SHELL_VAR * var )

static

Definition at line 4266 of file variables.c.

References exported_p, and invisible_p.

Referenced by all_exported_variables(), make_func_export_array(), and make_var_export_array().

 {
   return (invisible_p (var) == 0 && exported_p (var));
 }

Here is the caller graph for this function:

◆ export_environment_candidate()

static int export_environment_candidate ( SHELL_VAR * var )

static

Definition at line 4276 of file variables.c.

References exported_p, imported_p, and invisible_p.

Referenced by make_var_export_array().

 {
   return (exported_p (var) && (invisible_p (var) == 0 || imported_p (var)));
 }

Here is the caller graph for this function:

◆ local_and_exported()

static int local_and_exported ( SHELL_VAR * var )

static

Definition at line 4285 of file variables.c.

References variable::context, exported_p, invisible_p, local_p, and variable_context.

Referenced by local_exported_variables().

 {
   return (invisible_p (var) == 0 && local_p (var) && var->context == variable_context && exported_p (var));
 }

Here is the caller graph for this function:

◆ all_exported_variables()

SHELL_VAR** all_exported_variables ( )

Definition at line 4292 of file variables.c.

References vapply(), and visible_and_exported().

 {
   return (vapply (visible_and_exported));
 }

Here is the call graph for this function:

◆ local_exported_variables()

SHELL_VAR** local_exported_variables ( )

Definition at line 4298 of file variables.c.

References local_and_exported(), and vapply().

 {
   return (vapply (local_and_exported));
 }

Here is the call graph for this function:

◆ variable_in_context()

static int variable_in_context ( SHELL_VAR * var )

static

Definition at line 4304 of file variables.c.

References variable::context, invisible_p, local_p, and variable_context.

Referenced by all_local_variables().

 {
   return (invisible_p (var) == 0 && local_p (var) && var->context == variable_context);
 }

Here is the caller graph for this function:

◆ all_local_variables()

SHELL_VAR** all_local_variables ( )

Definition at line 4311 of file variables.c.

References _(), array_p, assoc_p, var_context::down, flatten(), free(), HASH_ENTRIES, internal_error(), invisible_p, _vlist::list, NULL, var_context::scope, shell_variables, sort_variables(), var_context::table, vapply(), variable_context, variable_in_context(), vc_haslocals, vc_isfuncenv, and vlist_alloc().

 {
   VARLIST *vlist;
   SHELL_VAR **ret;
   VAR_CONTEXT *vc;
 
   vc = shell_variables;
   for (vc = shell_variables; vc; vc = vc->down)
     if (vc_isfuncenv (vc) && vc->scope == variable_context)
       break;
 
   if (vc == 0)
     {
       internal_error (_("all_local_variables: no function context at current scope"));
       return (SHELL_VAR **)NULL;
     }
   if (vc->table == 0 || HASH_ENTRIES (vc->table) == 0 || vc_haslocals (vc) == 0)
     return (SHELL_VAR **)NULL;
     
   vlist = vlist_alloc (HASH_ENTRIES (vc->table));
 
   flatten (vc->table, variable_in_context, vlist, 0);
 
   ret = vlist->list;
   free (vlist);
   if (ret)
     sort_variables (ret);
   return ret;
 }

Here is the call graph for this function:

◆ all_variables_matching_prefix()

char** all_variables_matching_prefix ( char * prefix ) const

Definition at line 4358 of file variables.c.

References all_visible_variables(), free(), NULL, savestring(), STREQN, STRLEN, and strvec_create().

Referenced by parameter_brace_expand().

 {
   SHELL_VAR **varlist;
   char **rlist;
   int vind, rind, plen;
 
   plen = STRLEN (prefix);
   varlist = all_visible_variables ();
   for (vind = 0; varlist && varlist[vind]; vind++)
     ;
   if (varlist == 0 || vind == 0)
     return ((char **)NULL);
   rlist = strvec_create (vind + 1);
   for (vind = rind = 0; varlist[vind]; vind++)
     {
       if (plen == 0 || STREQN (prefix, varlist[vind]->name, plen))
     rlist[rind++] = savestring (varlist[vind]->name);
     }
   rlist[rind] = (char *)0;
   free (varlist);
 
   return rlist;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bind_tempenv_variable()

static SHELL_VAR* bind_tempenv_variable	(	char *	name,
		char *	value
	)		const

static

Definition at line 4391 of file variables.c.

References FREE, hash_lookup(), INVALIDATE_EXPORTSTR, NULL, savestring(), value_cell, and var_setvalue.

Referenced by bind_variable().

 {
   SHELL_VAR *var;
 
   var = temporary_env ? hash_lookup (name, temporary_env) : (SHELL_VAR *)NULL;
 
   if (var)
     {
       FREE (value_cell (var));
       var_setvalue (var, savestring (value));
       INVALIDATE_EXPORTSTR (var);
     }
 
   return (var);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_tempenv_variable()

SHELL_VAR* find_tempenv_variable ( char * name ) const

Definition at line 4412 of file variables.c.

References hash_lookup(), and NULL.

 {
   return (temporary_env ? hash_lookup (name, temporary_env) : (SHELL_VAR *)NULL);
 }

Here is the call graph for this function:

◆ push_posix_temp_var()

static void push_posix_temp_var ( char * data )

static

Definition at line 4426 of file variables.c.

References ASS_FORCE, ASS_NOLONGJMP, att_propagate, att_tempvar, variable::attributes, bind_variable_internal(), dispose_variable(), find_special_var(), hash_create(), variable::name, savestring(), var_context::table, value_cell, and VARIABLES_HASH_BUCKETS.

Referenced by merge_temporary_env().

 {
   SHELL_VAR *var, *v;
   HASH_TABLE *binding_table;
 
   var = (SHELL_VAR *)data;
 
   binding_table = global_variables->table;
   if (binding_table == 0)
     binding_table = global_variables->table = hash_create (VARIABLES_HASH_BUCKETS);
 
   v = bind_variable_internal (var->name, value_cell (var), binding_table, 0, ASS_FORCE|ASS_NOLONGJMP);
 
   /* global variables are no longer temporary and don't need propagating. */
   var->attributes &= ~(att_tempvar|att_propagate);
   if (v)
     v->attributes |= var->attributes;
 
   if (find_special_var (var->name) >= 0)
     tempvar_list[tvlist_ind++] = savestring (var->name);
 
   dispose_variable (var);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ push_temp_var()

static void push_temp_var ( char * data )

static

Definition at line 4462 of file variables.c.

References ASS_FORCE, ASS_NOLONGJMP, att_propagate, att_tempvar, variable::attributes, bind_variable_internal(), variable::context, dispose_variable(), find_special_var(), var_context::flags, hash_create(), variable::name, savestring(), var_context::scope, var_context::table, TEMPENV_HASH_BUCKETS, value_cell, VARIABLES_HASH_BUCKETS, and VC_HASTMPVAR.

Referenced by merge_temporary_env(), and propagate_temp_var().

 {
   SHELL_VAR *var, *v;
   HASH_TABLE *binding_table;
 
   var = (SHELL_VAR *)data;
 
   binding_table = shell_variables->table;
   if (binding_table == 0)
     {
       if (shell_variables == global_variables)
     /* shouldn't happen */
     binding_table = shell_variables->table = global_variables->table = hash_create (VARIABLES_HASH_BUCKETS);
       else
     binding_table = shell_variables->table = hash_create (TEMPENV_HASH_BUCKETS);
     }
 
   v = bind_variable_internal (var->name, value_cell (var), binding_table, 0, ASS_FORCE|ASS_NOLONGJMP);
 
   /* XXX - should we set the context here?  It shouldn't matter because of how
      assign_in_env works, but we do it anyway. */
   if (v)
     v->context = shell_variables->scope;
 
   if (binding_table == global_variables->table)     /* XXX */
     var->attributes &= ~(att_tempvar|att_propagate);
   else
     {
       var->attributes |= att_propagate;
       if  (binding_table == shell_variables->table)
     shell_variables->flags |= VC_HASTMPVAR;
     }
   if (v)
     v->attributes |= var->attributes;
 
   if (find_special_var (var->name) >= 0)
     tempvar_list[tvlist_ind++] = savestring (var->name);
 
   dispose_variable (var);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ propagate_temp_var()

static void propagate_temp_var ( char * data )

static

Definition at line 4509 of file variables.c.

References att_propagate, variable::attributes, dispose_variable(), find_special_var(), variable::name, push_temp_var(), savestring(), and tempvar_p.

Referenced by dispose_used_env_vars().

 {
   SHELL_VAR *var;
 
   var = (SHELL_VAR *)data;
   if (tempvar_p (var) && (var->attributes & att_propagate))
     push_temp_var (data);
   else
     {
       if (find_special_var (var->name) >= 0)
     tempvar_list[tvlist_ind++] = savestring (var->name);
       dispose_variable (var);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dispose_temporary_env()

static void dispose_temporary_env ( sh_free_func_t * pushf )

static

Definition at line 4533 of file variables.c.

References array_needs_making, hash_dispose(), HASH_ENTRIES, hash_flush(), i, NULL, strvec_create(), strvec_dispose(), stupidly_hack_special_variables(), and tvlist_ind.

Referenced by dispose_used_env_vars(), and merge_temporary_env().

 {
   int i;
 
   tempvar_list = strvec_create (HASH_ENTRIES (temporary_env) + 1);
   tempvar_list[tvlist_ind = 0] = 0;
     
   hash_flush (temporary_env, pushf);
   hash_dispose (temporary_env);
   temporary_env = (HASH_TABLE *)NULL;
 
   tempvar_list[tvlist_ind] = 0;
 
   array_needs_making = 1;
 
   for (i = 0; i < tvlist_ind; i++)
     stupidly_hack_special_variables (tempvar_list[i]);
 
   strvec_dispose (tempvar_list);
   tempvar_list = 0;
   tvlist_ind = 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dispose_used_env_vars()

void dispose_used_env_vars ( )

Definition at line 4558 of file variables.c.

References dispose_temporary_env(), maybe_make_export_env(), and propagate_temp_var().

Referenced by execute_command_internal(), and reader_loop().

 {
   if (temporary_env)
     {
       dispose_temporary_env (propagate_temp_var);
       maybe_make_export_env ();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ merge_temporary_env()

void merge_temporary_env ( )

Definition at line 4573 of file variables.c.

References dispose_temporary_env(), posixly_correct, push_posix_temp_var(), and push_temp_var().

Referenced by execute_builtin(), execute_simple_command(), and push_var_context().

 {
   if (temporary_env)
     dispose_temporary_env (posixly_correct ? push_posix_temp_var : push_temp_var);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flush_temporary_env()

void flush_temporary_env ( )

Definition at line 4580 of file variables.c.

References free_variable_hash_data(), hash_dispose(), hash_flush(), and NULL.

Referenced by command_substitute(), and parameter_brace_remove_pattern().

 {
   if (temporary_env)
     {
       hash_flush (temporary_env, free_variable_hash_data);
       hash_dispose (temporary_env);
       temporary_env = (HASH_TABLE *)NULL;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mk_env_string()

static char* mk_env_string	(	char *	name,
		char *	value,
		int	isfunc
	)		const

inlinestatic

Definition at line 4597 of file variables.c.

References _(), BASHFUNC_PREFIX, BASHFUNC_PREFLEN, BASHFUNC_SUFFIX, BASHFUNC_SUFFLEN, dequote_escapes(), variable::exportstr, free(), internal_error(), legal_variable_char, legal_variable_starter, p, STRLEN, t, and xmalloc().

Referenced by assign_in_env(), and make_env_array_from_var_list().

 {
   size_t name_len, value_len;
   char  *p, *q, *t;
 
   name_len = strlen (name);
   value_len = STRLEN (value);
 
   /* If we are exporting a shell function, construct the encoded function
      name. */
   if (isfunc && value)
     {
       p = (char *)xmalloc (BASHFUNC_PREFLEN + name_len + BASHFUNC_SUFFLEN + value_len + 2);
       q = p;
       memcpy (q, BASHFUNC_PREFIX, BASHFUNC_PREFLEN);
       q += BASHFUNC_PREFLEN;
       memcpy (q, name, name_len);
       q += name_len;
       memcpy (q, BASHFUNC_SUFFIX, BASHFUNC_SUFFLEN);
       q += BASHFUNC_SUFFLEN;
     }
   else
     {
       p = (char *)xmalloc (2 + name_len + value_len);
       memcpy (p, name, name_len);
       q = p + name_len;
     }
 
   q[0] = '=';
   if (value && *value)
     {
       if (isfunc)
     {
       t = dequote_escapes (value);
       value_len = STRLEN (t);
       memcpy (q + 1, t, value_len + 1);
       free (t);
     }
       else
     memcpy (q + 1, value, value_len + 1);
     }
   else
     q[1] = '\0';
 
   return (p);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_env_array_from_var_list()

static char** make_env_array_from_var_list ( SHELL_VAR ** vars )

static

Definition at line 4685 of file variables.c.

References array_cell, array_p, assoc_cell, assoc_p, variable::dynamic_value, variable::exportstr, free(), function_cell, function_p, i, INVALIDATE_EXPORTSTR, list, mk_env_string(), variable::name, named_function_string(), NULL, regen_p, SAVE_EXPORTSTR, savestring(), strvec_create(), strvec_len(), USE_EXPORTSTR, and value_cell.

Referenced by make_func_export_array(), and make_var_export_array().

 {
   register int i, list_index;
   register SHELL_VAR *var;
   char **list, *value;
 
   list = strvec_create ((1 + strvec_len ((char **)vars)));
 
 #define USE_EXPORTSTR (value == var->exportstr)
 
   for (i = 0, list_index = 0; var = vars[i]; i++)
     {
 #if defined (__CYGWIN__)
       /* We don't use the exportstr stuff on Cygwin at all. */
       INVALIDATE_EXPORTSTR (var);
 #endif
 
       /* If the value is generated dynamically, generate it here. */
       if (regen_p (var) && var->dynamic_value)
     {
       var = (*(var->dynamic_value)) (var);
       INVALIDATE_EXPORTSTR (var);
     }
 
       if (var->exportstr)
     value = var->exportstr;
       else if (function_p (var))
     value = named_function_string ((char *)NULL, function_cell (var), 0);
 #if defined (ARRAY_VARS)
       else if (array_p (var))
 #  if ARRAY_EXPORT
     value = array_to_assign (array_cell (var), 0);
 #  else
     continue;   /* XXX array vars cannot yet be exported */
 #  endif /* ARRAY_EXPORT */
       else if (assoc_p (var))
 #  if 0
     value = assoc_to_assign (assoc_cell (var), 0);
 #  else
     continue;   /* XXX associative array vars cannot yet be exported */
 #  endif
 #endif
       else
     value = value_cell (var);
 
       if (value)
     {
       /* Gee, I'd like to get away with not using savestring() if we're
          using the cached exportstr... */
       list[list_index] = USE_EXPORTSTR ? savestring (value)
                        : mk_env_string (var->name, value, function_p (var));
 
       if (USE_EXPORTSTR == 0)
         SAVE_EXPORTSTR (var, list[list_index]);
 
       list_index++;
 #undef USE_EXPORTSTR
 
 #if 0   /* not yet */
 #if defined (ARRAY_VARS)
       if (array_p (var) || assoc_p (var))
         free (value);
 #endif
 #endif
     }
     }
 
   list[list_index] = (char *)NULL;
   return (list);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_var_export_array()

static char** make_var_export_array ( VAR_CONTEXT * vcxt )

static

Definition at line 4761 of file variables.c.

References export_environment_candidate(), free(), list, make_env_array_from_var_list(), map_over(), NULL, and visible_and_exported().

Referenced by maybe_make_export_env().

 {
   char **list;
   SHELL_VAR **vars;
 
 #if 0
   vars = map_over (visible_and_exported, vcxt);
 #else
   vars = map_over (export_environment_candidate, vcxt);
 #endif
 
   if (vars == 0)
     return (char **)NULL;
 
   list = make_env_array_from_var_list (vars);
 
   free (vars);
   return (list);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_func_export_array()

static char** make_func_export_array ( )

static

Definition at line 4783 of file variables.c.

References free(), list, make_env_array_from_var_list(), map_over_funcs(), NULL, and visible_and_exported().

Referenced by maybe_make_export_env().

 {
   char **list;
   SHELL_VAR **vars;
 
   vars = map_over_funcs (visible_and_exported);
   if (vars == 0)
     return (char **)NULL;
 
   list = make_env_array_from_var_list (vars);
 
   free (vars);
   return (list);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_or_supercede_exported_var()

char** add_or_supercede_exported_var	(	char *	assign,
		int	do_alloc
	)

Definition at line 4815 of file variables.c.

References add_to_export_env, assignment(), export_env, export_env_index, free(), i, savestring(), and STREQN.

Referenced by add_temp_array_to_env(), and update_export_env_inplace().

 {
   register int i;
   int equal_offset;
 
   equal_offset = assignment (assign, 0);
   if (equal_offset == 0)
     return (export_env);
 
   /* If this is a function, then only supersede the function definition.
      We do this by including the `=() {' in the comparison, like
      initialize_shell_variables does. */
   if (assign[equal_offset + 1] == '(' &&
      strncmp (assign + equal_offset + 2, ") {", 3) == 0)        /* } */
     equal_offset += 4;
 
   for (i = 0; i < export_env_index; i++)
     {
       if (STREQN (assign, export_env[i], equal_offset + 1))
     {
       free (export_env[i]);
       export_env[i] = do_alloc ? savestring (assign) : assign;
       return (export_env);
     }
     }
   add_to_export_env (assign, do_alloc);
   return (export_env);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_temp_array_to_env()

static void add_temp_array_to_env	(	char **	temp_array,
		int	do_alloc,
		int	do_supercede
	)

static

Definition at line 4847 of file variables.c.

References add_or_supercede_exported_var(), add_to_export_env, export_env, free(), and i.

Referenced by maybe_make_export_env().

 {
   register int i;
 
   if (temp_array == 0)
     return;
 
   for (i = 0; temp_array[i]; i++)
     {
       if (do_supercede)
     export_env = add_or_supercede_exported_var (temp_array[i], do_alloc);
       else
     add_to_export_env (temp_array[i], do_alloc);
     }
 
   free (temp_array);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ n_shell_variables()

static int n_shell_variables ( )

static

Definition at line 4884 of file variables.c.

References var_context::down, HASH_ENTRIES, n, and var_context::table.

Referenced by maybe_make_export_env().

 {
   VAR_CONTEXT *vc;
   int n;
 
   for (n = 0, vc = shell_variables; vc; vc = vc->down)
     n += HASH_ENTRIES (vc->table);
   return n;
 }

Here is the caller graph for this function:

◆ chkexport()

int chkexport ( char * name )

Definition at line 4895 of file variables.c.

References array_needs_making, exported_p, find_variable(), and maybe_make_export_env().

Referenced by sv_globignore().

 {
   SHELL_VAR *v;
 
   v = find_variable (name);
   if (v && exported_p (v))
     {
       array_needs_making = 1;
       maybe_make_export_env ();
       return 1;
     }
   return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ maybe_make_export_env()

void maybe_make_export_env ( )

Definition at line 4911 of file variables.c.

References add_temp_array_to_env(), array_needs_making, var_context::down, environ, export_env, export_env_index, export_env_size, free(), HASH_ENTRIES, invalid_env, make_func_export_array(), make_var_export_array(), n_shell_variables(), new_var_context(), NULL, shell_variables, strvec_flush(), strvec_resize(), var_context::table, and temporary_env.

Referenced by chkexport(), command_substitute(), dispose_used_env_vars(), execute_disk_command(), execute_simple_command(), execute_subshell_builtin_or_function(), printenv_builtin(), reset_locale_vars(), and sv_globignore().

 {
   register char **temp_array;
   int new_size;
   VAR_CONTEXT *tcxt, *icxt;
 
   if (array_needs_making)
     {
       if (export_env)
     strvec_flush (export_env);
 
       /* Make a guess based on how many shell variables and functions we
      have.  Since there will always be array variables, and array
      variables are not (yet) exported, this will always be big enough
      for the exported variables and functions. */
       new_size = n_shell_variables () + HASH_ENTRIES (shell_functions) + 1 +
          HASH_ENTRIES (temporary_env) + HASH_ENTRIES (invalid_env);
       if (new_size > export_env_size)
     {
       export_env_size = new_size;
       export_env = strvec_resize (export_env, export_env_size);
       environ = export_env;
     }
       export_env[export_env_index = 0] = (char *)NULL;
 
       /* Make a dummy variable context from the temporary_env, stick it on
      the front of shell_variables, call make_var_export_array on the
      whole thing to flatten it, and convert the list of SHELL_VAR *s
      to the form needed by the environment. */
       if (temporary_env)
     {
       tcxt = new_var_context ((char *)NULL, 0);
       tcxt->table = temporary_env;
       tcxt->down = shell_variables;
     }
       else
     tcxt = shell_variables;
 
       if (invalid_env)
     {
       icxt = new_var_context ((char *)NULL, 0);
       icxt->table = invalid_env;
       icxt->down = tcxt;
     }
       else
     icxt = tcxt;
       
       temp_array = make_var_export_array (icxt);
       if (temp_array)
     add_temp_array_to_env (temp_array, 0, 0);
 
       if (icxt != tcxt)
     free (icxt);
 
       if (tcxt != shell_variables)
     free (tcxt);
 
 #if defined (RESTRICTED_SHELL)
       /* Restricted shells may not export shell functions. */
       temp_array = restricted ? (char **)0 : make_func_export_array ();
 #else
       temp_array = make_func_export_array ();
 #endif
       if (temp_array)
     add_temp_array_to_env (temp_array, 0, 0);
 
       array_needs_making = 0;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_export_env_inplace()

void update_export_env_inplace	(	char *	env_prefix,
		int	preflen,
		char *	value
	)

Definition at line 4991 of file variables.c.

References add_or_supercede_exported_var(), export_env, strcpy(), STRLEN, and xmalloc().

Referenced by put_command_name_into_env().

 {
   char *evar;
 
   evar = (char *)xmalloc (STRLEN (value) + preflen + 1);
   strcpy (evar, env_prefix);
   if (value)
     strcpy (evar + preflen, value);
   export_env = add_or_supercede_exported_var (evar, 0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ put_command_name_into_env()

void put_command_name_into_env ( char * command_name )

Definition at line 5007 of file variables.c.

References update_export_env_inplace().

Referenced by execute_disk_command().

 {
   update_export_env_inplace ("_=", 2, command_name);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ new_var_context()

VAR_CONTEXT* new_var_context	(	char *	name,
		int	flags
	)

Definition at line 5023 of file variables.c.

References var_context::down, var_context::flags, flags, var_context::name, NULL, savestring(), var_context::scope, var_context::table, var_context::up, variable_context, and xmalloc().

Referenced by create_variable_tables(), maybe_make_export_env(), and push_var_context().

 {
   VAR_CONTEXT *vc;
 
   vc = (VAR_CONTEXT *)xmalloc (sizeof (VAR_CONTEXT));
   vc->name = name ? savestring (name) : (char *)NULL;
   vc->scope = variable_context;
   vc->flags = flags;
 
   vc->up = vc->down = (VAR_CONTEXT *)NULL;
   vc->table = (HASH_TABLE *)NULL;
 
   return vc;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dispose_var_context()

void dispose_var_context ( VAR_CONTEXT * vc )

Definition at line 5043 of file variables.c.

References delete_all_variables(), free(), FREE, hash_dispose(), var_context::name, and var_context::table.

Referenced by delete_all_contexts(), and pop_var_context().

 {
   FREE (vc->name);
 
   if (vc->table)
     {
       delete_all_variables (vc->table);
       hash_dispose (vc->table);
     }
 
   free (vc);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_context()

static int set_context ( SHELL_VAR * var )

static

Definition at line 5059 of file variables.c.

References variable::context, and variable_context.

Referenced by push_var_context().

 {
   return (var->context = variable_context);
 }

Here is the caller graph for this function:

◆ push_var_context()

VAR_CONTEXT* push_var_context	(	char *	name,
		int	flags,
		HASH_TABLE *	tempvars
	)

Definition at line 5069 of file variables.c.

References var_context::down, var_context::flags, flatten(), merge_temporary_env(), new_var_context(), NULL, posixly_correct, set_context(), shell_variables, var_context::table, var_context::up, VC_FUNCENV, and VC_HASTMPVAR.

Referenced by push_context(), and push_scope().

 {
   VAR_CONTEXT *vc;
   int posix_func_behavior;
 
   /* As of IEEE Std 1003.1-2017, assignment statements preceding shell
      functions no longer behave like assignment statements preceding
      special builtins, and do not persist in the current shell environment.
      This is austin group interp #654, though nobody implements it yet. */
 #if 0   /* XXX - TAG: bash-5.1 */
   posix_func_behavior = 0;
 #else
   posix_func_behavior = posixly_correct;
 #endif
 
   vc = new_var_context (name, flags);
   /* Posix interp 1009, temporary assignments preceding function calls modify
      the current environment *before* the command is executed. */
   if (posix_func_behavior && (flags & VC_FUNCENV) && tempvars == temporary_env)
     merge_temporary_env ();
   else if (tempvars)
     {
       vc->table = tempvars;
       /* Have to do this because the temp environment was created before
      variable_context was incremented. */
       flatten (tempvars, set_context, (VARLIST *)NULL, 0);
       vc->flags |= VC_HASTMPVAR;
     }
   vc->down = shell_variables;
   shell_variables->up = vc;
 
   return (shell_variables = vc);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ push_posix_tempvar_internal()

static void push_posix_tempvar_internal	(	SHELL_VAR *	var,
		int	isbltin
	)

inlinestatic

Definition at line 5119 of file variables.c.

References array_cell, array_p, assoc_cell, assoc_copy, assoc_p, att_propagate, att_tempvar, variable::attributes, bind_variable_internal(), variable::context, dispose_variable(), var_context::flags, FREE, hash_create(), local_p, variable::name, posixly_correct, var_context::scope, STREQ, stupidly_hack_special_variables(), var_context::table, tempvar_p, value_cell, var_setarray, var_setassoc, VARIABLES_HASH_BUCKETS, VC_HASTMPVAR, vc_isfuncenv, and vc_istempenv.

Referenced by push_builtin_var(), and push_func_var().

 {
   SHELL_VAR *v;
   int posix_var_behavior;
 
   /* As of IEEE Std 1003.1-2017, assignment statements preceding shell
      functions no longer behave like assignment statements preceding
      special builtins, and do not persist in the current shell environment.
      This is austin group interp #654, though nobody implements it yet. */
 #if 0   /* XXX - TAG: bash-5.1 */
   posix_var_behavior = posixly_correct && isbltin;
 #else
   posix_var_behavior = posixly_correct;
 #endif
 
   if (local_p (var) && STREQ (var->name, "-"))
     set_current_options (value_cell (var));
   else if (tempvar_p (var) && (posix_var_behavior || (var->attributes & att_propagate)))
     {
       /* Make sure we have a hash table to store the variable in while it is
      being propagated down to the global variables table.  Create one if
      we have to */
       if ((vc_isfuncenv (shell_variables) || vc_istempenv (shell_variables)) && shell_variables->table == 0)
     shell_variables->table = hash_create (VARIABLES_HASH_BUCKETS);
       v = bind_variable_internal (var->name, value_cell (var), shell_variables->table, 0, 0);
       /* XXX - should we set v->context here? */
       if (v)
     v->context = shell_variables->scope;
 #if defined (ARRAY_VARS)
       if (v && (array_p (var) || assoc_p (var)))
     {
       FREE (value_cell (v));
       if (array_p (var))
         var_setarray (v, array_copy (array_cell (var)));
       else
         var_setassoc (v, assoc_copy (assoc_cell (var)));
     }
 #endif    
       if (shell_variables == global_variables)
     var->attributes &= ~(att_tempvar|att_propagate);
       else
     shell_variables->flags |= VC_HASTMPVAR;
       if (v)
     v->attributes |= var->attributes;
     }
   else
     stupidly_hack_special_variables (var->name);    /* XXX */
 
   dispose_variable (var);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ push_func_var()

static void push_func_var ( char * data )

static

Definition at line 5173 of file variables.c.

References push_posix_tempvar_internal().

Referenced by pop_var_context().

 {
   SHELL_VAR *var;
 
   var = (SHELL_VAR *)data;
   push_posix_tempvar_internal (var, 0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ push_builtin_var()

static void push_builtin_var ( char * data )

static

Definition at line 5183 of file variables.c.

References push_posix_tempvar_internal().

Referenced by pop_scope().

 {
   SHELL_VAR *var;
 
   var = (SHELL_VAR *)data;
   push_posix_tempvar_internal (var, 1);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pop_var_context()

void pop_var_context ( )

Definition at line 5195 of file variables.c.

References _(), dispose_var_context(), var_context::down, hash_flush(), internal_error(), NULL, push_func_var(), shell_variables, var_context::table, var_context::up, and vc_isfuncenv.

Referenced by pop_context().

 {
   VAR_CONTEXT *ret, *vcxt;
 
   vcxt = shell_variables;
   if (vc_isfuncenv (vcxt) == 0)
     {
       internal_error (_("pop_var_context: head of shell_variables not a function context"));
       return;
     }
 
   if (ret = vcxt->down)
     {
       ret->up = (VAR_CONTEXT *)NULL;
       shell_variables = ret;
       if (vcxt->table)
     hash_flush (vcxt->table, push_func_var);
       dispose_var_context (vcxt);
     }
   else
     internal_error (_("pop_var_context: no global_variables context"));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ delete_all_contexts()

void delete_all_contexts ( VAR_CONTEXT * vcxt )

Definition at line 5221 of file variables.c.

References delete_all_variables(), dispose_var_context(), var_context::down, global_variables, t, and var_context::table.

Referenced by shell_reinitialize().

 {
   VAR_CONTEXT *v, *t;
 
   for (v = vcxt; v != global_variables; v = t)
     {
       t = v->down;
       dispose_var_context (v);
     }    
 
   delete_all_variables (global_variables->table);
   shell_variables = global_variables;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ push_scope()

VAR_CONTEXT* push_scope	(	int	flags,
		HASH_TABLE *	tmpvars
	)

Definition at line 5243 of file variables.c.

References NULL, and push_var_context().

Referenced by execute_builtin().

 {
   return (push_var_context ((char *)NULL, flags, tmpvars));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ push_exported_var()

static void push_exported_var ( char * data )

static

Definition at line 5251 of file variables.c.

References att_propagate, att_tempvar, variable::attributes, bind_variable_internal(), variable::context, dispose_variable(), exported_p, variable::name, var_context::scope, stupidly_hack_special_variables(), var_context::table, tempvar_p, and value_cell.

Referenced by pop_scope().

 {
   SHELL_VAR *var, *v;
 
   var = (SHELL_VAR *)data;
 
   /* If a temp var had its export attribute set, or it's marked to be
      propagated, bind it in the previous scope before disposing it. */
   /* XXX - This isn't exactly right, because all tempenv variables have the
     export attribute set. */
   if (tempvar_p (var) && exported_p (var) && (var->attributes & att_propagate))
     {
       var->attributes &= ~att_tempvar;      /* XXX */
       v = bind_variable_internal (var->name, value_cell (var), shell_variables->table, 0, 0);
       if (shell_variables == global_variables)
     var->attributes &= ~att_propagate;
       if (v)
     {
       v->attributes |= var->attributes;
       v->context = shell_variables->scope;
     }
     }
   else
     stupidly_hack_special_variables (var->name);    /* XXX */
 
   dispose_variable (var);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pop_scope()

void pop_scope ( int is_special )

Definition at line 5286 of file variables.c.

References _(), var_context::down, free(), FREE, hash_dispose(), hash_flush(), internal_error(), var_context::name, NULL, push_builtin_var(), push_exported_var(), shell_variables, sv_ifs(), var_context::table, var_context::up, vc_isbltnenv, and vc_istempscope.

Referenced by execute_builtin().

 {
   VAR_CONTEXT *vcxt, *ret;
   int is_bltinenv;
 
   vcxt = shell_variables;
   if (vc_istempscope (vcxt) == 0)
     {
       internal_error (_("pop_scope: head of shell_variables not a temporary environment scope"));
       return;
     }
   is_bltinenv = vc_isbltnenv (vcxt);    /* XXX - for later */
 
   ret = vcxt->down;
   if (ret)
     ret->up = (VAR_CONTEXT *)NULL;
 
   shell_variables = ret;
 
   /* Now we can take care of merging variables in VCXT into set of scopes
      whose head is RET (shell_variables). */
   FREE (vcxt->name);
   if (vcxt->table)
     {
       if (is_special)
     hash_flush (vcxt->table, push_builtin_var);
       else
     hash_flush (vcxt->table, push_exported_var);
       hash_dispose (vcxt->table);
     }
   free (vcxt);
 
   sv_ifs ("IFS");   /* XXX here for now */
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ save_dollar_vars()

static char** save_dollar_vars ( )

static

Definition at line 5340 of file variables.c.

References dollar_vars, i, NULL, and strvec_create().

Referenced by push_dollar_vars().

 {
   char **ret;
   int i;
 
   ret = strvec_create (10);
   for (i = 1; i < 10; i++)
     {
       ret[i] = dollar_vars[i];
       dollar_vars[i] = (char *)NULL;
     }
   return ret;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ restore_dollar_vars()

static void restore_dollar_vars ( char ** args )

static

Definition at line 5355 of file variables.c.

References dollar_vars, and i.

Referenced by pop_dollar_vars().

 {
   int i;
 
   for (i = 1; i < 10; i++)
     dollar_vars[i] = args[i];
 }

Here is the caller graph for this function:

◆ free_dollar_vars()

static void free_dollar_vars ( )

static

Definition at line 5365 of file variables.c.

References dollar_vars, FREE, i, and NULL.

Referenced by pop_dollar_vars().

 {
   int i;
 
   for (i = 1; i < 10; i++)
     {
       FREE (dollar_vars[i]);
       dollar_vars[i] = (char *)NULL;
     }
 }

Here is the caller graph for this function:

◆ free_saved_dollar_vars()

static void free_saved_dollar_vars ( char ** args )

static

Definition at line 5377 of file variables.c.

References FREE, and i.

Referenced by dispose_saved_dollar_vars().

 {
   int i;
 
   for (i = 1; i < 10; i++)
     FREE (args[i]);
 }

Here is the caller graph for this function:

◆ push_context()

void push_context	(	char *	name,
		int	is_subshell,
		HASH_TABLE *	tempvars
	)

Definition at line 5388 of file variables.c.

References push_dollar_vars(), push_var_context(), variable_context, and VC_FUNCENV.

Referenced by execute_function().

 {
   if (is_subshell == 0)
     push_dollar_vars ();
   variable_context++;
   push_var_context (name, VC_FUNCENV, tempvars);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pop_context()

void pop_context ( )

Definition at line 5402 of file variables.c.

References pop_dollar_vars(), pop_var_context(), sv_ifs(), and variable_context.

Referenced by execute_function().

 {
   pop_dollar_vars ();
   variable_context--;
   pop_var_context ();
 
   sv_ifs ("IFS");       /* XXX here for now */
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ push_dollar_vars()

void push_dollar_vars ( )

Definition at line 5413 of file variables.c.

References dollar_arg_stack_index, saved_dollar_vars::first_ten, NULL, saved_dollar_vars::rest, rest_of_args, save_dollar_vars(), and xrealloc().

Referenced by push_context().

 {
   if (dollar_arg_stack_index + 2 > dollar_arg_stack_slots)
     {
       dollar_arg_stack = (struct saved_dollar_vars *)
     xrealloc (dollar_arg_stack, (dollar_arg_stack_slots += 10)
           * sizeof (struct saved_dollar_vars));
     }
   
   dollar_arg_stack[dollar_arg_stack_index].first_ten = save_dollar_vars ();
   dollar_arg_stack[dollar_arg_stack_index++].rest = rest_of_args;
   rest_of_args = (WORD_LIST *)NULL;
   
   dollar_arg_stack[dollar_arg_stack_index].first_ten = (char **)NULL;
   dollar_arg_stack[dollar_arg_stack_index].rest = (WORD_LIST *)NULL;  
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pop_dollar_vars()

void pop_dollar_vars ( )

Definition at line 5432 of file variables.c.

References dispose_words(), dollar_arg_stack_index, saved_dollar_vars::first_ten, free(), free_dollar_vars(), invalidate_cached_quoted_dollar_at(), NULL, saved_dollar_vars::rest, restore_dollar_vars(), and set_dollar_vars_unchanged().

Referenced by pop_context().

 {
   if (dollar_arg_stack == 0 || dollar_arg_stack_index == 0)
     return;
 
   /* Do what remember_args (xxx, 1) would have done. */
   free_dollar_vars ();
   dispose_words (rest_of_args);
   
   rest_of_args = dollar_arg_stack[--dollar_arg_stack_index].rest;
   restore_dollar_vars (dollar_arg_stack[dollar_arg_stack_index].first_ten);
   free (dollar_arg_stack[dollar_arg_stack_index].first_ten);
 
   dollar_arg_stack[dollar_arg_stack_index].first_ten = (char **)NULL;
   dollar_arg_stack[dollar_arg_stack_index].rest = (WORD_LIST *)NULL;
   
   set_dollar_vars_unchanged ();
   invalidate_cached_quoted_dollar_at ();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dispose_saved_dollar_vars()

void dispose_saved_dollar_vars ( )

Definition at line 5453 of file variables.c.

References dispose_words(), dollar_arg_stack_index, saved_dollar_vars::first_ten, free(), free_saved_dollar_vars(), NULL, and saved_dollar_vars::rest.

 {
   if (dollar_arg_stack == 0 || dollar_arg_stack_index == 0)
     return;
 
   dispose_words (dollar_arg_stack[--dollar_arg_stack_index].rest);    
   free_saved_dollar_vars (dollar_arg_stack[dollar_arg_stack_index].first_ten);  
   free (dollar_arg_stack[dollar_arg_stack_index].first_ten);
 
   dollar_arg_stack[dollar_arg_stack_index].first_ten = (char **)NULL;  
   dollar_arg_stack[dollar_arg_stack_index].rest = (WORD_LIST *)NULL;
 }

Here is the call graph for this function:

◆ init_bash_argv()

void init_bash_argv ( )

Definition at line 5469 of file variables.c.

References bash_argv_initialized, and save_bash_argv().

Referenced by _evalfile(), execute_function(), and get_bash_command().

 {
   if (bash_argv_initialized == 0)
     {
       save_bash_argv ();
       bash_argv_initialized = 1;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ save_bash_argv()

void save_bash_argv ( )

Definition at line 5479 of file variables.c.

References dispose_words(), list, list_rest_of_args(), and push_args().

Referenced by init_bash_argv().

 {
   WORD_LIST *list;
 
   list = list_rest_of_args ();
   push_args (list);
   dispose_words (list);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ push_args()

void push_args ( WORD_LIST * list )

Definition at line 5491 of file variables.c.

References array_push, free(), GET_ARRAY_FROM_VAR, i, itos(), word_list::next, t, word_desc::word, and word_list::word.

Referenced by bind_args(), execute_function(), and save_bash_argv().

 {
 #if defined (ARRAY_VARS) && defined (DEBUGGER)
   SHELL_VAR *bash_argv_v, *bash_argc_v;
   ARRAY *bash_argv_a, *bash_argc_a;
   WORD_LIST *l;
   arrayind_t i;
   char *t;
 
   GET_ARRAY_FROM_VAR ("BASH_ARGV", bash_argv_v, bash_argv_a);
   GET_ARRAY_FROM_VAR ("BASH_ARGC", bash_argc_v, bash_argc_a);
 
   for (l = list, i = 0; l; l = l->next, i++)
     array_push (bash_argv_a, l->word->word);
 
   t = itos (i);
   array_push (bash_argc_a, t);
   free (t);
 #endif /* ARRAY_VARS && DEBUGGER */
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pop_args()

void pop_args ( )

Definition at line 5517 of file variables.c.

References array_pop, element_value, GET_ARRAY_FROM_VAR, i, and legal_number().

Referenced by _evalfile(), execute_function(), and unbind_args().

 {
 #if defined (ARRAY_VARS) && defined (DEBUGGER)
   SHELL_VAR *bash_argv_v, *bash_argc_v;
   ARRAY *bash_argv_a, *bash_argc_a;
   ARRAY_ELEMENT *ce;
   intmax_t i;
 
   GET_ARRAY_FROM_VAR ("BASH_ARGV", bash_argv_v, bash_argv_a);
   GET_ARRAY_FROM_VAR ("BASH_ARGC", bash_argc_v, bash_argc_a);
 
   ce = array_shift (bash_argc_a, 1, 0);
   if (ce == 0 || legal_number (element_value (ce), &i) == 0)
     i = 0;
 
   for ( ; i > 0; i--)
     array_pop (bash_argv_a);
   array_dispose_element (ce);
 #endif /* ARRAY_VARS && DEBUGGER */
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sv_compare()

static int sv_compare	(	struct name_and_function *	sv1,
		struct name_and_function *	sv2
	)

static

Definition at line 5646 of file variables.c.

References name_and_function::name.

Referenced by stupidly_hack_special_variables().

 {
   int r;
 
   if ((r = sv1->name[0] - sv2->name[0]) == 0)
     r = strcmp (sv1->name, sv2->name);
   return r;
 }

Here is the caller graph for this function:

◆ find_special_var()

static int find_special_var ( char * name ) const

inlinestatic

Definition at line 5657 of file variables.c.

References i, and name_and_function::name.

Referenced by propagate_temp_var(), push_posix_temp_var(), push_temp_var(), and stupidly_hack_special_variables().

 {
   register int i, r;
 
   for (i = 0; special_vars[i].name; i++)
     {
       r = special_vars[i].name[0] - name[0];
       if (r == 0)
     r = strcmp (special_vars[i].name, name);
       if (r == 0)
     return i;
       else if (r > 0)
     /* Can't match any of rest of elements in sorted list.  Take this out
        if it causes problems in certain environments. */
     break;
     }
   return -1;
 }

Here is the caller graph for this function:

◆ stupidly_hack_special_variables()

void stupidly_hack_special_variables ( char * name )

Definition at line 5680 of file variables.c.

References find_special_var(), name_and_function::function, i, N_SPECIAL_VARS, name_and_function::name, qsort(), and sv_compare().

Referenced by assign_in_env(), dispose_temporary_env(), do_assignment_internal(), expr_bind_variable(), makunbound(), parameter_brace_expand_rhs(), push_exported_var(), push_posix_tempvar_internal(), redir_varassign(), and run_startup_files().

 {
   static int sv_sorted = 0;
   int i;
 
   if (sv_sorted == 0)   /* shouldn't need, but it's fairly cheap. */
     {
       qsort (special_vars, N_SPECIAL_VARS, sizeof (special_vars[0]),
         (QSFUNC *)sv_compare);
       sv_sorted = 1;
     }
 
   i = find_special_var (name);
   if (i != -1)
     (*(special_vars[i].function)) (name);
 }

Here is the call graph for this function:

◆ reinit_special_variables()

void reinit_special_variables ( )

Definition at line 5701 of file variables.c.

References sv_globignore(), and sv_opterr().

Referenced by shell_reinitialize().

 {
 #if defined (READLINE)
   sv_comp_wordbreaks ("COMP_WORDBREAKS");
 #endif
   sv_globignore ("GLOBIGNORE");
   sv_opterr ("OPTERR");
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sv_ifs()

void sv_ifs ( char * name )

Definition at line 5711 of file variables.c.

References find_variable(), and setifs().

Referenced by pop_context(), pop_scope(), redirection_expand(), write_here_document(), and write_here_string().

 {
   SHELL_VAR *v;
 
   v = find_variable ("IFS");
   setifs (v);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sv_path()

void sv_path ( char * name )

Definition at line 5722 of file variables.c.

References phash_flush().

 {
   /* hash -r */
   phash_flush ();
 }

Here is the call graph for this function:

◆ sv_mail()

void sv_mail ( char * name )

Definition at line 5733 of file variables.c.

References free_mail_files(), remember_mail_dates(), and reset_mail_timer().

 {
   /* If the time interval for checking the files has changed, then
      reset the mail timer.  Otherwise, one of the pathname vars
      to the users mailbox has changed, so rebuild the array of
      filenames. */
   if (name[4] == 'C')  /* if (strcmp (name, "MAILCHECK") == 0) */
     reset_mail_timer ();
   else
     {
       free_mail_files ();
       remember_mail_dates ();
     }
 }

Here is the call graph for this function:

◆ sv_funcnest()

void sv_funcnest ( char * name )

Definition at line 5750 of file variables.c.

References find_variable(), funcnest_max, legal_number(), and value_cell.

Referenced by initialize_shell_variables().

 {
   SHELL_VAR *v;
   intmax_t num;
 
   v = find_variable (name);
   if (v == 0)
     funcnest_max = 0;
   else if (legal_number (value_cell (v), &num) == 0)
     funcnest_max = 0;
   else
     funcnest_max = num;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sv_execignore()

void sv_execignore ( char * name )

Definition at line 5767 of file variables.c.

References setup_exec_ignore().

 {
   setup_exec_ignore (name);
 }

Here is the call graph for this function:

◆ sv_globignore()

void sv_globignore ( char * name )

Definition at line 5775 of file variables.c.

References array_needs_making, chkexport(), extract_colon_unit(), find_variable(), free(), get_string_value(), HC_ERASEDUPS, HC_IGNBOTH, HC_IGNDUPS, HC_IGNSPACE, history_comment_char, history_control, history_expansion_char, history_lines_in_file, history_lines_this_session, history_subst_char, history_truncate_file(), history_write_timestamps, hostname_list_initialized, interactive_shell, legal_number(), maybe_make_export_env(), name_and_function::name, no_line_editing, posixly_correct, privileged_mode, rl_reset_screen_size(), rl_reset_terminal(), rl_set_screen_size(), setup_glob_ignore(), stifle_history(), STREQ, sv_histsize(), temp, tzset(), unstifle_history(), val, value_cell, var_isset, and where_history().

Referenced by reinit_special_variables().

 {
   if (privileged_mode == 0)
     setup_glob_ignore (name);
 }

Here is the caller graph for this function:

◆ sv_ignoreeof()

void sv_ignoreeof ( char * name )

Definition at line 6005 of file variables.c.

References all_digits(), atoi(), eof_encountered, eof_encountered_limit, find_variable(), ignoreeof, NULL, temp, value_cell, and var_isset.

Referenced by initialize_shell_variables().

 {
   SHELL_VAR *tmp_var;
   char *temp;
 
   eof_encountered = 0;
 
   tmp_var = find_variable (name);
   ignoreeof = tmp_var && var_isset (tmp_var);
   temp = tmp_var ? value_cell (tmp_var) : (char *)NULL;
   if (temp)
     eof_encountered_limit = (*temp && all_digits (temp)) ? atoi (temp) : 10;
   set_shellopts (); /* make sure `ignoreeof' is/is not in $SHELLOPTS */
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sv_optind()

void sv_optind ( char * name )

Definition at line 6022 of file variables.c.

References atoi(), find_variable(), get_variable_value(), and NULL.

 {
   SHELL_VAR *var;
   char *tt;
   int s;
 
   var = find_variable ("OPTIND");
   tt = var ? get_variable_value (var) : (char *)NULL;
 
   /* Assume that if var->context < variable_context and variable_context > 0
      then we are restoring the variables's previous state while returning
      from a function. */
   if (tt && *tt)
     {
       s = atoi (tt);
 
       /* According to POSIX, setting OPTIND=1 resets the internal state
      of getopt (). */
       if (s < 0 || s == 1)
     s = 0;
     }
   else
     s = 0;
   getopts_reset (s);
 }

Here is the call graph for this function:

◆ sv_opterr()

void sv_opterr ( char * name )

Definition at line 6050 of file variables.c.

References atoi(), get_string_value(), and sh_opterr.

Referenced by reinit_special_variables().

 {
   char *tt;
 
   tt = get_string_value ("OPTERR");
   sh_opterr = (tt && *tt) ? atoi (tt) : 1;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sv_strict_posix()

void sv_strict_posix ( char * name )

Definition at line 6060 of file variables.c.

References find_variable(), interactive_shell, posix_initialize(), posixly_correct, and var_isset.

Referenced by initialize_shell_variables(), and main().

 {
   SHELL_VAR *var;
 
   var = find_variable (name);
   posixly_correct = var && var_isset (var);
   posix_initialize (posixly_correct);
 #if defined (READLINE)
   if (interactive_shell)
     posix_readline_initialize (posixly_correct);
 #endif /* READLINE */
   set_shellopts (); /* make sure `posix' is/is not in $SHELLOPTS */
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sv_locale()

void sv_locale ( char * name )

Definition at line 6076 of file variables.c.

References array_cell, array_num_elements, array_p, element_forw, element_value, find_variable(), free(), get_string_value(), i, INT_STRLEN_BOUND, inttostr(), itos(), last_command_exit_value, NULL, posixly_correct, set_element_value, set_lang(), set_locale_var(), t, and var_setarray.

 {
   char *v;
   int r;
 
   v = get_string_value (name);
   if (name[0] == 'L' && name[1] == 'A') /* LANG */
     r = set_lang (name, v);
   else
     r = set_locale_var (name, v);       /* LC_*, TEXTDOMAIN* */
 
 #if 1
   if (r == 0 && posixly_correct)
     last_command_exit_value = 1;
 #endif
 }

Here is the call graph for this function:

◆ set_pipestatus_from_exit()

void set_pipestatus_from_exit ( int s )

Definition at line 6194 of file variables.c.

Referenced by execute_command_internal(), execute_simple_command(), and exp_jump_to_top_level().

 {
 #if defined (ARRAY_VARS)
   static int v[2] = { 0, -1 };
 
   v[0] = s;
   set_pipestatus_array (v, 1);
 #endif
 }

Here is the caller graph for this function:

◆ sv_xtracefd()

void sv_xtracefd ( char * name )

Definition at line 6206 of file variables.c.

References _(), find_variable(), internal_error(), sh_validfd(), strtol(), t, value_cell, xtrace_reset(), and xtrace_set().

Referenced by initialize_shell_variables().

 {
   SHELL_VAR *v;
   char *t, *e;
   int fd;
   FILE *fp;
 
   v = find_variable (name);
   if (v == 0)
     {
       xtrace_reset ();
       return;
     }
 
   t = value_cell (v);
   if (t == 0 || *t == 0)
     xtrace_reset ();
   else
     {
       fd = (int)strtol (t, &e, 10);
       if (e != t && *e == '\0' && sh_validfd (fd))
     {
       fp = fdopen (fd, "w");
       if (fp == 0)
         internal_error (_("%s: %s: cannot open as FILE"), name, value_cell (v));
       else
         xtrace_set (fd, fp);
     }
       else
     internal_error (_("%s: %s: invalid value for trace file descriptor"), name, value_cell (v));
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sv_shcompat()

void sv_shcompat ( char * name )

Definition at line 6243 of file variables.c.

References _(), atoi(), find_variable(), get_string_value(), internal_error(), ISDIGIT, name_and_function::name, set_maxchild(), shell_compatibility_level, val, and value_cell.

Referenced by initialize_shell_variables().

 {
   SHELL_VAR *v;
   char *val;
   int tens, ones, compatval;
 
   v = find_variable (name);
   if (v == 0)
     {
       shell_compatibility_level = DEFAULT_COMPAT_LEVEL;
       set_compatibility_opts ();
       return;
     }
   val = value_cell (v);
   if (val == 0 || *val == '\0')
     {
       shell_compatibility_level = DEFAULT_COMPAT_LEVEL;
       set_compatibility_opts ();
       return;
     }
   /* Handle decimal-like compatibility version specifications: 4.2 */
   if (ISDIGIT (val[0]) && val[1] == '.' && ISDIGIT (val[2]) && val[3] == 0)
     {
       tens = val[0] - '0';
       ones = val[2] - '0';
       compatval = tens*10 + ones;
     }
   /* Handle integer-like compatibility version specifications: 42 */
   else if (ISDIGIT (val[0]) && ISDIGIT (val[1]) && val[2] == 0)
     {
       tens = val[0] - '0';
       ones = val[1] - '0';
       compatval = tens*10 + ones;
     }
   else
     {
 compat_error:
       internal_error (_("%s: %s: compatibility value out of range"), name, val);
       shell_compatibility_level = DEFAULT_COMPAT_LEVEL;
       set_compatibility_opts ();
       return;
     }
 
   if (compatval < MIN_COMPAT_LEVEL || compatval > DEFAULT_COMPAT_LEVEL)
     goto compat_error;
 
   shell_compatibility_level = compatval;
   set_compatibility_opts ();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

◆ environ

char** environ

Referenced by maybe_make_export_env().

◆ shell_start_time

time_t shell_start_time

Definition at line 181 of file shell.c.

Referenced by assign_seconds(), and get_seconds().

◆ global_variables

VAR_CONTEXT* global_variables = (VAR_CONTEXT *) 0x0

Definition at line 104 of file variables.c.

Referenced by delete_all_contexts().

◆ shell_variables

VAR_CONTEXT* shell_variables = (VAR_CONTEXT *) 0x0

Definition at line 107 of file variables.c.

Referenced by all_local_variables(), initialize_subshell(), maybe_make_export_env(), pop_scope(), pop_var_context(), push_var_context(), and shell_reinitialize().

◆ shell_functions

HASH_TABLE* shell_functions = (HASH_TABLE *) 0x0

Definition at line 111 of file variables.c.

Referenced by shell_reinitialize().

◆ invalid_env

HASH_TABLE* invalid_env = (HASH_TABLE *) 0x0

Definition at line 113 of file variables.c.

Referenced by maybe_make_export_env().

◆ variable_context

◆ localvar_inherit

int localvar_inherit = 0

Definition at line 127 of file variables.c.

Referenced by make_local_variable(), and make_new_variable().

◆ localvar_unset

int localvar_unset = 0

Definition at line 132 of file variables.c.

Referenced by makunbound().

◆ temporary_env

HASH_TABLE* temporary_env = (HASH_TABLE *) 0x0

Definition at line 136 of file variables.c.

Referenced by _run_trap_internal(), execute_builtin(), execute_function(), execute_simple_command(), maybe_make_export_env(), reader_loop(), run_pending_traps(), and run_sigchld_trap().

◆ tempenv_assign_error

int tempenv_assign_error

Definition at line 140 of file variables.c.

Referenced by execute_simple_command(), and expand_word_list_internal().

◆ dollar_vars

char* dollar_vars[10]

Definition at line 144 of file variables.c.

Referenced by assign_bash_argv0(), bind_args(), expand_word_internal(), free_dollar_vars(), get_bash_argv0(), get_dollar_var_value(), get_name_for_error(), initialize_shell_variables(), list_rest_of_args(), number_of_args(), open_shell_script(), param_expand(), pos_params(), remember_args(), restore_dollar_vars(), save_dollar_vars(), set_bash_input(), and set_shell_name().

◆ rest_of_args

WORD_LIST* rest_of_args = (WORD_LIST *) 0x0

Definition at line 145 of file variables.c.

Referenced by get_dollar_var_value(), list_rest_of_args(), number_of_args(), push_dollar_vars(), and remember_args().

◆ dollar_dollar_pid

pid_t dollar_dollar_pid

Definition at line 148 of file variables.c.

Referenced by execute_pipeline(), initialize_shell_variables(), param_expand(), parameter_brace_expand_length(), push_builtin(), sh_mktmpfd(), sh_mktmpname(), and termsig_handler().

◆ array_needs_making

int array_needs_making = 1

Definition at line 151 of file variables.c.

Referenced by assign_in_env(), bind_function(), bind_variable_internal(), bind_variable_value(), chkexport(), dispose_temporary_env(), dispose_variable(), initialize_shell_variables(), makunbound(), maybe_make_export_env(), sv_globignore(), and unbind_func().

◆ shell_level

int shell_level = 0

Definition at line 155 of file variables.c.

Referenced by adjust_shell_level(), get_tty_state(), run_startup_files(), and set_tty_state().

◆ export_env

char** export_env = (char **) 0x0

Definition at line 160 of file variables.c.

Referenced by add_or_supercede_exported_var(), add_temp_array_to_env(), bperl_builtin(), execute_disk_command(), maybe_make_export_env(), printenv_builtin(), and update_export_env_inplace().

◆ export_env_index

int export_env_index

static

Definition at line 161 of file variables.c.

Referenced by add_or_supercede_exported_var(), and maybe_make_export_env().

◆ export_env_size

int export_env_size

static

Definition at line 162 of file variables.c.

Referenced by maybe_make_export_env().

◆ nameref_invalid_value

SHELL_VAR nameref_invalid_value

Definition at line 168 of file variables.c.

◆ nameref_maxloop_value

SHELL_VAR nameref_maxloop_value

static

Definition at line 169 of file variables.c.

◆ last_table_searched

HASH_TABLE* last_table_searched

static

Definition at line 171 of file variables.c.

◆ seconds_value_assigned

intmax_t seconds_value_assigned

static

Definition at line 1266 of file variables.c.

◆ rseed

unsigned long rseed = 1

static

Definition at line 1314 of file variables.c.

◆ last_random_value

int last_random_value

static

Definition at line 1315 of file variables.c.

◆ seeded_subshell

int seeded_subshell = 0

static

Definition at line 1316 of file variables.c.

◆ static_shell_name

char* static_shell_name = 0

static

Definition at line 1531 of file variables.c.

Referenced by assign_bash_argv0().

◆ tempvar_list

char** tempvar_list

Definition at line 4418 of file variables.c.

◆ tvlist_ind

int tvlist_ind

Definition at line 4419 of file variables.c.

Referenced by dispose_temporary_env().

◆ dollar_arg_stack

struct saved_dollar_vars* dollar_arg_stack = (struct saved_dollar_vars *) 0x0

static

Definition at line 5333 of file variables.c.

◆ dollar_arg_stack_slots

int dollar_arg_stack_slots

static

Definition at line 5334 of file variables.c.

◆ dollar_arg_stack_index

int dollar_arg_stack_index

static

Definition at line 5335 of file variables.c.

Referenced by dispose_saved_dollar_vars(), pop_dollar_vars(), and push_dollar_vars().

◆ special_vars

struct name_and_function special_vars[]

static

Definition at line 5559 of file variables.c.

Data Structures

Macros

Functions

Variables

Data Structure Documentation

◆ saved_dollar_vars

◆ name_and_function

Macro Definition Documentation

◆ NEED_XTRACE_SET_DECL

◆ VARIABLES_HASH_BUCKETS

◆ FUNCTIONS_HASH_BUCKETS

◆ TEMPENV_HASH_BUCKETS

◆ BASHFUNC_PREFIX

◆ BASHFUNC_PREFLEN

◆ BASHFUNC_SUFFIX

◆ BASHFUNC_SUFFLEN

◆ FV_FORCETEMPENV

◆ FV_SKIPINVISIBLE

◆ INIT_DYNAMIC_VAR

◆ INIT_DYNAMIC_ARRAY_VAR

◆ INIT_DYNAMIC_ASSOC_VAR

◆ FIND_OR_MAKE_VARIABLE

◆ USE_EXPORTSTR

◆ add_to_export_env

◆ SET_INT_VAR

◆ N_SPECIAL_VARS

◆ MIN_COMPAT_LEVEL

Function Documentation

◆ __P() [1/26]

◆ __P() [2/26]

◆ __P() [3/26]

◆ __P() [4/26]

◆ __P() [5/26]

◆ __P() [6/26]

◆ __P() [7/26]

◆ __P() [8/26]

◆ __P() [9/26]

◆ __P() [10/26]

◆ __P() [11/26]

◆ __P() [12/26]

◆ __P() [13/26]

◆ __P() [14/26]

◆ __P() [15/26]

◆ __P() [16/26]

◆ __P() [17/26]

◆ __P() [18/26]

◆ __P() [19/26]

◆ __P() [20/26]

◆ __P() [21/26]

◆ __P() [22/26]

◆ __P() [23/26]

◆ __P() [24/26]

◆ __P() [25/26]

◆ __P() [26/26]

◆ create_variable_tables()

◆ initialize_shell_variables()

◆ set_machine_vars()

◆ sh_get_home_dir()

◆ set_home_var()

◆ set_shell_var()

◆ get_bash_name()

◆ adjust_shell_level()

◆ initialize_shell_level()

◆ set_pwd()

◆ set_ppid()

◆ uidset()

◆ sh_set_lines_and_columns()

◆ print_var_list()

◆ print_func_list()

◆ print_assignment()

◆ print_var_value()

◆ print_var_function()

◆ null_assign()

◆ get_self()

◆ assign_seconds()

◆ get_seconds()

◆ init_seconds_var()

◆ brand()

◆ sbrand()

◆ seedrand()