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