When inside tracing function, debugging a function call, is it possible to somehow retrieve the calling expression?
I can get calling line number from traceback object but if there are several function calls (possibly to the same function) on that line (eg. as subexpression in a bigger expression) then how could I learn where this call came from? I would be happy even with the offset from start of the source line.
That's how I finally solved the problem: I instrumented each function call in the original program by wrapping it in a call to a helper function together with information about the source location of the original call. Actually I was interested in controlling the evaluation of each subexpression in the program, so I wrapped each subexpression.
More precisely: when I had an expression
e in the original program, it became
in the instrumented program. The helpers were defined like this:
def _before(location_info): return location_info def _after(location_info, value): return value
When tracer reported the call to
_before, I knew that it's about to evaluate the expression at location represented by
location_info (tracing system gives me access to local variables/parameters, that's how I got to know the value of
location_info). When tracer reported the call to
_after, I knew that the expession indicated by
location_info was just evaluated and the value is in
I could have written the execution "event handling" right into those helper functions and bypass the tracing system altogether, but I needed it for other reasons as well, so I used those helpers only for triggering a "call" event in tracing system.
The result can be seen here: http://thonny.org