def Run(self, cmd_val):
# type: (cmd_value__Assign) -> int
arg_r = args.Reader(cmd_val.argv, spids=cmd_val.arg_spids)
arg_r.Next()
attrs = flag_spec.Parse('export_', arg_r)
arg = arg_types.export_(attrs.attrs)
#arg = attrs
if arg.f:
e_usage(
"doesn't accept -f because it's dangerous. "
"(The code can usually be restructured with 'source')")
if arg.p or len(cmd_val.pairs) == 0:
return _PrintVariables(self.mem, cmd_val, attrs, True, builtin=_EXPORT)
if arg.n:
for pair in cmd_val.pairs:
if pair.rval is not None:
e_usage("doesn't accept RHS with -n", span_id=pair.spid)
# NOTE: we don't care if it wasn't found, like bash.
self.mem.ClearFlag(pair.var_name, state.ClearExport, scope_e.Dynamic)
else:
for pair in cmd_val.pairs:
# NOTE: when rval is None, only flags are changed
self.mem.SetVar(lvalue.Named(pair.var_name), pair.rval, scope_e.Dynamic,
flags=state.SetExport)
return 0
def Run(self, cmd_val):
# type: (cmd_value__Assign) -> int
arg_r = args.Reader(cmd_val.argv, spids=cmd_val.arg_spids)
arg_r.Next()
attrs = flag_spec.Parse('readonly', arg_r)
arg = arg_types.readonly(attrs.attrs)
if arg.p or len(cmd_val.pairs) == 0:
return _PrintVariables(self.mem, cmd_val, attrs, True, builtin=_READONLY)
for pair in cmd_val.pairs:
if pair.rval is None:
if arg.a:
rval = value.MaybeStrArray([]) # type: value_t
elif arg.A:
rval = value.AssocArray({})
else:
rval = None
else:
rval = pair.rval
rval = _ReconcileTypes(rval, arg.a, arg.A, pair.spid)
# NOTE:
# - when rval is None, only flags are changed
# - dynamic scope because flags on locals can be changed, etc.
self.mem.SetVar(lvalue.Named(pair.var_name), rval, scope_e.Dynamic,
flags=state.SetReadOnly)
return 0
def Run(self, cmd_val):
# type: (cmd_value__Assign) -> int
arg_r = args.Reader(cmd_val.argv, spids=cmd_val.arg_spids)
arg_r.Next()
attrs = flag_spec.Parse('new_var', arg_r)
arg = arg_types.new_var(attrs.attrs)
status = 0
if arg.f:
names = arg_r.Rest()
if len(names):
# NOTE: in bash, -f shows the function body, while -F shows the name.
# Right now we just show the name.
status = self._PrintFuncs(names)
else:
e_usage('passed -f without args')
return status
if arg.F:
names = arg_r.Rest()
if len(names):
status = self._PrintFuncs(names)
else: # weird bash quirk: they're printed in a different format!
for func_name in sorted(self.funcs):
print('declare -f %s' % (func_name))
return status
if arg.p: # Lookup and print variables.
return _PrintVariables(self.mem, cmd_val, attrs, True)
elif len(cmd_val.pairs) == 0:
return _PrintVariables(self.mem, cmd_val, attrs, False)
#
# Set variables
#
#raise error.Usage("doesn't understand %s" % cmd_val.argv[1:])
if cmd_val.builtin_id == builtin_i.local:
lookup_mode = scope_e.LocalOnly
else: # declare/typeset
if arg.g:
lookup_mode = scope_e.GlobalOnly
else:
lookup_mode = scope_e.LocalOnly
flags = 0
if arg.x == '-':
flags |= state.SetExport
if arg.r == '-':
flags |= state.SetReadOnly
if arg.n == '-':
flags |= state.SetNameref
flags_to_clear = 0
if arg.x == '+':
flags |= state.ClearExport
if arg.r == '+':
flags |= state.ClearReadOnly
if arg.n == '+':
flags |= state.ClearNameref
for pair in cmd_val.pairs:
rval = pair.rval
# declare -a foo=(a b); declare -a foo; should not reset to empty array
if rval is None and (arg.a or arg.A):
old_val = self.mem.GetVar(pair.var_name)
if arg.a:
if old_val.tag_() != value_e.MaybeStrArray:
rval = value.MaybeStrArray([])
elif arg.A:
if old_val.tag_() != value_e.AssocArray:
rval = value.AssocArray({})
rval = _ReconcileTypes(rval, arg.a, arg.A, pair.spid)
self.mem.SetVar(lvalue.Named(pair.var_name),
rval,
lookup_mode,
flags=flags)
return status
def Run(self, cmd_val):
# type: (cmd_value__Assign) -> int
arg_r = args.Reader(cmd_val.argv, spids=cmd_val.arg_spids)
arg_r.Next()
attrs = flag_spec.Parse('new_var', arg_r)
arg = arg_types.new_var(attrs.attrs)
status = 0
if arg.f:
names = arg_r.Rest()
if len(names):
# This is only used for a STATUS QUERY now. We only show the name,
# not the body.
status = self._PrintFuncs(names)
else:
# Disallow this since it would be incompatible.
e_usage('with -f expects function names')
return status
if arg.F:
names = arg_r.Rest()
if len(names):
status = self._PrintFuncs(names)
else:
# bash quirk: with no names, they're printed in a different format!
for func_name in sorted(self.funcs):
print('declare -f %s' % (func_name))
return status
if arg.p: # Lookup and print variables.
return _PrintVariables(self.mem, cmd_val, attrs, True)
elif len(cmd_val.pairs) == 0:
return _PrintVariables(self.mem, cmd_val, attrs, False)
#
# Set variables
#
#raise error.Usage("doesn't understand %s" % cmd_val.argv[1:])
if cmd_val.builtin_id == builtin_i.local:
which_scopes = scope_e.LocalOnly
else: # declare/typeset
if arg.g:
which_scopes = scope_e.GlobalOnly
else:
which_scopes = scope_e.LocalOnly
flags = 0
if arg.x == '-':
flags |= state.SetExport
if arg.r == '-':
flags |= state.SetReadOnly
if arg.n == '-':
flags |= state.SetNameref
flags_to_clear = 0
if arg.x == '+':
flags |= state.ClearExport
if arg.r == '+':
flags |= state.ClearReadOnly
if arg.n == '+':
flags |= state.ClearNameref
for pair in cmd_val.pairs:
rval = pair.rval
# declare -a foo=(a b); declare -a foo; should not reset to empty array
if rval is None and (arg.a or arg.A):
old_val = self.mem.GetValue(pair.var_name)
if arg.a:
if old_val.tag_() != value_e.MaybeStrArray:
rval = value.MaybeStrArray([])
elif arg.A:
if old_val.tag_() != value_e.AssocArray:
rval = value.AssocArray({})
rval = _ReconcileTypes(rval, arg.a, arg.A, pair.spid)
self.mem.SetValue(lvalue.Named(pair.var_name), rval, which_scopes,
flags=flags)
return status
