eric: comparison DebugClients/Python3/DebugBase.py

-:fb9168c2e069
+:8c48f5e0cd92
 import ctypes
 import _thread
 import time
 from inspect import CO_GENERATOR
-from DebugProtocol import ResponseClearWatch, ResponseClearBreak, \
-ResponseLine, ResponseSyntax, ResponseException, CallTrace
 from DebugUtilities import getargvalues, formatargvalues
 from BreakpointWatch import Breakpoint, Watch
 gRecursionLimit = 64
 """
 cf = self.currentFrame
 while cf is not None and frmnr > 0:
 cf = cf.f_back
 frmnr -= 1
+try:
+if "__pypy__" in sys.builtin_module_names:
+import __pypy__
+__pypy__.locals_to_fast(cf)
+return
+except Exception:
+pass
 ctypes.pythonapi.PyFrame_LocalsToFast(
 ctypes.py_object(cf),
 ctypes.c_int(0))
 def step(self, traceMode):
 @type frame object
 @param toFrame destination frame
 @type frame object
 """
 if not self.__skipFrame(fromFrame) and not self.__skipFrame(toFrame):
-fromStr = "{0}:{1}:{2}".format(
+fromInfo = {
-self._dbgClient.absPath(self.fix_frame_filename(fromFrame)),
+"filename": self._dbgClient.absPath(
-fromFrame.f_lineno,
+self.fix_frame_filename(fromFrame)),
-fromFrame.f_code.co_name)
+"linenumber": fromFrame.f_lineno,
-toStr = "{0}:{1}:{2}".format(
+"codename": fromFrame.f_code.co_name,
-self._dbgClient.absPath(self.fix_frame_filename(toFrame)),
+}
-toFrame.f_lineno,
+toInfo = {
-toFrame.f_code.co_name)
+"filename": self._dbgClient.absPath(
-self._dbgClient.write("{0}{1}@@{2}@@{3}\n".format(
+self.fix_frame_filename(toFrame)),
-CallTrace, event[0], fromStr, toStr))
+"linenumber": toFrame.f_lineno,
+"codename": toFrame.f_code.co_name,
+}
+self._dbgClient.sendCallTrace(event, fromInfo, toInfo)
 def trace_dispatch(self, frame, event, arg):
 """
 Public method reimplemented from bdb.py to do some special things.
 if self.stop_here(frame):
 # Ignore return events in generator except when stepping.
 if self.stopframe and frame.f_code.co_flags & CO_GENERATOR:
 return
 # The program has finished if we have just left the first frame
-if frame == self._dbgClient.mainFrame and \
+if (frame == self._dbgClient.mainFrame and
-self._mainThread:
+self._mainThread):
 atexit._run_exitfuncs()
 self._dbgClient.progTerminated(arg)
 if self.quitting and not self._dbgClient.passive:
 raise SystemExit
 return
 if event == 'c_exception':
 return
 if event == 'c_return':
 return
-print('bdb.Bdb.dispatch: unknown debugging event: ', repr(event))   # __IGNORE_WARNING__
+print('DebugBase.trace_dispatch:'       # __IGNORE_WARNING__
+' unknown debugging event: ',
+repr(event))
 return self.trace_dispatch
 def set_trace(self, frame=None):
 """
 Public method to start debugging from 'frame'.
 @type str
 @param lineno linenumber of the bp
 @type int
 """
 Breakpoint.clear_break(filename, lineno)
-self._dbgClient.write('{0}{1},{2:d}\n'.format(
+self._dbgClient.sendClearTemporaryBreakpoint(filename, lineno)
-ResponseClearBreak, filename, lineno))
 def __do_clearWatch(self, cond):
 """
 Private method called to clear a temporary watch expression.
 @param cond expression of the watch expression to be cleared
 @type str
 """
 Watch.clear_watch(cond)
-self._dbgClient.write('{0}{1}\n'.format(ResponseClearWatch, cond))
+self._dbgClient.sendClearTemporaryWatch(cond)
 def getStack(self):
 """
 Public method to get the stack.
 else:
 fr = fr.f_back
 self.__isBroken = True
-self._dbgClient.write('{0}{1}\n'.format(ResponseLine, str(stack)))
+self._dbgClient.sendResponseLine(stack)
 self._dbgClient.eventLoop()
 self.__isBroken = False
 def user_exception(self, frame, excinfo, unhandled=False):
 return
 if exctype == SystemExit:
 atexit._run_exitfuncs()
 if excval is None:
-excval = 0
+exitcode = 0
+message = ""
 elif isinstance(excval, str):
-self._dbgClient.write(excval)
+exitcode = 1
-excval = 1
+message = excval
 elif isinstance(excval, bytes):
-self._dbgClient.write(excval.decode())
+exitcode = 1
-excval = 1
+message = excval.decode()
-if isinstance(excval, int):
+elif isinstance(excval, int):
-self._dbgClient.progTerminated(excval)
+exitcode = excval
+message = ""
+elif isinstance(excval, SystemExit):
+code = excval.code
+if isinstance(code, str):
+exitcode = 1
+message = code
+elif isinstance(code, bytes):
+exitcode = 1
+message = code.decode()
+elif isinstance(code, int):
+exitcode = code
+message = ""
+else:
+exitcode = 1
+message = str(code)
 else:
-self._dbgClient.progTerminated(excval.code)
+exitcode = 1
+message = str(excval)
+self._dbgClient.progTerminated(exitcode, message)
 return
 if exctype in [SyntaxError, IndentationError]:
 try:
 message = str(excval)
 filename = excval.filename
-linenr = excval.lineno
+lineno = excval.lineno
-charnr = excval.offset
+charno = excval.offset
+realSyntaxError = os.path.exists(filename)
 except (AttributeError, ValueError):
-exclist = []
+message = ""
+filename = ""
+lineno = 0
+charno = 0
 realSyntaxError = True
-else:
-exclist = [message, [filename, linenr, charnr]]
-realSyntaxError = os.path.exists(filename)
 if realSyntaxError:
-self._dbgClient.write("{0}{1}\n".format(
+self._dbgClient.sendSyntaxError(
-ResponseSyntax, str(exclist)))
+message, filename, lineno, charno)
 self._dbgClient.eventLoop()
 return
 self.skipFrames = 0
 if (exctype == RuntimeError and
 if unhandled:
 exctypetxt = "unhandled {0!s}".format(str(exctype))
 else:
 exctypetxt = str(exctype)
-try:
-exclist = [exctypetxt, str(excval)]
+stack = []
-except TypeError:
-exclist = [exctypetxt, str(excval)]
 if exctb:
 frlist = self.__extract_stack(exctb)
 frlist.reverse()
 self.currentFrame = frlist[0]
 except Exception:
 fargs = ""
 else:
 fargs = ""
-exclist.append([filename, linenr, ffunc, fargs])
+stack.append([filename, linenr, ffunc, fargs])
-self._dbgClient.write("{0}{1}\n".format(
+self._dbgClient.sendException(exctypetxt, str(excval), stack)
-ResponseException, str(exclist)))
 if exctb is None:
 return
 self._dbgClient.eventLoop()
 def tracePythonLibs(self, enable):
 """
 Public method to update the settings to trace into Python libraries.
 @param enable flag to debug into Python libraries
-@type int
+@type bool
 """
 pathsToSkip = list(self.pathsToSkip)
 # don't trace into Python library?
 if enable:
 pathsToSkip = [x for x in pathsToSkip if not x.endswith(

Mercurial Repositories > eric / file comparison

comparison: DebugClients/Python3/DebugBase.py

DebugClients/Python3/DebugBase.py