eric: comparison DebugClients/Python3/DebugBase.py

-:e2fa12bb0f53
+:be693f11da53
 self._mainThread = True
 self.breaks = self._dbgClient.breakpoints
 self.tracePythonLibs(0)
-self.__event = ""
+self.__isBroken = False
-self.__isBroken = ""
 self.cFrame = None
 # current frame we are at
 self.currentFrame = None
 This specialty is to check the connection to the debug server
 for new events (i.e. new breakpoints) while we are going through
 the code.
-@param frame The current stack frame.
+@param frame The current stack frame
-@param event The trace event (string)
+@type frame object
+@param event The trace event
+@type str
 @param arg The arguments
+@type depends on the previous event parameter
 @return local trace function
+@rtype trace function or None
+@exception bdb.BdbQuit
 """
 if self.quitting:
 return  # None
 # give the client a chance to push through new break points.
 self._dbgClient.eventPoll()
-self.__event == event
-self.__isBroken = False
 if event == 'line':
-return self.dispatch_line(frame)
+if self.stop_here(frame) or self.break_here(frame):
+self.user_line(frame)
+if self.quitting:
+raise bdb.BdbQuit
+return
 if event == 'call':
-return self.dispatch_call(frame, arg)
+if self.botframe is None:
-if event == 'return':
+# First call of dispatch since reset()
-return self.dispatch_return(frame, arg)
+# (CT) Note that this may also be None!
-if event == 'exception':
+self.botframe = frame.f_back
-return self.dispatch_exception(frame, arg)
+return self.trace_dispatch
-if event == 'c_call':
-return self.trace_dispatch
+if not (self.stop_here(frame) or self.break_anywhere(frame)):
-if event == 'c_exception':
+# No need to trace this function
-return self.trace_dispatch
+return
-if event == 'c_return':
-return self.trace_dispatch
-print('bdb.Bdb.dispatch: unknown debugging event: ', repr(event))   # __IGNORE_WARNING__
-return self.trace_dispatch
-def dispatch_line(self, frame):
-"""
-Public method reimplemented from bdb.py to do some special things.
-This speciality is to check the connection to the debug server
-for new events (i.e. new breakpoints) while we are going through
-the code.
-@param frame The current stack frame.
-@return local trace function
-@exception bdb.BdbQuit raised to indicate the end of the debug session
-"""
-if self.stop_here(frame) or self.break_here(frame):
-self.user_line(frame)
 if self.quitting:
 raise bdb.BdbQuit
 return self.trace_dispatch
-def dispatch_return(self, frame, arg):
+if event == 'return':
-"""
+if self.stop_here(frame) or frame == self.returnframe:
-Public method reimplemented from bdb.py to handle passive mode cleanly.
+# Ignore return events in generator except when stepping.
+if self.stopframe and frame.f_code.co_flags & CO_GENERATOR:
-@param frame The current stack frame.
+return
-@param arg The arguments
+# The program has finished if we have just left the first frame
-@return local trace function
+if frame == self._dbgClient.mainFrame and \
-@exception bdb.BdbQuit raised to indicate the end of the debug session
+self._mainThread:
-"""
+atexit._run_exitfuncs()
-if self.stop_here(frame) or frame == self.returnframe:
+self._dbgClient.progTerminated(arg)
-# Ignore return events in generator except when stepping.
+elif frame is not self.stepFrame:
-if self.stopframe and frame.f_code.co_flags & CO_GENERATOR:
+self.stepFrame = None
-return self.trace_dispatch
+self.user_line(frame)
-self.user_return(frame, arg)
 if self.quitting and not self._dbgClient.passive:
 raise bdb.BdbQuit
-return self.trace_dispatch
+return
-def dispatch_exception(self, frame, arg):
+if event == 'exception':
-"""
+if not self.__skipFrame(frame):
-Public method reimplemented from bdb.py to always call user_exception.
+# When stepping with next/until/return in a generator frame,
+# skip the internal StopIteration exception (with no traceback)
-@param frame The current stack frame.
+# triggered by a subiterator run with the 'yield from'
-@param arg The arguments
+# statement.
-@return local trace function
+if not (frame.f_code.co_flags & CO_GENERATOR and
-@exception bdb.BdbQuit raised to indicate the end of the debug session
+arg[0] is StopIteration and arg[2] is None):
-"""
+self.user_exception(frame, arg)
-if not self.__skipFrame(frame):
+if self.quitting:
-# When stepping with next/until/return in a generator frame,
+raise bdb.BdbQuit
-# skip the internal StopIteration exception (with no traceback)
+# Stop at the StopIteration or GeneratorExit exception when the user
-# triggered by a subiterator run with the 'yield from'
+# has set stopframe in a generator by issuing a return command, or a
-# statement.
+# next/until command at the last statement in the generator before the
-if not (frame.f_code.co_flags & CO_GENERATOR and
+# exception.
-arg[0] is StopIteration and arg[2] is None):
+elif (self.stopframe and frame is not self.stopframe and
+self.stopframe.f_code.co_flags & CO_GENERATOR and
+arg[0] in (StopIteration, GeneratorExit)):
 self.user_exception(frame, arg)
 if self.quitting:
 raise bdb.BdbQuit
-# Stop at the StopIteration or GeneratorExit exception when the user
+return
-# has set stopframe in a generator by issuing a return command, or a
-# next/until command at the last statement in the generator before the
+if event == 'c_call':
-# exception.
+return
-elif (self.stopframe and frame is not self.stopframe and
+if event == 'c_exception':
-self.stopframe.f_code.co_flags & CO_GENERATOR and
+return
-arg[0] in (StopIteration, GeneratorExit)):
+if event == 'c_return':
-self.user_exception(frame, arg)
+return
-if self.quitting:
+print('bdb.Bdb.dispatch: unknown debugging event: ', repr(event))   # __IGNORE_WARNING__
-raise bdb.BdbQuit
 return self.trace_dispatch
 def set_trace(self, frame=None):
 """
 Public method reimplemented from bdb.py to do some special setup.
 self.__isBroken = True
 self._dbgClient.write('{0}{1}\n'.format(ResponseLine, str(stack)))
 self._dbgClient.eventLoop()
+self.__isBroken = False
 def user_exception(self, frame, excinfo, unhandled=False):
 """
 Public method reimplemented to report an exception to the debug server.
 stack.append(tb.tb_frame)
 tb = tb.tb_next
 tb = None
 return stack
-def user_return(self, frame, retval):
-"""
-Public method reimplemented to report program termination to the debug
-server.
-@param frame the frame object
-@param retval the return value of the program
-"""
-# The program has finished if we have just left the first frame.
-if frame == self._dbgClient.mainFrame and \
-self._mainThread:
-atexit._run_exitfuncs()
-self._dbgClient.progTerminated(retval)
-elif frame is not self.stepFrame:
-self.stepFrame = None
-self.user_line(frame)
 def stop_here(self, frame):
 """
 Public method reimplemented to filter out debugger files.
 Tracing is turned off for files that are part of the
 def isBroken(self):
 """
 Public method to return the broken state of the debugger.
-@return flag indicating the broken state (boolean)
+@return flag indicating the broken state
+@rtype bool
 """
 return self.__isBroken
-def getEvent(self):
-"""
-Protected method to return the last debugger event.
-@return last debugger event (string)
-"""
-return self.__event
 #
 # eflag: noqa = M702

Mercurial Repositories > eric / file comparison

comparison: DebugClients/Python3/DebugBase.py

DebugClients/Python3/DebugBase.py