examples/python/pytracer.py - llvm-project/lldb - Git at Google

 import sys
 import inspect
 from collections import OrderedDict


 class TracebackFancy:
     def __init__(self, traceback):
         self.t = traceback

     def getFrame(self):
         return FrameFancy(self.t.tb_frame)

     def getLineNumber(self):
         return self.t.tb_lineno if self.t is not None else None

     def getNext(self):
         return TracebackFancy(self.t.tb_next)

     def __str__(self):
         if self.t is None:
             return ""
         str_self = "%s @ %s" % (self.getFrame().getName(), self.getLineNumber())
         return str_self + "\n" + self.getNext().__str__()


 class ExceptionFancy:
     def __init__(self, frame):
         self.etraceback = frame.f_exc_traceback
         self.etype = frame.exc_type
         self.evalue = frame.f_exc_value

     def __init__(self, tb, ty, va):
         self.etraceback = tb
         self.etype = ty
         self.evalue = va

     def getTraceback(self):
         return TracebackFancy(self.etraceback)

     def __nonzero__(self):
         return (
             self.etraceback is not None
             or self.etype is not None
             or self.evalue is not None
         )

     def getType(self):
         return str(self.etype)

     def getValue(self):
         return self.evalue


 class CodeFancy:
     def __init__(self, code):
         self.c = code

     def getArgCount(self):
         return self.c.co_argcount if self.c is not None else 0

     def getFilename(self):
         return self.c.co_filename if self.c is not None else ""

     def getVariables(self):
         return self.c.co_varnames if self.c is not None else []

     def getName(self):
         return self.c.co_name if self.c is not None else ""

     def getFileName(self):
         return self.c.co_filename if self.c is not None else ""


 class ArgsFancy:
     def __init__(self, frame, arginfo):
         self.f = frame
         self.a = arginfo

     def __str__(self):
         args, varargs, kwargs = self.getArgs(), self.getVarArgs(), self.getKWArgs()
         ret = ""
         count = 0
         size = len(args)
         for arg in args:
             ret = ret + ("%s = %s" % (arg, args[arg]))
             count = count + 1
             if count < size:
                 ret = ret + ", "
         if varargs:
             if size > 0:
                 ret = ret + " "
             ret = ret + "varargs are " + str(varargs)
         if kwargs:
             if size > 0:
                 ret = ret + " "
             ret = ret + "kwargs are " + str(kwargs)
         return ret

     def getNumArgs(wantVarargs=False, wantKWArgs=False):
         args, varargs, keywords, values = self.a
         size = len(args)
         if varargs and wantVarargs:
             size = size + len(self.getVarArgs())
         if keywords and wantKWArgs:
             size = size + len(self.getKWArgs())
         return size

     def getArgs(self):
         args, _, _, values = self.a
         argWValues = OrderedDict()
         for arg in args:
             argWValues[arg] = values[arg]
         return argWValues

     def getVarArgs(self):
         _, vargs, _, _ = self.a
         if vargs:
             return self.f.f_locals[vargs]
         return ()

     def getKWArgs(self):
         _, _, kwargs, _ = self.a
         if kwargs:
             return self.f.f_locals[kwargs]
         return {}


 class FrameFancy:
     def __init__(self, frame):
         self.f = frame

     def getCaller(self):
         return FrameFancy(self.f.f_back)

     def getLineNumber(self):
         return self.f.f_lineno if self.f is not None else 0

     def getCodeInformation(self):
         return CodeFancy(self.f.f_code) if self.f is not None else None

     def getExceptionInfo(self):
         return ExceptionFancy(self.f) if self.f is not None else None

     def getName(self):
         return self.getCodeInformation().getName() if self.f is not None else ""

     def getFileName(self):
         return self.getCodeInformation().getFileName() if self.f is not None else ""

     def getLocals(self):
         return self.f.f_locals if self.f is not None else {}

     def getArgumentInfo(self):
         return (
             ArgsFancy(self.f, inspect.getargvalues(self.f))
             if self.f is not None
             else None
         )


 class TracerClass:
     def callEvent(self, frame):
         pass

     def lineEvent(self, frame):
         pass

     def returnEvent(self, frame, retval):
         pass

     def exceptionEvent(self, frame, exception, value, traceback):
         pass

     def cCallEvent(self, frame, cfunct):
         pass

     def cReturnEvent(self, frame, cfunct):
         pass

     def cExceptionEvent(self, frame, cfunct):
         pass


 tracer_impl = TracerClass()


 def the_tracer_entrypoint(frame, event, args):
     if tracer_impl is None:
         return None
     if event == "call":
         call_retval = tracer_impl.callEvent(FrameFancy(frame))
         if not call_retval:
             return None
         return the_tracer_entrypoint
     elif event == "line":
         line_retval = tracer_impl.lineEvent(FrameFancy(frame))
         if not line_retval:
             return None
         return the_tracer_entrypoint
     elif event == "return":
         tracer_impl.returnEvent(FrameFancy(frame), args)
     elif event == "exception":
         exty, exva, extb = args
         exception_retval = tracer_impl.exceptionEvent(
             FrameFancy(frame), ExceptionFancy(extb, exty, exva)
         )
         if not exception_retval:
             return None
         return the_tracer_entrypoint
     elif event == "c_call":
         tracer_impl.cCallEvent(FrameFancy(frame), args)
     elif event == "c_return":
         tracer_impl.cReturnEvent(FrameFancy(frame), args)
     elif event == "c_exception":
         tracer_impl.cExceptionEvent(FrameFancy(frame), args)
     return None


 def enable(t=None):
     global tracer_impl
     if t:
         tracer_impl = t
     sys.settrace(the_tracer_entrypoint)


 def disable():
     sys.settrace(None)


 class LoggingTracer:
     def callEvent(self, frame):
         print(
             "call "
             + frame.getName()
             + " from "
             + frame.getCaller().getName()
             + " @ "
             + str(frame.getCaller().getLineNumber())
             + " args are "
             + str(frame.getArgumentInfo())
         )

     def lineEvent(self, frame):
         print(
             "running "
             + frame.getName()
             + " @ "
             + str(frame.getLineNumber())
             + " locals are "
             + str(frame.getLocals())
             + " in "
             + frame.getFileName()
         )

     def returnEvent(self, frame, retval):
         print(
             "return from "
             + frame.getName()
             + " value is "
             + str(retval)
             + " locals are "
             + str(frame.getLocals())
         )

     def exceptionEvent(self, frame, exception):
         print(
             "exception %s %s raised from %s @ %s"
             % (
                 exception.getType(),
                 str(exception.getValue()),
                 frame.getName(),
                 frame.getLineNumber(),
             )
         )
         print("tb: " + str(exception.getTraceback()))


 # the same functionality as LoggingTracer, but with a little more
 # lldb-specific smarts


 class LLDBAwareTracer:
     def callEvent(self, frame):
         if frame.getName() == "<module>":
             return
         if frame.getName() == "run_one_line":
             print(
                 "call run_one_line(%s)"
                 % (frame.getArgumentInfo().getArgs()["input_string"])
             )
             return
         if "Python.framework" in frame.getFileName():
             print("call into Python at " + frame.getName())
             return
         if (
             frame.getName() == "__init__"
             and frame.getCaller().getName() == "run_one_line"
             and frame.getCaller().getLineNumber() == 101
         ):
             return False
         strout = "call " + frame.getName()
         if frame.getCaller().getFileName() == "":
             strout += " from LLDB - args are "
             args = frame.getArgumentInfo().getArgs()
             for arg in args:
                 if arg == "dict" or arg == "internal_dict":
                     continue
                 strout = strout + ("%s = %s " % (arg, args[arg]))
         else:
             strout += (
                 " from "
                 + frame.getCaller().getName()
                 + " @ "
                 + str(frame.getCaller().getLineNumber())
                 + " args are "
                 + str(frame.getArgumentInfo())
             )
         print(strout)

     def lineEvent(self, frame):
         if frame.getName() == "<module>":
             return
         if frame.getName() == "run_one_line":
             print(
                 "running run_one_line(%s) @ %s"
                 % (
                     frame.getArgumentInfo().getArgs()["input_string"],
                     frame.getLineNumber(),
                 )
             )
             return
         if "Python.framework" in frame.getFileName():
             print(
                 "running into Python at "
                 + frame.getName()
                 + " @ "
                 + str(frame.getLineNumber())
             )
             return
         strout = (
             "running "
             + frame.getName()
             + " @ "
             + str(frame.getLineNumber())
             + " locals are "
         )
         if frame.getCaller().getFileName() == "":
             locals = frame.getLocals()
             for local in locals:
                 if local == "dict" or local == "internal_dict":
                     continue
                 strout = strout + ("%s = %s " % (local, locals[local]))
         else:
             strout = strout + str(frame.getLocals())
         strout = strout + " in " + frame.getFileName()
         print(strout)

     def returnEvent(self, frame, retval):
         if frame.getName() == "<module>":
             return
         if frame.getName() == "run_one_line":
             print(
                 "return from run_one_line(%s) return value is %s"
                 % (frame.getArgumentInfo().getArgs()["input_string"], retval)
             )
             return
         if "Python.framework" in frame.getFileName():
             print(
                 "return from Python at "
                 + frame.getName()
                 + " return value is "
                 + str(retval)
             )
             return
         strout = (
             "return from "
             + frame.getName()
             + " return value is "
             + str(retval)
             + " locals are "
         )
         if frame.getCaller().getFileName() == "":
             locals = frame.getLocals()
             for local in locals:
                 if local == "dict" or local == "internal_dict":
                     continue
                 strout = strout + ("%s = %s " % (local, locals[local]))
         else:
             strout = strout + str(frame.getLocals())
         strout = strout + " in " + frame.getFileName()
         print(strout)

     def exceptionEvent(self, frame, exception):
         if frame.getName() == "<module>":
             return
         print(
             "exception %s %s raised from %s @ %s"
             % (
                 exception.getType(),
                 str(exception.getValue()),
                 frame.getName(),
                 frame.getLineNumber(),
             )
         )
         print("tb: " + str(exception.getTraceback()))


 def f(x, y=None):
     if x > 0:
         return 2 + f(x - 2)
     return 35


 def g(x):
     return 1.134 / x


 def print_keyword_args(**kwargs):
     # kwargs is a dict of the keyword args passed to the function
     for key, value in kwargs.items():
         print("%s = %s" % (key, value))


 def total(initial=5, *numbers, **keywords):
     count = initial
     for number in numbers:
         count += number
     for key in keywords:
         count += keywords[key]
     return count


 if __name__ == "__main__":
     enable(LoggingTracer())
     f(5)
     f(5, 1)
     print_keyword_args(first_name="John", last_name="Doe")
     total(10, 1, 2, 3, vegetables=50, fruits=100)
     try:
         g(0)
     except:
         pass
     disable()
	import sys
	import inspect
	from collections import OrderedDict


	class TracebackFancy:
	def __init__(self, traceback):
	self.t = traceback

	def getFrame(self):
	return FrameFancy(self.t.tb_frame)

	def getLineNumber(self):
	return self.t.tb_lineno if self.t is not None else None

	def getNext(self):
	return TracebackFancy(self.t.tb_next)

	def __str__(self):
	if self.t is None:
	return ""
	str_self = "%s @ %s" % (self.getFrame().getName(), self.getLineNumber())
	return str_self + "\n" + self.getNext().__str__()


	class ExceptionFancy:
	def __init__(self, frame):
	self.etraceback = frame.f_exc_traceback
	self.etype = frame.exc_type
	self.evalue = frame.f_exc_value

	def __init__(self, tb, ty, va):
	self.etraceback = tb
	self.etype = ty
	self.evalue = va

	def getTraceback(self):
	return TracebackFancy(self.etraceback)

	def __nonzero__(self):
	return (
	self.etraceback is not None
	or self.etype is not None
	or self.evalue is not None
	)

	def getType(self):
	return str(self.etype)

	def getValue(self):
	return self.evalue


	class CodeFancy:
	def __init__(self, code):
	self.c = code

	def getArgCount(self):
	return self.c.co_argcount if self.c is not None else 0

	def getFilename(self):
	return self.c.co_filename if self.c is not None else ""

	def getVariables(self):
	return self.c.co_varnames if self.c is not None else []

	def getName(self):
	return self.c.co_name if self.c is not None else ""

	def getFileName(self):
	return self.c.co_filename if self.c is not None else ""


	class ArgsFancy:
	def __init__(self, frame, arginfo):
	self.f = frame
	self.a = arginfo

	def __str__(self):
	args, varargs, kwargs = self.getArgs(), self.getVarArgs(), self.getKWArgs()
	ret = ""
	count = 0
	size = len(args)
	for arg in args:
	ret = ret + ("%s = %s" % (arg, args[arg]))
	count = count + 1
	if count < size:
	ret = ret + ", "
	if varargs:
	if size > 0:
	ret = ret + " "
	ret = ret + "varargs are " + str(varargs)
	if kwargs:
	if size > 0:
	ret = ret + " "
	ret = ret + "kwargs are " + str(kwargs)
	return ret

	def getNumArgs(wantVarargs=False, wantKWArgs=False):
	args, varargs, keywords, values = self.a
	size = len(args)
	if varargs and wantVarargs:
	size = size + len(self.getVarArgs())
	if keywords and wantKWArgs:
	size = size + len(self.getKWArgs())
	return size

	def getArgs(self):
	args, _, _, values = self.a
	argWValues = OrderedDict()
	for arg in args:
	argWValues[arg] = values[arg]
	return argWValues

	def getVarArgs(self):
	_, vargs, _, _ = self.a
	if vargs:
	return self.f.f_locals[vargs]
	return ()

	def getKWArgs(self):
	_, _, kwargs, _ = self.a
	if kwargs:
	return self.f.f_locals[kwargs]
	return {}


	class FrameFancy:
	def __init__(self, frame):
	self.f = frame

	def getCaller(self):
	return FrameFancy(self.f.f_back)

	def getLineNumber(self):
	return self.f.f_lineno if self.f is not None else 0

	def getCodeInformation(self):
	return CodeFancy(self.f.f_code) if self.f is not None else None

	def getExceptionInfo(self):
	return ExceptionFancy(self.f) if self.f is not None else None

	def getName(self):
	return self.getCodeInformation().getName() if self.f is not None else ""

	def getFileName(self):
	return self.getCodeInformation().getFileName() if self.f is not None else ""

	def getLocals(self):
	return self.f.f_locals if self.f is not None else {}

	def getArgumentInfo(self):
	return (
	ArgsFancy(self.f, inspect.getargvalues(self.f))
	if self.f is not None
	else None
	)


	class TracerClass:
	def callEvent(self, frame):
	pass

	def lineEvent(self, frame):
	pass

	def returnEvent(self, frame, retval):
	pass

	def exceptionEvent(self, frame, exception, value, traceback):
	pass

	def cCallEvent(self, frame, cfunct):
	pass

	def cReturnEvent(self, frame, cfunct):
	pass

	def cExceptionEvent(self, frame, cfunct):
	pass


	tracer_impl = TracerClass()


	def the_tracer_entrypoint(frame, event, args):
	if tracer_impl is None:
	return None
	if event == "call":
	call_retval = tracer_impl.callEvent(FrameFancy(frame))
	if not call_retval:
	return None
	return the_tracer_entrypoint
	elif event == "line":
	line_retval = tracer_impl.lineEvent(FrameFancy(frame))
	if not line_retval:
	return None
	return the_tracer_entrypoint
	elif event == "return":
	tracer_impl.returnEvent(FrameFancy(frame), args)
	elif event == "exception":
	exty, exva, extb = args
	exception_retval = tracer_impl.exceptionEvent(
	FrameFancy(frame), ExceptionFancy(extb, exty, exva)
	)
	if not exception_retval:
	return None
	return the_tracer_entrypoint
	elif event == "c_call":
	tracer_impl.cCallEvent(FrameFancy(frame), args)
	elif event == "c_return":
	tracer_impl.cReturnEvent(FrameFancy(frame), args)
	elif event == "c_exception":
	tracer_impl.cExceptionEvent(FrameFancy(frame), args)
	return None


	def enable(t=None):
	global tracer_impl
	if t:
	tracer_impl = t
	sys.settrace(the_tracer_entrypoint)


	def disable():
	sys.settrace(None)


	class LoggingTracer:
	def callEvent(self, frame):
	print(
	"call "
	+ frame.getName()
	+ " from "
	+ frame.getCaller().getName()
	+ " @ "
	+ str(frame.getCaller().getLineNumber())
	+ " args are "
	+ str(frame.getArgumentInfo())
	)

	def lineEvent(self, frame):
	print(
	"running "
	+ frame.getName()
	+ " @ "
	+ str(frame.getLineNumber())
	+ " locals are "
	+ str(frame.getLocals())
	+ " in "
	+ frame.getFileName()
	)

	def returnEvent(self, frame, retval):
	print(
	"return from "
	+ frame.getName()
	+ " value is "
	+ str(retval)
	+ " locals are "
	+ str(frame.getLocals())
	)

	def exceptionEvent(self, frame, exception):
	print(
	"exception %s %s raised from %s @ %s"
	% (
	exception.getType(),
	str(exception.getValue()),
	frame.getName(),
	frame.getLineNumber(),
	)
	)
	print("tb: " + str(exception.getTraceback()))


	# the same functionality as LoggingTracer, but with a little more
	# lldb-specific smarts


	class LLDBAwareTracer:
	def callEvent(self, frame):
	if frame.getName() == "<module>":
	return
	if frame.getName() == "run_one_line":
	print(
	"call run_one_line(%s)"
	% (frame.getArgumentInfo().getArgs()["input_string"])
	)
	return
	if "Python.framework" in frame.getFileName():
	print("call into Python at " + frame.getName())
	return
	if (
	frame.getName() == "__init__"
	and frame.getCaller().getName() == "run_one_line"
	and frame.getCaller().getLineNumber() == 101
	):
	return False
	strout = "call " + frame.getName()
	if frame.getCaller().getFileName() == "":
	strout += " from LLDB - args are "
	args = frame.getArgumentInfo().getArgs()
	for arg in args:
	if arg == "dict" or arg == "internal_dict":
	continue
	strout = strout + ("%s = %s " % (arg, args[arg]))
	else:
	strout += (
	" from "
	+ frame.getCaller().getName()
	+ " @ "
	+ str(frame.getCaller().getLineNumber())
	+ " args are "
	+ str(frame.getArgumentInfo())
	)
	print(strout)

	def lineEvent(self, frame):
	if frame.getName() == "<module>":
	return
	if frame.getName() == "run_one_line":
	print(
	"running run_one_line(%s) @ %s"
	% (
	frame.getArgumentInfo().getArgs()["input_string"],
	frame.getLineNumber(),
	)
	)
	return
	if "Python.framework" in frame.getFileName():
	print(
	"running into Python at "
	+ frame.getName()
	+ " @ "
	+ str(frame.getLineNumber())
	)
	return
	strout = (
	"running "
	+ frame.getName()
	+ " @ "
	+ str(frame.getLineNumber())
	+ " locals are "
	)
	if frame.getCaller().getFileName() == "":
	locals = frame.getLocals()
	for local in locals:
	if local == "dict" or local == "internal_dict":
	continue
	strout = strout + ("%s = %s " % (local, locals[local]))
	else:
	strout = strout + str(frame.getLocals())
	strout = strout + " in " + frame.getFileName()
	print(strout)

	def returnEvent(self, frame, retval):
	if frame.getName() == "<module>":
	return
	if frame.getName() == "run_one_line":
	print(
	"return from run_one_line(%s) return value is %s"
	% (frame.getArgumentInfo().getArgs()["input_string"], retval)
	)
	return
	if "Python.framework" in frame.getFileName():
	print(
	"return from Python at "
	+ frame.getName()
	+ " return value is "
	+ str(retval)
	)
	return
	strout = (
	"return from "
	+ frame.getName()
	+ " return value is "
	+ str(retval)
	+ " locals are "
	)
	if frame.getCaller().getFileName() == "":
	locals = frame.getLocals()
	for local in locals:
	if local == "dict" or local == "internal_dict":
	continue
	strout = strout + ("%s = %s " % (local, locals[local]))
	else:
	strout = strout + str(frame.getLocals())
	strout = strout + " in " + frame.getFileName()
	print(strout)

	def exceptionEvent(self, frame, exception):
	if frame.getName() == "<module>":
	return
	print(
	"exception %s %s raised from %s @ %s"
	% (
	exception.getType(),
	str(exception.getValue()),
	frame.getName(),
	frame.getLineNumber(),
	)
	)
	print("tb: " + str(exception.getTraceback()))


	def f(x, y=None):
	if x > 0:
	return 2 + f(x - 2)
	return 35


	def g(x):
	return 1.134 / x


	def print_keyword_args(**kwargs):
	# kwargs is a dict of the keyword args passed to the function
	for key, value in kwargs.items():
	print("%s = %s" % (key, value))


	def total(initial=5, numbers, *keywords):
	count = initial
	for number in numbers:
	count += number
	for key in keywords:
	count += keywords[key]
	return count


	if __name__ == "__main__":
	enable(LoggingTracer())
	f(5)
	f(5, 1)
	print_keyword_args(first_name="John", last_name="Doe")
	total(10, 1, 2, 3, vegetables=50, fruits=100)
	try:
	g(0)
	except:
	pass
	disable()