lldb/examples/python/pytracer.py

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()