Python虚拟机中调试器的实现原理是什么

def m99():    for i in range(1, 10):        for j in range(1, i + 1):            print(f"{i}x{j}={i*j}", end='	')        print()if __name__ == '__main__':    m99()

import sysfile = sys.argv[1]with open(file, "r+") as fp:    code = fp.read()lines = code.split("
")def do_line(frame, event, arg):    print("debugging line:", lines[frame.f_lineno - 1])    return debugdef debug(frame, event, arg):    if event == "line":        while True:            _ = input("(Pdb)")            if _ == 'n':                return do_line(frame, event, arg)            elif _.startswith('p'):                _, v = _.split()                v = eval(v, frame.f_globals, frame.f_locals)                print(v)            elif _ == 'q':                sys.exit(0)    return debugif __name__ == '__main__':    sys.settrace(debug)    exec(code, None, None)    sys.settrace(None)

    def run(self, cmd, globals=None, locals=None):        """Debug a statement executed via the exec() function.        globals defaults to __main__.dict; locals defaults to globals.        """        if globals is None:            import __main__            globals = __main__.__dict__        if locals is None:            locals = globals        self.reset()        if isinstance(cmd, str):            cmd = compile(cmd, "<string>", "exec")        sys.settrace(self.trace_dispatch)        try:            exec(cmd, globals, locals)        except BdbQuit:            pass        finally:            self.quitting = True            sys.settrace(None)

    def trace_dispatch(self, frame, event, arg):        """Dispatch a trace function for debugged frames based on the event.        This function is installed as the trace function for debugged        frames. Its return value is the new trace function, which is        usually itself. The default implementation decides how to        dispatch a frame, depending on the type of event (passed in as a        string) that is about to be executed.        The event can be one of the following:            line: A new line of code is going to be executed.            call: A function is about to be called or another code block                  is entered.            return: A function or other code block is about to return.            exception: An exception has occurred.            c_call: A C function is about to be called.            c_return: A C function has returned.            c_exception: A C function has raised an exception.        For the Python events, specialized functions (see the dispatch_*()        methods) are called.  For the C events, no action is taken.        The arg parameter depends on the previous event.        """        if self.quitting:            return # None        if event == 'line':            print("In line")            return self.dispatch_line(frame)        if event == 'call':            print("In call")            return self.dispatch_call(frame, arg)        if event == 'return':            print("In return")            return self.dispatch_return(frame, arg)        if event == 'exception':            print("In execption")            return self.dispatch_exception(frame, arg)        if event == 'c_call':            print("In c_call")            return self.trace_dispatch        if event == 'c_exception':            print("In c_exception")            return self.trace_dispatch        if event == 'c_return':            print("In c_return")            return self.trace_dispatch        print('bdb.Bdb.dispatch: unknown debugging event:', repr(event))        return self.trace_dispatch

    def dispatch_line(self, frame):        """Invoke user function and return trace function for line event.        If the debugger stops on the current line, invoke        self.user_line(). Raise BdbQuit if self.quitting is set.        Return self.trace_dispatch to continue tracing in this scope.        """        if self.stop_here(frame) or self.break_here(frame):            self.user_line(frame)            if self.quitting: raise BdbQuit        return self.trace_dispatch

    def cmdloop(self, intro=None):        """Repeatedly issue a prompt, accept input, parse an initial prefix        off the received input, and dispatch to action methods, passing them        the remainder of the line as argument.        """        print("In cmdloop")        self.preloop()        if self.use_rawinput and self.completekey:            try:                import readline                self.old_completer = readline.get_completer()                readline.set_completer(self.complete)                readline.parse_and_bind(self.completekey+": complete")            except ImportError:                pass        try:            if intro is not None:                self.intro = intro            print(f"{self.intro = }")            if self.intro:                self.stdout.write(str(self.intro)+"
")            stop = None            while not stop:                print(f"{self.cmdqueue = }")                if self.cmdqueue:                    line = self.cmdqueue.pop(0)                else:                    print(f"{self.prompt = } {self.use_rawinput}")                    if self.use_rawinput:                        try:                            # 核心逻辑就在这里 不断的要求输入然后进行处理                            line = input(self.prompt) # self.prompt = '(Pdb)'                        except EOFError:                            line = 'EOF'                    else:                        self.stdout.write(self.prompt)                        self.stdout.flush()                        line = self.stdin.readline()                        if not len(line):                            line = 'EOF'                        else:                            line = line.rstrip('
')                line = self.precmd(line)                stop = self.onecmd(line) # 这个函数就是处理我们输入的字符串的比如 p n 等等                stop = self.postcmd(stop, line)            self.postloop()        finally:            if self.use_rawinput and self.completekey:                try:                    import readline                    readline.set_completer(self.old_completer)                except ImportError:                    pass

    def onecmd(self, line):        """Interpret the argument as though it had been typed in response        to the prompt.        This may be overridden, but should not normally need to be;        see the precmd() and postcmd() methods for useful execution hooks.        The return value is a flag indicating whether interpretation of        commands by the interpreter should stop.        """        cmd, arg, line = self.parseline(line)        if not line:            return self.emptyline()        if cmd is None:            return self.default(line)        self.lastcmd = line        if line == 'EOF' :            self.lastcmd = ''        if cmd == '':            return self.default(line)        else:            try:                # 根据下面的代码可以分析了解到如果我们执行命令 p 执行的函数为 do_p                func = getattr(self, 'do_' + cmd)            except AttributeError:                return self.default(line)            return func(arg)

    def do_p(self, arg):        """p expression        Print the value of the expression.        """        self._msg_val_func(arg, repr)    def _msg_val_func(self, arg, func):        try:            val = self._getval(arg)        except:            return  # _getval() has displayed the error        try:            self.message(func(val))        except:            self._error_exc()    def _getval(self, arg):        try:            # 看到这里就破案了这不是和我们自己实现的 pdb 获取变量的方式一样嘛 都是            # 使用当前执行栈帧的全局和局部变量交给 eval 函数处理 并且将它的返回值输出            return eval(arg, self.curframe.f_globals, self.curframe_locals)        except:            self._error_exc()            raise