eric: comparison DebugClients/Python/DebugClientBase.py

-:889ed5ff7a68
+:a094eee9f862
 import atexit
 import signal
 import inspect
-import DebugProtocol
 import DebugClientCapabilities
 from DebugBase import setRecursionLimit, printerr   # __IGNORE_WARNING__
 from AsyncFile import AsyncFile, AsyncPendingWrite
 from DebugConfig import ConfigVarTypeStrings
 from FlexCompleter import Completer
+from DebugUtilities import prepareJsonCommand
 DebugClientInstance = None
 ###############################################################################
 @param prompt prompt to be shown. (string)
 @param echo flag indicating echoing of the input (boolean)
 @return result of the raw_input() call
 """
-if DebugClientInstance is None or DebugClientInstance.redirect == 0:
+if DebugClientInstance is None or not DebugClientInstance.redirect:
 return DebugClientOrigRawInput(prompt)
 return DebugClientInstance.raw_input(prompt, echo)
 # Use our own raw_input().
 def __init__(self):
 """
 Constructor
 """
 self.breakpoints = {}
-self.redirect = 1
+self.redirect = True
+self.__receiveBuffer = ""
 # The next couple of members are needed for the threaded version.
 # For this base class they contain static values for the non threaded
 # debugger
 # The list of regexp objects to filter variables against
 self.globalsFilterObjects = []
 self.localsFilterObjects = []
-self.pendingResponse = DebugProtocol.ResponseOK
 self._fncache = {}
 self.dircache = []
-self.inRawMode = 0
 self.mainProcStr = None     # used for the passive mode
-self.passive = 0            # used to indicate the passive mode
+self.passive = False        # used to indicate the passive mode
 self.running = None
 self.test = None
-self.tracePython = 0
+self.tracePython = False
-self.debugging = 0
+self.debugging = False
 self.fork_auto = False
 self.fork_child = False
 self.readstream = None
 d["broken"] = self.isBroken()
 else:
 d["broken"] = False
 threadList.append(d)
-self.write('%s%s\n' % (DebugProtocol.ResponseThreadList,
+self.sendJsonCommand("ResponseThreadList", {
-unicode((currentId, threadList))))
+"currentID": currentId,
+"threadList": threadList,
+})
 def raw_input(self, prompt, echo):
 """
 Public method to implement raw_input() using the event loop.
 @param prompt the prompt to be shown (string)
 @param echo Flag indicating echoing of the input (boolean)
 @return the entered string
 """
-self.write("%s%s\n" % (DebugProtocol.ResponseRaw,
+self.sendJsonCommand("RequestRaw", {
-unicode((prompt, echo))))
+"prompt": prompt,
-self.inRawMode = 1
+"echo": echo,
+})
 self.eventLoop(True)
 return self.rawLine
 def input(self, prompt):
 """
 @param prompt the prompt to be shown (string)
 @return the entered string evaluated as a Python expresion
 """
 return eval(self.raw_input(prompt, 1))
-def __exceptionRaised(self):
+def sessionClose(self, exit=True):
-"""
-Private method called in the case of an exception.
-It ensures that the debug server is informed of the raised exception.
-"""
-self.pendingResponse = DebugProtocol.ResponseException
-def sessionClose(self, exit=1):
 """
 Public method to close the session with the debugger and optionally
 terminate.
 @param exit flag indicating to terminate (boolean)
 try:
 self.set_quit()
 except Exception:
 pass
-# clean up asyncio.
+self.debugging = False
-self.disconnect()
-self.debugging = 0
 # make sure we close down our end of the socket
 # might be overkill as normally stdin, stdout and stderr
 # SHOULD be closed on exit, but it does not hurt to do it here
-self.readstream.close(1)
+self.readstream.close(True)
-self.writestream.close(1)
+self.writestream.close(True)
-self.errorstream.close(1)
+self.errorstream.close(True)
 if exit:
 # Ok, go away.
 sys.exit()
 # Remove any newline.
 if line[-1] == '\n':
 line = line[:-1]
 ##        printerr(line)          ##debug
-eoc = line.find('<')
+self.handleJsonCommand(line)
-if eoc >= 0 and line[0] == '>':
+def handleJsonCommand(self, jsonStr):
-# Get the command part and any argument.
+"""
-cmd = line[:eoc + 1]
+Public method to handle a command serialized as a JSON string.
-arg = line[eoc + 1:]
+@param jsonStr string containing the command received from the IDE
-if cmd == DebugProtocol.RequestVariables:
+@type str
-frmnr, scope, filter = eval(arg)
+"""
-self.__dumpVariables(int(frmnr), int(scope), filter)
+import json
-return
+try:
-if cmd == DebugProtocol.RequestVariable:
+commandDict = json.loads(jsonStr.strip())
-var, frmnr, scope, filter = eval(arg)
+except json.JSONDecodeError as err:
-self.__dumpVariable(var, int(frmnr), int(scope), filter)
+printerr(str(err))
 return
-if cmd == DebugProtocol.RequestThreadList:
+method = commandDict["method"]
-self.__dumpThreadList()
+params = commandDict["params"]
-return
+if method == "RequestVariables":
-if cmd == DebugProtocol.RequestThreadSet:
+self.__dumpVariables(
-tid = eval(arg)
+params["frameNumber"], params["scope"], params["filters"])
-if tid in self.threads:
-self.setCurrentThread(tid)
+elif method == "RequestVariable":
-self.write(DebugProtocol.ResponseThreadSet + '\n')
+self.__dumpVariable(
-stack = self.currentThread.getStack()
+params["variable"], params["frameNumber"],
-self.write('%s%s\n' % (DebugProtocol.ResponseStack,
+params["scope"], params["filters"])
-unicode(stack)))
-return
+elif method == "RequestThreadList":
+self.__dumpThreadList()
-if cmd == DebugProtocol.RequestStep:
-self.currentThread.step(1)
+elif method == "RequestThreadSet":
-self.eventExit = 1
+if params["threadID"] in self.threads:
-return
+self.setCurrentThread(params["threadID"])
+self.sendJsonCommand("ResponseThreadSet", {})
-if cmd == DebugProtocol.RequestStepOver:
+stack = self.currentThread.getStack()
-self.currentThread.step(0)
+self.sendJsonCommand("ResponseStack", {
-self.eventExit = 1
+"stack": stack,
-return
+})
-if cmd == DebugProtocol.RequestStepOut:
+elif method == "RequestCapabilities":
-self.currentThread.stepOut()
+self.sendJsonCommand("ResponseCapabilities", {
-self.eventExit = 1
+"capabilities": self.__clientCapabilities(),
-return
+"clientType": "Python3"
+})
-if cmd == DebugProtocol.RequestStepQuit:
-if self.passive:
+elif method == "RequestBanner":
-self.progTerminated(42)
+self.sendJsonCommand("ResponseBanner", {
+"version": "Python {0}".format(sys.version),
+"platform": socket.gethostname(),
+"dbgclient": self.variant,
+})
+elif method == "RequestSetFilter":
+self.__generateFilterObjects(params["scope"], params["filter"])
+elif method == "RequestCallTrace":
+if self.debugging:
+self.callTraceEnabled = params["enable"]
+else:
+self.__newCallTraceEnabled = params["enable"]
+# remember for later
+elif method == "RequestEnvironment":
+for key, value in params["environment"].items():
+if key.endswith("+"):
+if key[:-1] in os.environ:
+os.environ[key[:-1]] += value
+else:
+os.environ[key[:-1]] = value
 else:
-self.set_quit()
+os.environ[key] = value
-self.eventExit = 1
-return
+elif method == "RequestLoad":
+self._fncache = {}
-if cmd == DebugProtocol.RequestContinue:
+self.dircache = []
-special = int(arg)
+sys.argv = []
-self.currentThread.go(special)
+params["filename"] = params["filename"].encode(
-self.eventExit = 1
+sys.getfilesystemencoding())
-return
+self.__setCoding(params["filename"])
+sys.argv.append(params["filename"])
-if cmd == DebugProtocol.RequestOK:
+sys.argv.extend(params["argv"])
-self.write(self.pendingResponse + '\n')
+sys.path = self.__getSysPath(os.path.dirname(sys.argv[0]))
-self.pendingResponse = DebugProtocol.ResponseOK
+if params["workdir"] == '':
-return
+os.chdir(sys.path[1])
+else:
-if cmd == DebugProtocol.RequestCallTrace:
+os.chdir(params["workdir"])
-if arg.strip().lower() == "on":
-callTraceEnabled = True
+self.running = sys.argv[0]
+self.mainFrame = None
+self.debugging = True
+self.fork_auto = params["autofork"]
+self.fork_child = params["forkChild"]
+self.threads.clear()
+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.mainThread.tracePython = params["traceInterpreter"]
+# This will eventually enter a local event loop.
+self.debugMod.__dict__['__file__'] = self.running
+sys.modules['__main__'] = self.debugMod
+self.callTraceEnabled = self.__newCallTraceEnabled
+res = self.mainThread.run(
+'execfile(' + repr(self.running) + ')',
+self.debugMod.__dict__)
+self.progTerminated(res)
+elif method == "RequestRun":
+sys.argv = []
+params["filename"] = params["filename"].encode(
+sys.getfilesystemencoding())
+self.__setCoding(params["filename"])
+sys.argv.append(params["filename"])
+sys.argv.extend(params["argv"])
+sys.path = self.__getSysPath(os.path.dirname(sys.argv[0]))
+if params["workdir"] == '':
+os.chdir(sys.path[1])
+else:
+os.chdir(params["workdir"])
+self.running = sys.argv[0]
+self.mainFrame = None
+self.botframe = None
+self.fork_auto = params["autofork"]
+self.fork_child = params["forkChild"]
+self.threads.clear()
+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
+res = 0
+try:
+execfile(sys.argv[0], self.debugMod.__dict__)
+except SystemExit as exc:
+res = exc.code
+atexit._run_exitfuncs()
+self.writestream.flush()
+self.progTerminated(res)
+elif method == "RequestCoverage":
+from coverage import coverage
+sys.argv = []
+params["filename"] = params["filename"].encode(
+sys.getfilesystemencoding())
+self.__setCoding(params["filename"])
+sys.argv.append(params["filename"])
+sys.argv.extend(params["argv"])
+sys.path = self.__getSysPath(os.path.dirname(sys.argv[0]))
+if params["workdir"] == '':
+os.chdir(sys.path[1])
+else:
+os.chdir(params["workdir"])
+# 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="%s.coverage" % os.path.splitext(sys.argv[0])[0])
+if params["erase"]:
+self.cover.erase()
+sys.modules['__main__'] = self.debugMod
+self.debugMod.__dict__['__file__'] = sys.argv[0]
+self.running = sys.argv[0]
+res = 0
+self.cover.start()
+try:
+execfile(sys.argv[0], self.debugMod.__dict__)
+except SystemExit as exc:
+res = exc.code
+atexit._run_exitfuncs()
+self.cover.stop()
+self.cover.save()
+self.writestream.flush()
+self.progTerminated(res)
+elif method == "RequestProfile":
+sys.setprofile(None)
+import PyProfile
+sys.argv = []
+params["filename"] = params["filename"].encode(
+sys.getfilesystemencoding())
+self.__setCoding(params["filename"])
+sys.argv.append(params["filename"])
+sys.argv.extend(params["argv"])
+sys.path = self.__getSysPath(os.path.dirname(sys.argv[0]))
+if params["workdir"] == '':
+os.chdir(sys.path[1])
+else:
+os.chdir(params["workdir"])
+# 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 params["erase"]:
+self.prof.erase()
+self.debugMod.__dict__['__file__'] = sys.argv[0]
+sys.modules['__main__'] = self.debugMod
+self.running = sys.argv[0]
+res = 0
+try:
+self.prof.run('execfile(%r)' % sys.argv[0])
+except SystemExit as exc:
+res = exc.code
+atexit._run_exitfuncs()
+self.prof.save()
+self.writestream.flush()
+self.progTerminated(res)
+elif method == "ExecuteStatement":
+if self.buffer:
+self.buffer = self.buffer + '\n' + params["statement"]
+else:
+self.buffer = params["statement"]
+try:
+code = self.compile_command(self.buffer, self.readstream.name)
+except (OverflowError, SyntaxError, ValueError):
+# Report the exception
+sys.last_type, sys.last_value, sys.last_traceback = \
+sys.exc_info()
+self.sendJsonCommand("ClientOutput", {
+"text": "".join(traceback.format_exception_only(
+sys.last_type, sys.last_value))
+})
+self.buffer = ''
+else:
+if code is None:
+self.sendJsonCommand("ResponseContinue", {})
+return
 else:
-callTraceEnabled = False
+self.buffer = ''
-if self.debugging:
-self.callTraceEnabled = callTraceEnabled
+try:
-else:
+if self.running is None:
-self.__newCallTraceEnabled = callTraceEnabled
+exec code in self.debugMod.__dict__
-# remember for later
-return
-if cmd == DebugProtocol.RequestEnv:
-env = eval(arg)
-for key, value in env.items():
-if key.endswith("+"):
-if key[:-1] in os.environ:
-os.environ[key[:-1]] += value
 else:
-os.environ[key[:-1]] = value
+if self.currentThread is None:
-else:
+# program has terminated
-os.environ[key] = value
-return
-if cmd == DebugProtocol.RequestLoad:
-self._fncache = {}
-self.dircache = []
-sys.argv = []
-wd, fn, args, tracePython = arg.split('|')
-fn = fn.encode(sys.getfilesystemencoding())
-self.__setCoding(fn)
-sys.argv.append(fn)
-sys.argv.extend(eval(args))
-sys.path = self.__getSysPath(os.path.dirname(sys.argv[0]))
-if wd == '':
-os.chdir(sys.path[1])
-else:
-os.chdir(wd)
-tracePython = int(tracePython)
-self.running = sys.argv[0]
-self.mainFrame = None
-self.inRawMode = 0
-self.debugging = 1
-self.threads.clear()
-self.attachThread(mainThread=1)
-# 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.mainThread.tracePython = tracePython
-# 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 IOErrors, if self.running is passed
-# as a normal str.
-self.debugMod.__dict__['__file__'] = self.running
-sys.modules['__main__'] = self.debugMod
-self.callTraceEnabled = self.__newCallTraceEnabled
-res = self.mainThread.run(
-'execfile(' + repr(self.running) + ')',
-self.debugMod.__dict__)
-self.progTerminated(res)
-return
-if cmd == DebugProtocol.RequestRun:
-sys.argv = []
-wd, fn, args = arg.split('|')
-fn = fn.encode(sys.getfilesystemencoding())
-self.__setCoding(fn)
-sys.argv.append(fn)
-sys.argv.extend(eval(args))
-sys.path = self.__getSysPath(os.path.dirname(sys.argv[0]))
-if wd == '':
-os.chdir(sys.path[1])
-else:
-os.chdir(wd)
-self.running = sys.argv[0]
-self.mainFrame = None
-self.botframe = None
-self.inRawMode = 0
-self.threads.clear()
-self.attachThread(mainThread=1)
-# 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 = 0
-self.debugMod.__dict__['__file__'] = sys.argv[0]
-sys.modules['__main__'] = self.debugMod
-res = 0
-try:
-execfile(sys.argv[0], self.debugMod.__dict__)
-except SystemExit as exc:
-res = exc.code
-atexit._run_exitfuncs()
-self.writestream.flush()
-self.progTerminated(res)
-return
-if cmd == DebugProtocol.RequestCoverage:
-from coverage import coverage
-sys.argv = []
-wd, fn, args, erase = arg.split('@@')
-fn = fn.encode(sys.getfilesystemencoding())
-self.__setCoding(fn)
-sys.argv.append(fn)
-sys.argv.extend(eval(args))
-sys.path = self.__getSysPath(os.path.dirname(sys.argv[0]))
-if wd == '':
-os.chdir(sys.path[1])
-else:
-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="%s.coverage" % os.path.splitext(sys.argv[0])[0])
-if int(erase):
-self.cover.erase()
-sys.modules['__main__'] = self.debugMod
-self.debugMod.__dict__['__file__'] = sys.argv[0]
-self.running = sys.argv[0]
-res = 0
-self.cover.start()
-try:
-execfile(sys.argv[0], self.debugMod.__dict__)
-except SystemExit as exc:
-res = exc.code
-atexit._run_exitfuncs()
-self.cover.stop()
-self.cover.save()
-self.writestream.flush()
-self.progTerminated(res)
-return
-if cmd == DebugProtocol.RequestProfile:
-sys.setprofile(None)
-import PyProfile
-sys.argv = []
-wd, fn, args, erase = arg.split('|')
-fn = fn.encode(sys.getfilesystemencoding())
-self.__setCoding(fn)
-sys.argv.append(fn)
-sys.argv.extend(eval(args))
-sys.path = self.__getSysPath(os.path.dirname(sys.argv[0]))
-if wd == '':
-os.chdir(sys.path[1])
-else:
-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):
-self.prof.erase()
-self.debugMod.__dict__['__file__'] = sys.argv[0]
-sys.modules['__main__'] = self.debugMod
-self.running = sys.argv[0]
-res = 0
-try:
-self.prof.run('execfile(%r)' % sys.argv[0])
-except SystemExit as exc:
-res = exc.code
-atexit._run_exitfuncs()
-self.prof.save()
-self.writestream.flush()
-self.progTerminated(res)
-return
-if cmd == DebugProtocol.RequestShutdown:
-self.sessionClose()
-return
-if cmd == DebugProtocol.RequestBreak:
-fn, line, temporary, set, cond = arg.split('@@')
-fn = fn.encode(sys.getfilesystemencoding())
-line = int(line)
-set = int(set)
-temporary = int(temporary)
-if set:
-if cond == 'None' or cond == '':
-cond = None
-else:
-try:
-compile(cond, '<string>', 'eval')
-except SyntaxError:
-self.write(
-'%s%s,%d\n' %
-(DebugProtocol.ResponseBPConditionError,
-fn, line))
-return
-self.mainThread.set_break(fn, line, temporary, cond)
-else:
-self.mainThread.clear_break(fn, line)
-return
-if cmd == DebugProtocol.RequestBreakEnable:
-fn, line, enable = arg.split(',')
-fn = fn.encode(sys.getfilesystemencoding())
-line = int(line)
-enable = int(enable)
-bp = self.mainThread.get_break(fn, line)
-if bp is not None:
-if enable:
-bp.enable()
-else:
-bp.disable()
-return
-if cmd == DebugProtocol.RequestBreakIgnore:
-fn, line, count = arg.split(',')
-fn = fn.encode(sys.getfilesystemencoding())
-line = int(line)
-count = int(count)
-bp = self.mainThread.get_break(fn, line)
-if bp is not None:
-bp.ignore = count
-return
-if cmd == DebugProtocol.RequestWatch:
-cond, temporary, set = arg.split('@@')
-set = int(set)
-temporary = int(temporary)
-if set:
-if not cond.endswith('??created??') and \
-not cond.endswith('??changed??'):
-try:
-compile(cond, '<string>', 'eval')
-except SyntaxError:
-self.write('%s%s\n' % (
-DebugProtocol.ResponseWPConditionError, cond))
-return
-self.mainThread.set_watch(cond, temporary)
-else:
-self.mainThread.clear_watch(cond)
-return
-if cmd == DebugProtocol.RequestWatchEnable:
-cond, enable = arg.split(',')
-enable = int(enable)
-bp = self.mainThread.get_watch(cond)
-if bp is not None:
-if enable:
-bp.enable()
-else:
-bp.disable()
-return
-if cmd == DebugProtocol.RequestWatchIgnore:
-cond, count = arg.split(',')
-count = int(count)
-bp = self.mainThread.get_watch(cond)
-if bp is not None:
-bp.ignore = count
-return
-if cmd == DebugProtocol.RequestEval:
-try:
-value = eval(
-arg, self.currentThread.getCurrentFrame().f_globals,
-self.currentThread.getFrameLocals(self.framenr))
-self.currentThread.storeFrameLocals(self.framenr)
-except Exception:
-# Report the exception and the traceback
-try:
-type, value, tb = sys.exc_info()
-sys.last_type = type
-sys.last_value = value
-sys.last_traceback = tb
-tblist = traceback.extract_tb(tb)
-del tblist[:1]
-list = traceback.format_list(tblist)
-if list:
-list.insert(0, "Traceback (innermost last):\n")
-list[len(list):] = \
-traceback.format_exception_only(type, value)
-finally:
-tblist = tb = None
-map(self.write, list)
-self.write(DebugProtocol.ResponseException + '\n')
-else:
-self.write(unicode(value) + '\n')
-self.write(DebugProtocol.ResponseOK + '\n')
-return
-if cmd == DebugProtocol.RequestExec:
-_globals = self.currentThread.getCurrentFrame().f_globals
-_locals = self.currentThread.getFrameLocals(self.framenr)
-try:
-code = compile(arg + '\n', '<stdin>', 'single')
-exec code in _globals, _locals
-self.currentThread.storeFrameLocals(self.framenr)
-except Exception:
-# Report the exception and the traceback
-try:
-type, value, tb = sys.exc_info()
-sys.last_type = type
-sys.last_value = value
-sys.last_traceback = tb
-tblist = traceback.extract_tb(tb)
-del tblist[:1]
-list = traceback.format_list(tblist)
-if list:
-list.insert(0, "Traceback (innermost last):\n")
-list[len(list):] = \
-traceback.format_exception_only(type, value)
-finally:
-tblist = tb = None
-map(self.write, list)
-self.write(DebugProtocol.ResponseException + '\n')
-return
-if cmd == DebugProtocol.RequestBanner:
-self.write(
-'%s%s\n' % (
-DebugProtocol.ResponseBanner,
-unicode(("Python %s" % sys.version,
-socket.gethostname(),
-self.variant))))
-return
-if cmd == DebugProtocol.RequestCapabilities:
-self.write('%s%d, "Python2"\n' % (
-DebugProtocol.ResponseCapabilities,
-self.__clientCapabilities()))
-return
-if cmd == DebugProtocol.RequestCompletion:
-self.__completionList(arg)
-return
-if cmd == DebugProtocol.RequestSetFilter:
-scope, filterString = eval(arg)
-self.__generateFilterObjects(int(scope), filterString)
-return
-if cmd == DebugProtocol.RequestUTPrepare:
-fn, tn, tfn, failed, cov, covname, erase = arg.split('|')
-fn = fn.encode(sys.getfilesystemencoding())
-sys.path.insert(0, os.path.dirname(os.path.abspath(fn)))
-os.chdir(sys.path[0])
-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 = __import__(tn)
-try:
-if failed:
-self.test = unittest.defaultTestLoader\
-.loadTestsFromNames(failed, utModule)
-else:
-self.test = unittest.defaultTestLoader\
-.loadTestsFromName(tfn, utModule)
-except AttributeError:
-self.test = unittest.defaultTestLoader\
-.loadTestsFromModule(utModule)
-except Exception:
-exc_type, exc_value, exc_tb = sys.exc_info()
-self.write(
-'%s%s\n' % (
-DebugProtocol.ResponseUTPrepared,
-unicode((0, str(exc_type), str(exc_value)))))
-self.__exceptionRaised()
-return
-# generate a coverage object
-if int(cov):
-from coverage import coverage
-self.cover = coverage(
-auto_data=True,
-data_file="%s.coverage" % os.path.splitext(covname)[0])
-if int(erase):
-self.cover.erase()
-else:
-self.cover = None
-self.write(
-'%s%s\n' % (
-DebugProtocol.ResponseUTPrepared,
-unicode((self.test.countTestCases(), "", ""))))
-return
-if cmd == DebugProtocol.RequestUTRun:
-from DCTestResult import DCTestResult
-self.testResult = DCTestResult(self)
-if self.cover:
-self.cover.start()
-self.test.run(self.testResult)
-if self.cover:
-self.cover.stop()
-self.cover.save()
-self.write('%s\n' % DebugProtocol.ResponseUTFinished)
-return
-if cmd == DebugProtocol.RequestUTStop:
-self.testResult.stop()
-return
-if cmd == DebugProtocol.ResponseForkTo:
-# this results from a separate event loop
-self.fork_child = (arg == 'child')
-self.eventExit = 1
-return
-if cmd == DebugProtocol.RequestForkMode:
-self.fork_auto, self.fork_child = eval(arg)
-return
-# If we are handling raw mode input then reset the mode and break out
-# of the current event loop.
-if self.inRawMode:
-self.inRawMode = 0
-self.rawLine = line
-self.eventExit = 1
-return
-if self.buffer:
-self.buffer = self.buffer + '\n' + line
-else:
-self.buffer = line
-try:
-code = self.compile_command(self.buffer, self.readstream.name)
-except (OverflowError, SyntaxError, ValueError):
-# Report the exception
-sys.last_type, sys.last_value, sys.last_traceback = sys.exc_info()
-map(self.write, traceback.format_exception_only(
-sys.last_type, sys.last_value))
-self.buffer = ''
-else:
-if code is None:
-self.pendingResponse = DebugProtocol.ResponseContinue
-else:
-self.buffer = ''
-try:
-if self.running is None:
-exec code in self.debugMod.__dict__
-else:
-if self.currentThread is None:
-# program has terminated
-self.running = None
-_globals = self.debugMod.__dict__
-_locals = _globals
-else:
-cf = self.currentThread.getCurrentFrame()
-# program has terminated
-if cf is None:
 self.running = None
 _globals = self.debugMod.__dict__
 _locals = _globals
 else:
-frmnr = self.framenr
+cf = self.currentThread.getCurrentFrame()
-while cf is not None and frmnr > 0:
+# program has terminated
-cf = cf.f_back
+if cf is None:
-frmnr -= 1
+self.running = None
-_globals = cf.f_globals
+_globals = self.debugMod.__dict__
-_locals = \
+_locals = _globals
-self.currentThread.getFrameLocals(
+else:
-self.framenr)
+frmnr = self.framenr
-# reset sys.stdout to our redirector (unconditionally)
+while cf is not None and frmnr > 0:
-if "sys" in _globals:
+cf = cf.f_back
-__stdout = _globals["sys"].stdout
+frmnr -= 1
-_globals["sys"].stdout = self.writestream
+_globals = cf.f_globals
-exec code in _globals, _locals
+_locals = \
-_globals["sys"].stdout = __stdout
+self.currentThread.getFrameLocals(
-elif "sys" in _locals:
+self.framenr)
-__stdout = _locals["sys"].stdout
+# reset sys.stdout to our redirector
-_locals["sys"].stdout = self.writestream
+# (unconditionally)
-exec code in _globals, _locals
+if "sys" in _globals:
-_locals["sys"].stdout = __stdout
+__stdout = _globals["sys"].stdout
-else:
+_globals["sys"].stdout = self.writestream
 exec code in _globals, _locals
+_globals["sys"].stdout = __stdout
-self.currentThread.storeFrameLocals(self.framenr)
+elif "sys" in _locals:
-except SystemExit, exc:
+__stdout = _locals["sys"].stdout
-self.progTerminated(exc.code)
+_locals["sys"].stdout = self.writestream
-except Exception:
+exec code in _globals, _locals
-# Report the exception and the traceback
+_locals["sys"].stdout = __stdout
+else:
+exec code in _globals, _locals
+self.currentThread.storeFrameLocals(self.framenr)
+except SystemExit, exc:
+self.progTerminated(exc.code)
+except Exception:
+# Report the exception and the traceback
+tlist = []
+try:
+exc_type, exc_value, exc_tb = sys.exc_info()
+sys.last_type = exc_type
+sys.last_value = exc_value
+sys.last_traceback = exc_tb
+tblist = traceback.extract_tb(exc_tb)
+del tblist[:1]
+tlist = traceback.format_list(tblist)
+if tlist:
+tlist.insert(
+0, "Traceback (innermost last):\n")
+tlist.extend(traceback.format_exception_only(
+exc_type, exc_value))
+finally:
+tblist = exc_tb = None
+self.sendJsonCommand("ClientOutput", {
+"text": "".join(tlist)
+})
+self.sendJsonCommand("ResponseOK", {})
+elif method == "RequestStep":
+self.currentThread.step(True)
+self.eventExit = True
+elif method == "RequestStepOver":
+self.currentThread.step(False)
+self.eventExit = True
+elif method == "RequestStepOut":
+self.currentThread.stepOut()
+self.eventExit = True
+elif method == "RequestStepQuit":
+if self.passive:
+self.progTerminated(42)
+else:
+self.set_quit()
+self.eventExit = True
+elif method == "RequestContinue":
+self.currentThread.go(params["special"])
+self.eventExit = True
+elif method == "RawInput":
+# If we are handling raw mode input then break out of the current
+# event loop.
+self.rawLine = params["input"]
+self.eventExit = True
+elif method == "RequestBreakpoint":
+params["filename"] = params["filename"].encode(
+sys.getfilesystemencoding())
+if params["setBreakpoint"]:
+if params["condition"] in ['None', '']:
+params["condition"] = None
+elif params["condition"] is not None:
 try:
-type, value, tb = sys.exc_info()
+compile(params["condition"], '<string>', 'eval')
-sys.last_type = type
+except SyntaxError:
-sys.last_value = value
+self.sendJsonCommand("ResponseBPConditionError", {
-sys.last_traceback = tb
+"filename": params["filename"],
-tblist = traceback.extract_tb(tb)
+"line": params["line"],
-del tblist[:1]
+})
-list = traceback.format_list(tblist)
+return
-if list:
+self.mainThread.set_break(
-list.insert(0, "Traceback (innermost last):\n")
+params["filename"], params["line"], params["temporary"],
-list[len(list):] = \
+params["condition"])
-traceback.format_exception_only(type, value)
+else:
-finally:
+self.mainThread.clear_break(params["filename"], params["line"])
-tblist = tb = None
+elif method == "RequestBreakpointEnable":
-map(self.write, list)
+params["filename"] = params["filename"].encode(
+sys.getfilesystemencoding())
+bp = self.mainThread.get_break(params["filename"], params["line"])
+if bp is not None:
+if params["enable"]:
+bp.enable()
+else:
+bp.disable()
+elif method == "RequestBreakpointIgnore":
+params["filename"] = params["filename"].encode(
+sys.getfilesystemencoding())
+bp = self.mainThread.get_break(params["filename"], params["line"])
+if bp is not None:
+bp.ignore = params["count"]
+elif method == "RequestWatch":
+if params["setWatch"]:
+if not params["condition"].endswith(
+('??created??', '??changed??')):
+try:
+compile(params["condition"], '<string>', 'eval')
+except SyntaxError:
+self.sendJsonCommand("ResponseWatchConditionError", {
+"condition": params["condition"],
+})
+return
+self.mainThread.set_watch(
+params["condition"], params["temporary"])
+else:
+self.mainThread.clear_watch(params["condition"])
+elif method == "RequestWatchEnable":
+wp = self.mainThread.get_watch(params["condition"])
+if wp is not None:
+if params["enable"]:
+wp.enable()
+else:
+wp.disable()
+elif method == "RequestWatchIgnore":
+wp = self.mainThread.get_watch(params["condition"])
+if wp is not None:
+wp.ignore = params["count"]
+elif method == "RequestShutdown":
+self.sessionClose()
+elif method == "RequestCompletion":
+self.__completionList(params["text"])
+elif method == "RequestUTPrepare":
+params["filename"] = params["filename"].encode(
+sys.getfilesystemencoding())
+sys.path.insert(
+0, os.path.dirname(os.path.abspath(params["filename"])))
+os.chdir(sys.path[0])
+# 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 = __import__(params["testname"])
+try:
+if params["failed"]:
+self.test = unittest.defaultTestLoader\
+.loadTestsFromNames(params["failed"], utModule)
+else:
+self.test = unittest.defaultTestLoader\
+.loadTestsFromName(params["testfunctionname"],
+utModule)
+except AttributeError:
+self.test = unittest.defaultTestLoader\
+.loadTestsFromModule(utModule)
+except Exception:
+exc_type, exc_value, exc_tb = sys.exc_info()
+self.sendJsonCommand("ResponseUTPrepared", {
+"count": 0,
+"exception": exc_type.__name__,
+"message": str(exc_value),
+})
+return
+# generate a coverage object
+if params["coverage"]:
+from coverage import coverage
+self.cover = coverage(
+auto_data=True,
+data_file="%s.coverage" % \
+os.path.splitext(params["coveragefile"])[0])
+if params["coverageerase"]:
+self.cover.erase()
+else:
+self.cover = None
+self.sendJsonCommand("ResponseUTPrepared", {
+"count": self.test.countTestCases(),
+"exception": "",
+"message": "",
+})
+elif method == "RequestUTRun":
+from DCTestResult import DCTestResult
+self.testResult = DCTestResult(self)
+if self.cover:
+self.cover.start()
+self.test.run(self.testResult)
+if self.cover:
+self.cover.stop()
+self.cover.save()
+self.sendJsonCommand("ResponseUTFinished", {})
+elif method == "RequestUTStop":
+self.testResult.stop()
+elif method == "ResponseForkTo":
+# this results from a separate event loop
+self.fork_child = (params["target"] == 'child')
+self.eventExit = True
+def sendJsonCommand(self, method, params):
+"""
+Public method to send a single command or response to the IDE.
+@param method command or response command name to be sent
+@type str
+@param params dictionary of named parameters for the command or
+response
+@type dict
+"""
+cmd = prepareJsonCommand(method, params)
+self.writestream.write_p(cmd)
+self.writestream.flush()
+def sendClearTemporaryBreakpoint(self, filename, lineno):
+"""
+Public method to signal the deletion of a temporary breakpoint.
+@param filename name of the file the bp belongs to
+@type str
+@param lineno linenumber of the bp
+@type int
+"""
+self.sendJsonCommand("ResponseClearBreakpoint", {
+"filename": filename,
+"line": lineno
+})
+def sendClearTemporaryWatch(self, condition):
+"""
+Public method to signal the deletion of a temporary watch expression.
+@param condition condition of the watch expression to be cleared
+@type str
+"""
+self.sendJsonCommand("ResponseClearWatch", {
+"condition": condition,
+})
+def sendResponseLine(self, stack):
+"""
+Public method to send the current call stack.
+@param stack call stack
+@type list
+"""
+self.sendJsonCommand("ResponseLine", {
+"stack": stack,
+})
+def sendCallTrace(self, event, fromStr, toStr):
+"""
+Public method to send a call trace entry.
+@param event trace event (call or return)
+@type str
+@param fromStr pre-formatted origin info
+@type str
+@param toStr pre-formatted target info
+@type str
+"""
+self.sendJsonCommand("CallTrace", {
+"event": event[0],
+"from": fromStr,
+"to": toStr,
+})
+def sendException(self, exceptionType, exceptionMessage, stack):
+"""
+Public method to send information for an exception.
+@param exceptionType type of exception raised
+@type str
+@param exceptionMessage message of the exception
+@type str
+@param stack stack trace information
+@type list
+"""
+self.sendJsonCommand("ResponseException", {
+"type": exceptionType,
+"message": exceptionMessage,
+"stack": stack,
+})
+def sendSyntaxError(self, message, filename, lineno, charno):
+"""
+Public method to send information for a syntax error.
+@param message syntax error message
+@type str
+@param filename name of the faulty file
+@type str
+@param lineno line number info
+@type int
+@param charno character number info
+@tyoe int
+"""
+self.sendJsonCommand("ResponseSyntax", {
+"message": message,
+"filename": filename,
+"linenumber": lineno,
+"characternumber": charno,
+})
+def sendPassiveStartup(self, filename, exceptions):
+"""
+Public method to send the passive start information.
+@param filename name of the script
+@type str
+@param exceptions flag to enable exception reporting of the IDE
+@type bool
+"""
+self.sendJsonCommand("PassiveStartup", {
+"filename": filename,
+"exceptions": exceptions,
+})
 def __clientCapabilities(self):
 """
 Private method to determine the clients capabilities.
 pass
 return self.clientCapabilities
 except ImportError:
 return (
 self.clientCapabilities & ~DebugClientCapabilities.HasProfiler)
-def write(self, s):
+def readReady(self, stream):
 """
-Public method to write data to the output stream.
+Public method called when there is data ready to be read.
-@param s data to be written (string)
+@param stream file like object that has data to be written
 """
-self.writestream.write(s)
+try:
-self.writestream.flush()
+got = stream.readline_p()
+except Exception:
+return
+if len(got) == 0:
+self.sessionClose()
+return
+self.__receiveBuffer = self.__receiveBuffer + got
+# Call handleLine for the line if it is complete.
+eol = self.__receiveBuffer.find('\n')
+while eol >= 0:
+line = self.__receiveBuffer[:eol + 1]
+self.__receiveBuffer = self.__receiveBuffer[eol + 1:]
+self.handleLine(line)
+eol = self.__receiveBuffer.find('\n')
+def writeReady(self, stream):
+"""
+Public method called when we are ready to write data.
+@param stream file like object that has data to be written
+"""
+stream.write_p("")
+stream.flush()
 def __interact(self):
 """
 Private method to interact with the debugger.
 """
 global DebugClientInstance
-self.setDescriptors(self.readstream, self.writestream)
 DebugClientInstance = self
+self.__receiveBuffer = ""
 if not self.passive:
 # At this point simulate an event loop.
 self.eventLoop()
 except (select.error, KeyboardInterrupt, socket.error):
 # just carry on
 continue
 if self.readstream in rrdy:
-self.readReady(self.readstream.fileno())
+self.readReady(self.readstream)
 if self.writestream in wrdy:
-self.writeReady(self.writestream.fileno())
+self.writeReady(self.writestream)
 if self.errorstream in wrdy:
-self.writeReady(self.errorstream.fileno())
+self.writeReady(self.errorstream)
 self.eventExit = None
 self.pollingDisabled = False
 def eventPoll(self):
 rrdy, wrdy, xrdy = select.select([self.readstream], wrdy, [], 0)
 except (select.error, KeyboardInterrupt, socket.error):
 return
 if self.readstream in rrdy:
-self.readReady(self.readstream.fileno())
+self.readReady(self.readstream)
 if self.writestream in wrdy:
-self.writeReady(self.writestream.fileno())
+self.writeReady(self.writestream)
 if self.errorstream in wrdy:
-self.writeReady(self.errorstream.fileno())
+self.writeReady(self.errorstream)
 def connectDebugger(self, port, remoteAddress=None, redirect=1):
 """
 Public method to establish a session with the debugger.
 @param exctype the type of the exception
 @param excval data about the exception
 @param exctb traceback for the exception
 """
-self.mainThread.user_exception(None, (exctype, excval, exctb), 1)
+self.mainThread.user_exception(None, (exctype, excval, exctb), True)
 def __interceptSignals(self):
 """
 Private method to intercept common signals.
 """
 except Exception:
 fargs = ""
 else:
 fargs = ""
-siglist = [message, [filename, linenr, ffunc, fargs]]
+self.sendJsonCommand("ResponseSignal", {
+"message": message,
-self.write("%s%s" % (DebugProtocol.ResponseSignal, str(siglist)))
+"filename": filename,
+"linenumber": linenr,
+"function": ffunc,
+"arguments": fargs,
+})
 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
 @param fn filename to be checked
 @return non-zero if fn represents a file we are 'skipping',
 zero otherwise.
 """
 if self.mainThread.tracePython:     # trace into Python library
-return 0
+return False
 # Eliminate anything that is part of the Python installation.
 afn = self.absPath(fn)
 for d in self.skipdirs:
 if afn.startswith(d):
-return 1
+return True
 # special treatment for paths containing site-packages or dist-packages
 for part in ["site-packages", "dist-packages"]:
 if part in afn:
-return 1
+return True
-return 0
+return False
 def getRunning(self):
 """
 Public method to return the main script we are currently running.
 @return flag indicating a running debug session (boolean)
 """
 return self.running
-def progTerminated(self, status):
+def progTerminated(self, status, message=""):
 """
 Public method to tell the debugger that the program has terminated.
 @param status return status
 @type int
+@param message status message
+@type str
 """
 if status is None:
 status = 0
-else:
+elif not isinstance(status, int):
-try:
+message = str(status)
-int(status)
+status = 1
-except ValueError:
-status = 1
 if self.running:
 self.set_quit()
 self.running = None
-self.write('%s%d\n' % (DebugProtocol.ResponseExit, status))
+self.sendJsonCommand("ResponseExit", {
+"status": status,
+"message": message,
+})
 # reset coding
 self.__coding = self.defaultCoding
 def __dumpVariables(self, frmnr, scope, filter):
 elif f.f_globals is f.f_locals:
 scope = -1
 else:
 dict = f.f_locals
-varlist = [scope]
+varlist = []
 if scope != -1:
 keylist = dict.keys()
 vlist = self.__formatVariablesList(keylist, dict, scope, filter)
 varlist.extend(vlist)
-self.write('%s%s\n' % (
+self.sendJsonCommand("ResponseVariables", {
-DebugProtocol.ResponseVariables, unicode(varlist)))
+"scope": scope,
+"variables": varlist,
+})
 def __dumpVariable(self, var, frmnr, scope, filter):
 """
 Private method to return the variables of a frame to the debug server.
 elif f.f_globals is f.f_locals:
 scope = -1
 else:
 dict = f.f_locals
-varlist = [scope, var]
+varlist = []
 if scope != -1:
 # search the correct dictionary
 i = 0
 rvar = var[:]
 dictkeys = None
 obj = None
-isDict = 0
+isDict = False
-formatSequences = 0
+formatSequences = False
 access = ""
 oaccess = ""
 odict = dict
 qtVariable = False
 if i + 1 == len(var):
 if var[i][:-2] == '...':
 dictkeys = [var[i - 1]]
 else:
 dictkeys = [var[i][:-2]]
-formatSequences = 1
+formatSequences = True
 if not access and not oaccess:
 if var[i][:-2] == '...':
 access = '["%s"]' % var[i - 1]
 dict = odict
 else:
 access = '%s[%s]' % (oaccess, var[i][:-2])
 oaccess = ''
 else:
 access = '%s[%s]' % (access, var[i][:-2])
 if var[i][-2:] == "{}":         # __IGNORE_WARNING__
-isDict = 1
+isDict = True
 break
 else:
 if not access:
 if var[i][:-2] == '...':
 access = '["%s"]' % var[i - 1]
 elif unicode(repr(obj)).startswith('('):
 varlist.append(('...', 'tuple', "%d" % len(obj)))
 except Exception:
 pass
-self.write('%s%s\n' % (
+self.sendJsonCommand("ResponseVariable", {
-DebugProtocol.ResponseVariable, unicode(varlist)))
+"scope": scope,
+"variable": var,
+"variables": varlist,
+})
 def __formatQtVariable(self, value, vtype):
 """
 Private method to produce a formated output of a simple Qt4/Qt5 type.
 else:
 patternFilterObjects = self.localsFilterObjects
 for key in keylist:
 # filter based on the filter pattern
-matched = 0
+matched = False
 for pat in patternFilterObjects:
 if pat.match(unicode(key)):
-matched = 1
+matched = True
 break
 if matched:
 continue
 # filter hidden attributes (filter #0)
 self.__getCompletionList(text, localCompleter, completions)
 except AttributeError:
 pass
 self.__getCompletionList(text, self.complete, completions)
-self.write("%s%s||%s\n" % (DebugProtocol.ResponseCompletion,
+self.sendJsonCommand("ResponseCompletion", {
-unicode(list(completions)), text))
+"completions": list(completions),
+"text": text,
+})
 def __getCompletionList(self, text, completer, completions):
 """
 Private method to create a completions list.
 comp = completer(text, state)
 except Exception:
 comp = None
 def startDebugger(self, filename=None, host=None, port=None,
-enableTrace=1, exceptions=1, tracePython=0, redirect=1):
+enableTrace=True, exceptions=True, tracePython=False,
+redirect=True):
 """
 Public method used to start the remote debugger.
 @param filename the program to be debugged (string)
 @param host hostname of the debug server (string)
 self.running = os.path.abspath(sys.argv[0])
 except IndexError:
 self.running = None
 if self.running:
 self.__setCoding(self.running)
-self.passive = 1
+self.passive = True
-self.write("%s%s|%d\n" % (
+self.sendPassiveStartup(self.running, exceptions)
-DebugProtocol.PassiveStartup, self.running, exceptions))
 self.__interact()
 # setup the debugger variables
 self._fncache = {}
 self.dircache = []
 self.mainFrame = None
-self.inRawMode = 0
+self.debugging = True
-self.debugging = 1
+self.attachThread(mainThread=True)
-self.attachThread(mainThread=1)
 self.mainThread.tracePython = tracePython
 # set the system exception handling function to ensure, that
 # we report on all unhandled exceptions
 sys.excepthook = self.__unhandled_exception
 # now start debugging
 if enableTrace:
 self.mainThread.set_trace()
 def startProgInDebugger(self, progargs, wd='', host=None,
-port=None, exceptions=1, tracePython=0,
+port=None, exceptions=True, tracePython=False,
-redirect=1):
+redirect=True):
 """
 Public method used to start the remote debugger.
 @param progargs commandline for the program to be debugged
 (list of strings)
 else:
 os.chdir(wd)
 self.running = sys.argv[0]
 self.__setCoding(self.running)
 self.mainFrame = None
-self.inRawMode = 0
+self.debugging = True
-self.debugging = 1
+self.passive = True
-self.passive = 1
+self.sendPassiveStartup(self.running, exceptions)
-self.write("%s%s|%d\n" % (
-DebugProtocol.PassiveStartup, self.running, exceptions))
 self.__interact()
 self.attachThread(mainThread=1)
 self.mainThread.tracePython = tracePython
 if '--' in sys.argv:
 args = sys.argv[1:]
 host = None
 port = None
 wd = ''
-tracePython = 0
+tracePython = False
-exceptions = 1
+exceptions = True
-redirect = 1
+redirect = True
 while args[0]:
 if args[0] == '-h':
 host = args[1]
 del args[0]
 del args[0]
 elif args[0] == '-w':
 wd = args[1]
 del args[0]
 del args[0]
 elif args[0] == '-t':
-tracePython = 1
+tracePython = True
 del args[0]
 elif args[0] == '-e':
-exceptions = 0
+exceptions = False
 del args[0]
 elif args[0] == '-n':
-redirect = 0
+redirect = False
 del args[0]
 elif args[0] == '--no-encoding':
 self.noencoding = True
 del args[0]
 elif args[0] == '--fork-child':
 except (ValueError, IndexError):
 port = -1
 try:
 redirect = int(sys.argv[2])
 except (ValueError, IndexError):
-redirect = 1
+redirect = True
 try:
 ipOrHost = sys.argv[3]
 if ':' in ipOrHost:
 remoteAddress = ipOrHost
 elif ipOrHost[0] in '0123456789':
 follow.
 @return process ID (integer)
 """
 if not self.fork_auto:
-self.write(DebugProtocol.RequestForkTo + '\n')
+self.sendJsonCommand("RequestForkTo", {})
 self.eventLoop(True)
 pid = DebugClientOrigFork()
 if pid == 0:
 # child
 if not self.fork_child:

Mercurial Repositories > eric / file comparison

comparison: DebugClients/Python/DebugClientBase.py

DebugClients/Python/DebugClientBase.py