eric: comparison DebugClients/Python3/DebugClientBase.py

-:d97f2e05ae1b
+:9445c7cb991f
 import os
 import time
 import imp
 import re
 import atexit
+import signal
+import inspect
 import DebugProtocol
 import DebugClientCapabilities
 from DebugBase import setRecursionLimit, printerr   # __IGNORE_WARNING__
 self.attachThread(mainThread=True)
 # set the system exception handling function to ensure, that
 # we report on all unhandled exceptions
 sys.excepthook = self.__unhandled_exception
+self.__interceptSignals()
 # clear all old breakpoints, they'll get set after we have
 # started
 self.mainThread.clear_all_breaks()
 self.attachThread(mainThread=True)
 # set the system exception handling function to ensure, that
 # we report on all unhandled exceptions
 sys.excepthook = self.__unhandled_exception
+self.__interceptSignals()
 self.mainThread.tracePython = False
 self.debugMod.__dict__['__file__'] = sys.argv[0]
 sys.modules['__main__'] = self.debugMod
 exec(code, self.debugMod.__dict__)
 except SystemExit as exc:
 res = exc.code
 atexit._run_exitfuncs()
 self.writestream.flush()
-self.progTerminated(res)
+self.progTerminated(res, exit=True)
 return
 if cmd == DebugProtocol.RequestProfile:
 sys.setprofile(None)
 import PyProfile
 os.chdir(wd)
 # set the system exception handling function to ensure, that
 # we report on all unhandled exceptions
 sys.excepthook = self.__unhandled_exception
+self.__interceptSignals()
 # generate a profile object
 self.prof = PyProfile.PyProfile(sys.argv[0])
 if int(erase):
 except SystemExit as exc:
 res = exc.code
 atexit._run_exitfuncs()
 self.prof.save()
 self.writestream.flush()
-self.progTerminated(res)
+self.progTerminated(res, exit=True)
 return
 if cmd == DebugProtocol.RequestCoverage:
 from coverage import coverage
 sys.argv = []
 os.chdir(wd)
 # set the system exception handling function to ensure, that
 # we report on all unhandled exceptions
 sys.excepthook = self.__unhandled_exception
+self.__interceptSignals()
 # generate a coverage object
 self.cover = coverage(
 auto_data=True,
 data_file="{0}.coverage".format(
 res = exc.code
 atexit._run_exitfuncs()
 self.cover.stop()
 self.cover.save()
 self.writestream.flush()
-self.progTerminated(res)
+self.progTerminated(res, exit=True)
 return
 if cmd == DebugProtocol.RequestShutdown:
 self.sessionClose()
 return
 failed = eval(failed)
 # set the system exception handling function to ensure, that
 # we report on all unhandled exceptions
 sys.excepthook = self.__unhandled_exception
+self.__interceptSignals()
 try:
 import unittest
 utModule = imp.load_source(tn, fn)
 try:
 @param excval data about the exception
 @param exctb traceback for the exception
 """
 self.mainThread.user_exception(None, (exctype, excval, exctb), True)
+def __interceptSignals(self):
+"""
+Private method to intercept common signals.
+"""
+for signum in [
+signal.SIGABRT,                 # abnormal termination
+signal.SIGFPE,                  # floating point exception
+signal.SIGILL,                  # illegal instruction
+signal.SIGSEGV,                 # segmentation violation
+]:
+signal.signal(signum, self.__signalHandler)
+def __signalHandler(self, signalNumber, stackFrame):
+"""
+Private method to handle signals.
+@param signalNumber number of the signal to be handled
+@type int
+@param stack frame current stack frame
+@type frame object
+"""
+if signalNumber == signal.SIGABRT:
+message = "Abnormal Termination"
+elif signalNumber == signal.SIGFPE:
+message = "Floating Point Exception"
+elif signalNumber == signal.SIGILL:
+message = "Illegal Instruction"
+elif signalNumber == signal.SIGSEGV:
+message = "Segmentation Violation"
+else:
+message = "Unknown Signal '{0}'".format(signalNumber)
+filename = self.absPath(stackFrame)
+linenr = stackFrame.f_lineno
+ffunc = stackFrame.f_code.co_name
+if ffunc == '?':
+ffunc = ''
+if ffunc and not ffunc.startswith("<"):
+argInfo = inspect.getargvalues(stackFrame)
+try:
+fargs = inspect.formatargvalues(
+argInfo.args, argInfo.varargs,
+argInfo.keywords, argInfo.locals)
+except Exception:
+fargs = ""
+else:
+fargs = ""
+siglist = [message, [filename, linenr, ffunc, fargs]]
+self.write("{0}{1}".format(DebugProtocol.ResponseSignal, str(siglist)))
 def absPath(self, fn):
 """
 Public method to convert a filename to an absolute name.
 sys.path is used as a set of possible prefixes. The name stays
 @return flag indicating a running debug session (boolean)
 """
 return self.running
-def progTerminated(self, status):
+def progTerminated(self, status, exit=False):
 """
 Public method to tell the debugger that the program has terminated.
-@param status the return status
+@param status return status
+@param exit flag indicating to perform a sys.exit()
+@type bool
 """
 if status is None:
 status = 0
 else:
 try:
 if self.running:
 self.set_quit()
 self.running = None
 self.write('{0}{1:d}\n'.format(DebugProtocol.ResponseExit, status))
+if exit:
+sys.exit(status)
 # reset coding
 self.__coding = self.defaultCoding
 def __dumpVariables(self, frmnr, scope, filter):
 self.mainThread.tracePython = tracePython
 # set the system exception handling function to ensure, that
 # we report on all unhandled exceptions
 sys.excepthook = self.__unhandled_exception
+self.__interceptSignals()
 # now start debugging
 if enableTrace:
 self.mainThread.set_trace()
 self.mainThread.tracePython = tracePython
 # set the system exception handling function to ensure, that
 # we report on all unhandled exceptions
 sys.excepthook = self.__unhandled_exception
+self.__interceptSignals()
 # This will eventually enter a local event loop.
 # Note the use of backquotes to cause a repr of self.running. The
 # need for this is on Windows os where backslash is the path separator.
 # They will get inadvertantly stripped away during the eval causing

Mercurial Repositories > eric / file comparison

comparison: DebugClients/Python3/DebugClientBase.py

DebugClients/Python3/DebugClientBase.py