It’s a small update, but I added support for displaying method arguments along side the local variables. As I mentioned in that post, breaking out the CorValue extraction and display code into a shared function was a good idea – adding support for getting arguments was trivial since I could reuse that code.
Because there’s no hierarchy of scopes to deal with and the names are in the metadata instead of debug symbols, getting arguments is much easier than getting local variables.
def get_arguments(frame): mi = frame.GetMethodInfo() for pi in mi.GetParameters(): if pi.Position == 0: continue arg = frame.GetArgument(pi.Position - 1) yield pi.Name, arg
You’ll notice that I’m yielding the arguments as a tuple of the name and value, the same as get_locals yields. I did refactor get_locals a bit – there’s no longer an argument to skip hidden variables anymore (though get_locals still skips dynamic call sites caches as it did before). Now, it’s up to the the caller of get_arguments and get_locals to filter hidden variables as they see fit.
Because get_locals and get_arguments yield the same types, I was able to factor the code to print a value and loop through the collection of values into separate local functions.
def _input_locals_cmd(self, keyinfo): def print_value(name, value): display, type_name = display_value(extract_value(value)) with CC.Magenta: print " ", name, print display, with CC.Green: print type_name def print_all_values(f, show_hidden): count = 0 for name,value in f(self.active_thread.ActiveFrame): if name.startswith("$") and not show_hidden: continue print_value(name, value) count+=1 return count print "nLocals" show_hidden = (keyinfo.Modifiers & ConsoleModifiers.Alt) == ConsoleModifiers.Alt count = print_all_values(get_locals, show_hidden) count += print_all_values(get_arguments, show_hidden) if count == 0: with CC.Magenta: print " No Locals Found"
I really like the local functions feature of Python. In C#, you can define an anonymous delegate using the lambda syntax. But for a scenario like this, I like local functions better. However, I do like C#’s support for statement lambdas – Python only supports expression lambdas. So while I like local functions better in this scenario (because I’m using the method more than once) in something like an event handler, I like the statement lambda syntax better.
As usual, the latest version of ipydbg is up on GitHub.