eric: comparison eric6/Debugger/DebugServer.py

-:866adc8c315b
+:0acf98cd089a
 Module implementing the debug server.
 """
 import os
-from PyQt5.QtCore import pyqtSignal, QModelIndex
+from PyQt5.QtCore import pyqtSignal, pyqtSlot, QModelIndex
 from PyQt5.QtNetwork import (
 QTcpServer, QHostAddress, QHostInfo, QNetworkInterface
 )
 from E5Gui.E5Application import e5App
 @signal clientProcessStdout(str) emitted after the client has sent some
 output via stdout
 @signal clientProcessStderr(str) emitted after the client has sent some
 output via stderr
 @signal clientOutput(str) emitted after the client has sent some output
-@signal clientRawInputSent() emitted after the data was sent to the
+@signal clientRawInputSent(debuggerId) emitted after the data was sent
-debug client
+to the indicated debug client
-@signal clientLine(filename, lineno, forStack) emitted after the
+@signal clientLine(filename, lineno, debuggerId, threadName, forStack)
+emitted after the debug client has executed a line of code
+@signal clientStack(stack, debuggerId, threadName) emitted after the
 debug client has executed a line of code
-@signal clientStack(stack) emitted after the debug client has executed a
+@signal clientThreadList(currentId, threadList, debuggerId) emitted after
-line of code
+a thread list has been received
-@signal clientThreadList(currentId, threadList) emitted after a thread list
+@signal clientThreadSet(debuggerId) emitted after the client has
-has been received
+acknowledged the change of the current thread
-@signal clientThreadSet() emitted after the client has acknowledged the
+@signal clientVariables(scope, variables, debuggerId) emitted after a
-change of the current thread
+variables dump has been received
-@signal clientVariables(scope, variables) emitted after a variables dump
+@signal clientVariable(scope, variables, debuggerId) emitted after a dump
-has been received
+for one class variable has been received
-@signal clientVariable(scope, variables) emitted after a dump for one class
+@signal clientStatement(continue, debuggerId) emitted after an interactive
-variable has been received
+command has been executed. The parameter is False to indicate that the
-@signal clientStatement(bool) emitted after an interactive command has
+command is complete and True if it needs more input.
-been executed. The parameter is 0 to indicate that the command is
+@signal clientDisassembly(disassembly, debuggerId) emitted after the client
-complete and 1 if it needs more input.
+has sent a disassembly of the code raising an exception
-@signal clientDisassembly(disassembly) emitted after the client has sent
+@signal clientException(exceptionType, exceptionMessage, stackTrace,
-a disassembly of the code raising an exception
+debuggerId, threadName) emitted after an exception occured on the
-@signal clientException(exception) emitted after an exception occured on
+client side
-the client side
+@signal clientSyntaxError(message, filename, linenumber, characternumber,
-@signal clientSyntaxError(exception) emitted after a syntax error has been
+debuggerId, threadName) emitted after a syntax error has been detected
-detected on the client side
+on the client side
-@signal clientSignal(signal) emitted after a signal has been generated on
+@signal clientSignal(message, filename, linenumber, function name,
-the client side
+function arguments, debuggerId) emitted after a signal has been
-@signal clientExit(int, str, bool) emitted after the client has exited
+generated on the client side
-giving the exit status, an exit message and an indication to be quiet
+@signal clientDisconnected(str) emitted after a debug client has
-@signal clientClearBreak(filename, lineno) emitted after the debug client
+disconnected (i.e. closed the network socket)
-has decided to clear a temporary breakpoint
+@signal clientExit(str, int, str, bool, str) emitted after the client has
-@signal clientBreakConditionError(fn, lineno) emitted after the client has
+exited giving the program name, the exit status, an exit message, an
-signaled a syntax error in a breakpoint condition
+indication to be quiet and the ID of the exited client
-@signal clientClearWatch(condition) emitted after the debug client
+@signal lastClientExited() emitted to indicate that the last connected
-has decided to clear a temporary watch expression
+debug client has terminated
-@signal clientWatchConditionError(condition) emitted after the client has
+@signal clientClearBreak(filename, lineno, debuggerId) emitted after the
-signaled a syntax error in a watch expression
+debug client has decided to clear a temporary breakpoint
-@signal clientRawInput(prompt, echo) emitted after a raw input request was
+@signal clientBreakConditionError(fn, lineno, debuggerId) emitted after the
-received
+client has signaled a syntax error in a breakpoint condition
-@signal clientBanner(version, platform, dbgclient, venvname) emitted after
+@signal clientClearWatch(condition, debuggerId) emitted after the debug
+client has decided to clear a temporary watch expression
+@signal clientWatchConditionError(condition, debuggerId) emitted after the
+client has signaled a syntax error in a watch expression
+@signal clientRawInput(prompt, echo, debuggerId) emitted after a raw input
+request was received
+@signal clientBanner(version, platform, venvname) emitted after
 the client banner data was received
 @signal clientCapabilities(capabilities, cltype, venvname) emitted after
 the clients capabilities were received
-@signal clientCompletionList(completionList, text) emitted after the client
+@signal clientCompletionList(completionList, text) emitted after the
-the commandline completion list and the reworked searchstring was
+commandline completion list and the reworked search string was
 received from the client
 @signal passiveDebugStarted(str, bool) emitted after the debug client has
 connected in passive debug mode
 @signal clientGone(bool) emitted if the client went away (planned or
 unplanned)
 client reported an expected test failure
 @signal utTestSucceededUnexpected(testname, id) emitted after the client
 reported an unexpected test success
 @signal callTraceInfo emitted after the client reported the call trace
 data (isCall, fromFile, fromLine, fromFunction, toFile, toLine,
-toFunction)
+toFunction, debuggerId)
 @signal appendStdout(msg) emitted when a passive debug connection is
 established or lost
+@signal clientDebuggerId(debuggerId) emitted to indicate a newly connected
+debugger backend
 """
-clientClearBreak = pyqtSignal(str, int)
+clientClearBreak = pyqtSignal(str, int, str)
-clientClearWatch = pyqtSignal(str)
+clientClearWatch = pyqtSignal(str, str)
 clientGone = pyqtSignal(bool)
 clientProcessStdout = pyqtSignal(str)
 clientProcessStderr = pyqtSignal(str)
-clientRawInputSent = pyqtSignal()
+clientRawInputSent = pyqtSignal(str)
 clientOutput = pyqtSignal(str)
-clientLine = pyqtSignal(str, int, bool)
+clientLine = pyqtSignal(str, int, str, str, bool)
-clientStack = pyqtSignal(list)
+clientStack = pyqtSignal(list, str, str)
-clientThreadList = pyqtSignal('PyQt_PyObject', list)
+clientThreadList = pyqtSignal('PyQt_PyObject', list, str)
-clientThreadSet = pyqtSignal()
+clientThreadSet = pyqtSignal(str)
-clientVariables = pyqtSignal(int, list)
+clientVariables = pyqtSignal(int, list, str)
-clientVariable = pyqtSignal(int, list)
+clientVariable = pyqtSignal(int, list, str)
-clientStatement = pyqtSignal(bool)
+clientStatement = pyqtSignal(bool, str)
-clientDisassembly = pyqtSignal(dict)
+clientDisassembly = pyqtSignal(dict, str)
-clientException = pyqtSignal(str, str, list)
+clientException = pyqtSignal(str, str, list, str, str)
-clientSyntaxError = pyqtSignal(str, str, int, int)
+clientSyntaxError = pyqtSignal(str, str, int, int, str, str)
-clientSignal = pyqtSignal(str, str, int, str, str)
+clientSignal = pyqtSignal(str, str, int, str, str, str)
-clientExit = pyqtSignal(int, str, bool)
+clientDisconnected = pyqtSignal(str)
-clientBreakConditionError = pyqtSignal(str, int)
+clientExit = pyqtSignal(str, int, str, bool, str)
-clientWatchConditionError = pyqtSignal(str)
+lastClientExited = pyqtSignal()
-clientRawInput = pyqtSignal(str, bool)
+clientBreakConditionError = pyqtSignal(str, int, str)
-clientBanner = pyqtSignal(str, str, str, str)
+clientWatchConditionError = pyqtSignal(str, str)
+clientRawInput = pyqtSignal(str, bool, str)
+clientBanner = pyqtSignal(str, str, str)
 clientCapabilities = pyqtSignal(int, str, str)
 clientCompletionList = pyqtSignal(list, str)
 clientInterpreterChanged = pyqtSignal(str)
+clientDebuggerId = pyqtSignal(str)
 utDiscovered = pyqtSignal(list, str, str)
 utPrepared = pyqtSignal(int, str, str)
 utStartTest = pyqtSignal(str, str)
 utStopTest = pyqtSignal()
 utTestFailed = pyqtSignal(str, str, str)
 utTestSkipped = pyqtSignal(str, str, str)
 utTestFailedExpected = pyqtSignal(str, str, str)
 utTestSucceededUnexpected = pyqtSignal(str, str)
 utFinished = pyqtSignal()
 passiveDebugStarted = pyqtSignal(str, bool)
-callTraceInfo = pyqtSignal(bool, str, str, str, str, str, str)
+callTraceInfo = pyqtSignal(bool, str, str, str, str, str, str, str)
 appendStdout = pyqtSignal(str)
 def __init__(self, originalPathString, preventPassiveDebugging=False):
 """
 Constructor
 self.watchpointModel = WatchPointModel(self)
 self.watchSpecialCreated = self.tr(
 "created", "must be same as in EditWatchpointDialog")
 self.watchSpecialChanged = self.tr(
 "changed", "must be same as in EditWatchpointDialog")
+# arrays to track already reported issues
+self.__reportedBreakpointIssues = []
+self.__reportedWatchpointIssues = []
 self.networkInterface = Preferences.getDebugger("NetworkInterface")
 if self.networkInterface == "all":
 hostAddress = QHostAddress("0.0.0.0")  # QHostAddress.Any)  # secok
 elif self.networkInterface == "allv6":
 self.watchpointModel.dataChanged.connect(self.__changeWatchPoints)
 self.watchpointModel.rowsInserted.connect(self.__addWatchPoints)
 self.__maxVariableSize = Preferences.getDebugger("MaxVariableSize")
+self.__multiprocessNoDebugList = []
 self.__registerDebuggerInterfaces()
 def getHostAddress(self, localhost):
 """
 Public method to get the IP address or hostname the debug server is
 listening.
 @param localhost flag indicating to return the address for localhost
-(boolean)
+@type bool
-@return IP address or hostname (string)
+@return IP address or hostname
+@rtype str
 """
 if self.networkInterface == "all":
 if localhost:
 return "127.0.0.1"
 else:
 else:
 return "{0}@@v6".format(QHostInfo.localHostName())
 else:
 return "{0}@@i{1}".format(self.networkInterface,
 self.networkInterfaceIndex)
 def __getNetworkInterfaceAndIndex(self, address):
 """
 Private method to determine the network interface and the interface
 index.
-@param address address to determine the info for (string)
+@param address address to determine the info for
-@return tuple of network interface name (string) and index (integer)
+@type str
+@return tuple of network interface name and index
+@rtype tuple of (str, int)
 """
 if address not in ["all", "allv6"]:
 for networkInterface in QNetworkInterface.allInterfaces():
 addressEntries = networkInterface.addressEntries()
 if len(addressEntries) > 0:
 address.lower()):
 return (networkInterface.humanReadableName(),
 networkInterface.index())
 return "", 0
 def preferencesChanged(self):
 """
 Public slot to handle the preferencesChanged signal.
 """
 registeredInterfaces = {}
 for interfaceName, getRegistryData in registeredInterfaces.items():
 self.registerDebuggerInterface(interfaceName, getRegistryData,
 reregister=True)
 self.__maxVariableSize = Preferences.getDebugger("MaxVariableSize")
 def registerDebuggerInterface(self, interfaceName, getRegistryData,
 reregister=False):
 """
 Public method to register a debugger interface.
 for (clientLanguage, clientCapabilities, clientExtensions,
 interfaceCreator) in registryDataList:
 self.__debuggerInterfaceRegistry[clientLanguage] = [
 clientCapabilities, clientExtensions, interfaceCreator,
 interfaceName]
 def unregisterDebuggerInterface(self, interfaceName):
 """
 Public method to unregister a debugger interface.
 @param interfaceName interfaceName of the debugger interface
 if interfaceName == registryData[-1]:
 clientLanguages.append(clientLanguage)
 for clientLanguage in clientLanguages:
 del self.__debuggerInterfaceRegistry[clientLanguage]
 del self.__debuggerInterfaces[interfaceName]
 def __findLanguageForExtension(self, ext):
 """
 Private method to get the language associated with a file extension.
 @param ext file extension
 for language in self.__debuggerInterfaceRegistry:
 if ext in self.__debuggerInterfaceRegistry[language][1]:
 return language
 return ""
 def __registerDebuggerInterfaces(self):
 """
 Private method to register the available internal debugger interfaces.
 """
 for name, interface in DebuggerInterfaces.items():
 components = modName.split('.')
 for comp in components[1:]:
 mod = getattr(mod, comp)
 self.registerDebuggerInterface(name, mod.getRegistryData)
 def getSupportedLanguages(self, shellOnly=False):
 """
 Public slot to return the supported programming languages.
 @param shellOnly flag indicating only languages supporting an
 interactive shell should be returned
-@return list of supported languages (list of strings)
+@type bool
+@return list of supported languages
+@rtype list of str
 """
 languages = list(self.__debuggerInterfaceRegistry.keys())
 try:
 languages.remove("None")
 except ValueError:
 languages = [lang for lang in languages
 if self.__debuggerInterfaceRegistry[lang][0] &
 DebugClientCapabilities.HasShell]
 return languages[:]
 def getExtensions(self, language):
 """
 Public slot to get the extensions associated with the given language.
-@param language language to get extensions for (string)
+@param language language to get extensions for
+@type str
 @return tuple of extensions associated with the language
-(tuple of strings)
+@rtype tuple of str
 """
 if language in self.__debuggerInterfaceRegistry:
 return tuple(self.__debuggerInterfaceRegistry[language][1])
 else:
 return ()
 def __createDebuggerInterface(self, clientType=None):
 """
 Private slot to create the debugger interface object.
-@param clientType type of the client interface to be created (string)
+@param clientType type of the client interface to be created
+@type str
 """
 if self.lastClientType != self.clientType or clientType is not None:
 if clientType is None:
 clientType = self.clientType
 if clientType in self.__debuggerInterfaceRegistry:
 else:
 self.debuggerInterface = (
 self.__debuggerInterfaceRegistry["None"][2](
 self, self.passive))
 self.clientType = "None"
 def __setClientType(self, clType):
 """
 Private method to set the client type.
-@param clType type of client to be started (string)
+@param clType type of client to be started
+@type str
 """
 if clType is not None and clType in self.getSupportedLanguages():
 self.clientType = clType
 Preferences.Prefs.settings.setValue(
 'DebugClient/Type', self.clientType)
 def startClient(self, unplanned=True, clType=None, forProject=False,
 runInConsole=False, venvName="", workingDir=None):
 """
 Public method to start a debug client.
-@keyparam unplanned flag indicating that the client has died
+@param unplanned flag indicating that the client has died
 @type bool
-@keyparam clType type of client to be started
+@param clType type of client to be started
 @type str
-@keyparam forProject flag indicating a project related action
+@param forProject flag indicating a project related action
 @type bool
-@keyparam runInConsole flag indicating to start the debugger in a
+@param runInConsole flag indicating to start the debugger in a
 console window
 @type bool
-@keyparam venvName name of the virtual environment to be used
+@param venvName name of the virtual environment to be used
 @type str
-@keyparam workingDir directory to start the debugger client in
+@param workingDir directory to start the debugger client in
 @type str
 """
 self.running = False
 if not self.passive or not self.passiveClientExited:
 self.lastClientType = self.clientType
 self.remoteBanner()
 elif self.__autoClearShell:
 self.__autoClearShell = False
 self.remoteBanner()
-##                self.remoteClientVariables(0, [], 0)
-##                self.remoteClientVariables(1, [], 0)
 else:
 if clType and self.lastClientType:
 self.__setClientType(self.lastClientType)
 else:
 self.__createDebuggerInterface("None")
 clientInterpreter = ""
 if clientInterpreter != self.clientInterpreter:
 self.clientInterpreter = clientInterpreter
 self.clientInterpreterChanged.emit(clientInterpreter)
 def __clientProcessOutput(self):
 """
 Private slot to process client output received via stdout.
 """
 output = str(self.clientProcess.readAllStandardOutput(),
 Preferences.getSystem("IOEncoding"),
 'replace')
 self.clientProcessStdout.emit(output)
 def __clientProcessError(self):
 """
 Private slot to process client output received via stderr.
 """
 error = str(self.clientProcess.readAllStandardError(),
 Preferences.getSystem("IOEncoding"),
 'replace')
 self.clientProcessStderr.emit(error)
+@pyqtSlot(str, int)
 def __clientClearBreakPoint(self, fn, lineno):
 """
 Private slot to handle the clientClearBreak signal.
-@param fn filename of breakpoint to clear (string)
+@param fn filename of breakpoint to clear
-@param lineno line number of breakpoint to clear (integer)
+@type str
+@param lineno line number of breakpoint to clear
+@type int
 """
 if self.debugging:
 index = self.breakpointModel.getBreakPointIndex(fn, lineno)
 self.breakpointModel.deleteBreakPointByIndex(index)
+if (fn, lineno) in self.__reportedBreakpointIssues:
+self.__reportedBreakpointIssues.remove((fn, lineno))
 def __deleteBreakPoints(self, parentIndex, start, end):
 """
 Private slot to delete breakpoints.
-@param parentIndex index of parent item (QModelIndex)
+@param parentIndex index of parent item
-@param start start row (integer)
+@type QModelIndex
-@param end end row (integer)
+@param start start row
+@type int
+@param end end row
+@type int
 """
 if self.debugging:
 for row in range(start, end + 1):
 index = self.breakpointModel.index(row, 0, parentIndex)
 fn, lineno = (
 self.breakpointModel.getBreakPointByIndex(index)[0:2])
-self.remoteBreakpoint(fn, lineno, False)
+# delete the breakpoints of all connected backends
+self.remoteBreakpoint("", fn, lineno, False)
+if (fn, lineno) in self.__reportedBreakpointIssues:
+self.__reportedBreakpointIssues.remove((fn, lineno))
 def __changeBreakPoints(self, startIndex, endIndex):
 """
 Private slot to set changed breakpoints.
-@param startIndex starting index of the change breakpoins (QModelIndex)
+@param startIndex starting index of the change breakpoins
-@param endIndex ending index of the change breakpoins (QModelIndex)
+@type QModelIndex
+@param endIndex ending index of the change breakpoins
+@type QModelIndex
 """
 if self.debugging:
 self.__addBreakPoints(
 QModelIndex(), startIndex.row(), endIndex.row())
 def __breakPointDataAboutToBeChanged(self, startIndex, endIndex):
 """
 Private slot to handle the dataAboutToBeChanged signal of the
 breakpoint model.
-@param startIndex start index of the rows to be changed (QModelIndex)
+@param startIndex start index of the rows to be changed
-@param endIndex end index of the rows to be changed (QModelIndex)
+@type QModelIndex
+@param endIndex end index of the rows to be changed
+@type QModelIndex
 """
 if self.debugging:
 self.__deleteBreakPoints(
 QModelIndex(), startIndex.row(), endIndex.row())
-def __addBreakPoints(self, parentIndex, start, end):
+def __addBreakPoints(self, parentIndex, start, end, debuggerId=""):
 """
 Private slot to add breakpoints.
-@param parentIndex index of parent item (QModelIndex)
+@param parentIndex index of parent item
-@param start start row (integer)
+@type QModelIndex
-@param end end row (integer)
+@param start start row
+@type int
+@param end end row
+@type int
+@param debuggerId ID of the debugger backend to send to. If this is
+empty, they will be broadcast to all connected backends.
+@type str
 """
 if self.debugging:
 for row in range(start, end + 1):
 index = self.breakpointModel.index(row, 0, parentIndex)
-fn, line, cond, temp, enabled, ignorecount = (
+fn, lineno, cond, temp, enabled, ignorecount = (
 self.breakpointModel.getBreakPointByIndex(index)[:6])
-self.remoteBreakpoint(fn, line, True, cond, temp)
+if (fn, lineno) in self.__reportedBreakpointIssues:
+self.__reportedBreakpointIssues.remove((fn, lineno))
+self.remoteBreakpoint(debuggerId, fn, lineno, True, cond, temp)
 if not enabled:
-self.__remoteBreakpointEnable(fn, line, False)
+self.__remoteBreakpointEnable(
+debuggerId, fn, lineno, False)
 if ignorecount:
-self.__remoteBreakpointIgnore(fn, line, ignorecount)
+self.__remoteBreakpointIgnore(
+debuggerId, fn, lineno, ignorecount)
 def __makeWatchCondition(self, cond, special):
 """
 Private method to construct the condition string.
-@param cond condition (string)
+@param cond condition
-@param special special condition (string)
+@type str
-@return condition string (string)
+@param special special condition
+@type str
+@return condition string
+@rtype str
 """
 if special == "":
 _cond = cond
 else:
 if special == self.watchSpecialCreated:
 _cond = "{0} ??created??".format(cond)
 elif special == self.watchSpecialChanged:
 _cond = "{0} ??changed??".format(cond)
 return _cond
 def __splitWatchCondition(self, cond):
 """
 Private method to split a remote watch expression.
-@param cond remote expression (string)
+@param cond remote expression
+@type str
 @return tuple of local expression (string) and special condition
-(string)
+@rtype str
 """
 if cond.endswith(" ??created??"):
 cond, special = cond.split()
 special = self.watchSpecialCreated
 elif cond.endswith(" ??changed??"):
 else:
 cond = cond
 special = ""
 return cond, special
+@pyqtSlot(str)
 def __clientClearWatchPoint(self, condition):
 """
 Private slot to handle the clientClearWatch signal.
-@param condition expression of watch expression to clear (string)
+@param condition expression of watch expression to clear
+@type str
 """
 if self.debugging:
 cond, special = self.__splitWatchCondition(condition)
 index = self.watchpointModel.getWatchPointIndex(cond, special)
 self.watchpointModel.deleteWatchPointByIndex(index)
+if condition in self.__reportedWatchpointIssues:
+self.__reportedWatchpointIssues.remove(condition)
 def __deleteWatchPoints(self, parentIndex, start, end):
 """
 Private slot to delete watch expressions.
-@param parentIndex index of parent item (QModelIndex)
+@param parentIndex index of parent item
-@param start start row (integer)
+@type QModelIndex
-@param end end row (integer)
+@param start start row
+@type int
+@param end end row
+@type int
 """
 if self.debugging:
 for row in range(start, end + 1):
 index = self.watchpointModel.index(row, 0, parentIndex)
 cond, special = (
 self.watchpointModel.getWatchPointByIndex(index)[0:2])
 cond = self.__makeWatchCondition(cond, special)
-self.__remoteWatchpoint(cond, False)
+self.__remoteWatchpoint("", cond, False)
+if cond in self.__reportedWatchpointIssues:
+self.__reportedWatchpointIssues.remove(cond)
 def __watchPointDataAboutToBeChanged(self, startIndex, endIndex):
 """
 Private slot to handle the dataAboutToBeChanged signal of the
 watch expression model.
-@param startIndex start index of the rows to be changed (QModelIndex)
+@param startIndex start index of the rows to be changed
-@param endIndex end index of the rows to be changed (QModelIndex)
+@type QModelIndex
+@param endIndex end index of the rows to be changed
+@type QModelIndex
 """
 if self.debugging:
 self.__deleteWatchPoints(
 QModelIndex(), startIndex.row(), endIndex.row())
-def __addWatchPoints(self, parentIndex, start, end):
+def __addWatchPoints(self, parentIndex, start, end, debuggerId=""):
 """
 Private slot to set a watch expression.
-@param parentIndex index of parent item (QModelIndex)
+@param parentIndex index of parent item
-@param start start row (integer)
+@type QModelIndex
-@param end end row (integer)
+@param start start row
+@type int
+@param end end row
+@type int
+@param debuggerId ID of the debugger backend to send to. If this is
+empty, they will be broadcast to all connected backends.
+@type str
 """
 if self.debugging:
 for row in range(start, end + 1):
 index = self.watchpointModel.index(row, 0, parentIndex)
 cond, special, temp, enabled, ignorecount = (
 self.watchpointModel.getWatchPointByIndex(index)[:5])
 cond = self.__makeWatchCondition(cond, special)
-self.__remoteWatchpoint(cond, True, temp)
+if cond in self.__reportedWatchpointIssues:
+self.__reportedWatchpointIssues.remove(cond)
+self.__remoteWatchpoint(debuggerId, cond, True, temp)
 if not enabled:
-self.__remoteWatchpointEnable(cond, False)
+self.__remoteWatchpointEnable(debuggerId, cond, False)
 if ignorecount:
-self.__remoteWatchpointIgnore(cond, ignorecount)
+self.__remoteWatchpointIgnore(debuggerId, cond,
+ignorecount)
 def __changeWatchPoints(self, startIndex, endIndex):
 """
 Private slot to set changed watch expressions.
-@param startIndex start index of the rows to be changed (QModelIndex)
+@param startIndex start index of the rows to be changed
-@param endIndex end index of the rows to be changed (QModelIndex)
+@type QModelIndex
+@param endIndex end index of the rows to be changed
+@type QModelIndex
 """
 if self.debugging:
 self.__addWatchPoints(
 QModelIndex(), startIndex.row(), endIndex.row())
 def getClientCapabilities(self, clientType):
 """
 Public method to retrieve the debug clients capabilities.
-@param clientType debug client type (string)
+@param clientType debug client type
-@return debug client capabilities (integer)
+@type str
+@return debug client capabilities
+@rtype int
 """
 try:
 return self.__debuggerInterfaceRegistry[clientType][0]
 except KeyError:
 return 0    # no capabilities
 def getClientInterpreter(self):
 """
 Public method to get the interpreter of the debug client.
-@return interpreter of the debug client (string)
+@return interpreter of the debug client
+@rtype str
 """
 return self.clientInterpreter
 def getClientType(self):
 """
 if self.passive:
 self.__createDebuggerInterface(
 Preferences.getDebugger("PassiveDbgType"))
-accepted = self.debuggerInterface.newConnection(sock)
+self.debuggerInterface.newConnection(sock)
-if accepted:
-# Perform actions necessary, if client type has changed
+def masterClientConnected(self):
-if self.lastClientType != self.clientType:
+"""
-self.lastClientType = self.clientType
+Public method to perform actions after the master client has finally
-self.remoteBanner()
+established the connection.
-elif self.__autoClearShell:
+"""
-self.__autoClearShell = False
+# Perform actions necessary, if client type has changed
-self.remoteBanner()
+if self.lastClientType != self.clientType:
-elif self.passive:
+self.lastClientType = self.clientType
 self.remoteBanner()
+elif self.__autoClearShell:
-self.debuggerInterface.flush()
+self.__autoClearShell = False
+self.remoteBanner()
+elif self.passive:
+self.remoteBanner()
 def shutdownServer(self):
 """
 Public method to cleanly shut down.
 It closes our socket and shuts down
 the debug client. (Needed on Win OS)
 """
 if self.debuggerInterface is not None:
 self.debuggerInterface.shutdown()
 def remoteEnvironment(self, env):
 """
 Public method to set the environment for a program to debug, run, ...
-@param env environment settings (string)
+@param env environment settings
+@type str
 """
 envlist = Utilities.parseEnvironmentString(env)
 envdict = {}
 for el in envlist:
 try:
 value = value[1:-1]
 envdict[key] = value
 except ValueError:
 pass
 self.debuggerInterface.remoteEnvironment(envdict)
 def remoteLoad(self, venvName, fn, argv, wd, env, autoClearShell=True,
 tracePython=False, autoContinue=True, forProject=False,
-runInConsole=False, autoFork=False, forkChild=False,
+runInConsole=False, clientType="", enableCallTrace=False,
-clientType="", enableCallTrace=False):
+enableMultiprocess=False, multiprocessNoDebug=""):
 """
 Public method to load a new program to debug.
 @param venvName name of the virtual environment to be used
 @type str
 @type str
 @param wd the working directory for the program
 @type str
 @param env environment parameter settings
 @type str
-@keyparam autoClearShell flag indicating, that the interpreter window
+@param autoClearShell flag indicating, that the interpreter window
 should be cleared
 @type bool
-@keyparam tracePython flag indicating if the Python library should be
+@param tracePython flag indicating if the Python library should be
 traced as well
 @type bool
-@keyparam autoContinue flag indicating, that the debugger should not
+@param autoContinue flag indicating, that the debugger should not
 stop at the first executable line
 @type bool
-@keyparam forProject flag indicating a project related action
+@param forProject flag indicating a project related action
 @type bool
-@keyparam runInConsole flag indicating to start the debugger in a
+@param runInConsole flag indicating to start the debugger in a
 console window
 @type bool
-@keyparam autoFork flag indicating the automatic fork mode
+@param clientType client type to be used
-@type bool
+@type str
-@keyparam forkChild flag indicating to debug the child after forking
+@param enableCallTrace flag indicating to enable the call trace
-@type bool
-@keyparam clientType client type to be used
-@type str
-@keyparam enableCallTrace flag indicating to enable the call trace
 function
 @type bool
+@param enableMultiprocess flag indicating to perform multiprocess
+debugging
+@type bool
+@param multiprocessNoDebug space separated list of programs not to be
+debugged
+@type str
 """
 self.__autoClearShell = autoClearShell
-self.__autoContinue = autoContinue
+self.__multiprocessNoDebugList = [
+s.strip() for s in multiprocessNoDebug.split(os.pathsep)
+]
 if clientType not in self.getSupportedLanguages():
 # a not supported client language was requested
 E5MessageBox.critical(
 None,
 except KeyError:
 self.__setClientType('Python3')    # assume it is a Python3 file
 self.startClient(False, forProject=forProject,
 runInConsole=runInConsole, venvName=venvName)
-self.setCallTraceEnabled(enableCallTrace)
+self.setCallTraceEnabled("", enableCallTrace)
 self.remoteEnvironment(env)
-self.debuggerInterface.remoteLoad(fn, argv, wd, tracePython,
+self.debuggerInterface.remoteLoad(
-autoContinue, autoFork, forkChild)
+fn, argv, wd, tracePython, autoContinue,
+enableMultiprocess=enableMultiprocess
+)
 self.debugging = True
 self.running = True
 self.__restoreBreakpoints()
 self.__restoreWatchpoints()
+self.__restoreNoDebugList()
 def remoteRun(self, venvName, fn, argv, wd, env, autoClearShell=True,
-forProject=False, runInConsole=False, autoFork=False,
+forProject=False, runInConsole=False, clientType=""):
-forkChild=False, clientType=""):
 """
 Public method to load a new program to run.
 @param venvName name of the virtual environment to be used
 @type str
 @type str
 @param wd the working directory for the program
 @type str
 @param env environment parameter settings
 @type str
-@keyparam autoClearShell flag indicating, that the interpreter window
+@param autoClearShell flag indicating, that the interpreter window
 should be cleared
 @type bool
-@keyparam forProject flag indicating a project related action
+@param forProject flag indicating a project related action
 @type bool
-@keyparam runInConsole flag indicating to start the debugger in a
+@param runInConsole flag indicating to start the debugger in a
 console window
 @type bool
-@keyparam autoFork flag indicating the automatic fork mode
+@param clientType client type to be used
-@type bool
-@keyparam forkChild flag indicating to debug the child after forking
-@type bool
-@keyparam clientType client type to be used
 @type str
 """
 self.__autoClearShell = autoClearShell
 if clientType not in self.getSupportedLanguages():
 self.startClient(False, forProject=forProject,
 runInConsole=runInConsole, venvName=venvName)
 self.remoteEnvironment(env)
-self.debuggerInterface.remoteRun(fn, argv, wd, autoFork, forkChild)
+self.debuggerInterface.remoteRun(fn, argv, wd)
 self.debugging = False
 self.running = True
 def remoteCoverage(self, venvName, fn, argv, wd, env,
 autoClearShell=True, erase=False, forProject=False,
 runInConsole=False, clientType=""):
 """
 Public method to load a new program to collect coverage data.
 @type str
 @param wd the working directory for the program
 @type str
 @param env environment parameter settings
 @type str
-@keyparam autoClearShell flag indicating, that the interpreter window
+@param autoClearShell flag indicating, that the interpreter window
 should be cleared
 @type bool
-@keyparam erase flag indicating that coverage info should be
+@param erase flag indicating that coverage info should be
 cleared first
 @type bool
-@keyparam forProject flag indicating a project related action
+@param forProject flag indicating a project related action
 @type bool
-@keyparam runInConsole flag indicating to start the debugger in a
+@param runInConsole flag indicating to start the debugger in a
 console window
 @type bool
-@keyparam clientType client type to be used
+@param clientType client type to be used
 @type str
 """
 self.__autoClearShell = autoClearShell
 if clientType not in self.getSupportedLanguages():
 self.remoteEnvironment(env)
 self.debuggerInterface.remoteCoverage(fn, argv, wd, erase)
 self.debugging = False
 self.running = True
 def remoteProfile(self, venvName, fn, argv, wd, env,
 autoClearShell=True, erase=False, forProject=False,
 runInConsole=False, clientType=""):
 """
 Public method to load a new program to collect profiling data.
 @type str
 @param wd the working directory for the program
 @type str
 @param env environment parameter settings
 @type str
-@keyparam autoClearShell flag indicating, that the interpreter window
+@param autoClearShell flag indicating, that the interpreter window
 should be cleared
 @type bool
-@keyparam erase flag indicating that coverage info should be
+@param erase flag indicating that coverage info should be
 cleared first
 @type bool
-@keyparam forProject flag indicating a project related action
+@param forProject flag indicating a project related action
 @type bool
-@keyparam runInConsole flag indicating to start the debugger in a
+@param runInConsole flag indicating to start the debugger in a
 console window
 @type bool
-@keyparam clientType client type to be used
+@param clientType client type to be used
 @type str
 """
 self.__autoClearShell = autoClearShell
 if clientType not in self.getSupportedLanguages():
 self.remoteEnvironment(env)
 self.debuggerInterface.remoteProfile(fn, argv, wd, erase)
 self.debugging = False
 self.running = True
-def remoteStatement(self, stmt):
+def remoteStatement(self, debuggerId, stmt):
 """
 Public method to execute a Python statement.
-@param stmt the Python statement to execute (string). It
+@param debuggerId ID of the debugger backend
-should not have a trailing newline.
+@type str
-"""
+@param stmt the Python statement to execute.
-self.debuggerInterface.remoteStatement(stmt)
+@type str
+"""
-def remoteStep(self):
+self.debuggerInterface.remoteStatement(debuggerId, stmt.rstrip())
+def remoteStep(self, debuggerId):
 """
 Public method to single step the debugged program.
-"""
-self.debuggerInterface.remoteStep()
+@param debuggerId ID of the debugger backend
+@type str
-def remoteStepOver(self):
+"""
+self.debuggerInterface.remoteStep(debuggerId)
+def remoteStepOver(self, debuggerId):
 """
 Public method to step over the debugged program.
-"""
-self.debuggerInterface.remoteStepOver()
+@param debuggerId ID of the debugger backend
+@type str
-def remoteStepOut(self):
+"""
+self.debuggerInterface.remoteStepOver(debuggerId)
+def remoteStepOut(self, debuggerId):
 """
 Public method to step out the debugged program.
-"""
-self.debuggerInterface.remoteStepOut()
+@param debuggerId ID of the debugger backend
+@type str
-def remoteStepQuit(self):
+"""
+self.debuggerInterface.remoteStepOut(debuggerId)
+def remoteStepQuit(self, debuggerId):
 """
 Public method to stop the debugged program.
-"""
-self.debuggerInterface.remoteStepQuit()
+@param debuggerId ID of the debugger backend
+@type str
-def remoteContinue(self, special=False):
+"""
+self.debuggerInterface.remoteStepQuit(debuggerId)
+def remoteContinue(self, debuggerId, special=False):
 """
 Public method to continue the debugged program.
+@param debuggerId ID of the debugger backend
+@type str
 @param special flag indicating a special continue operation
 """
-self.debuggerInterface.remoteContinue(special)
+self.debuggerInterface.remoteContinue(debuggerId, special)
-def remoteMoveIP(self, line):
+def remoteContinueUntil(self, debuggerId, line):
+"""
+Public method to continue the debugged program to the given line
+or until returning from the current frame.
+@param debuggerId ID of the debugger backend
+@type str
+@param line the new line, where execution should be continued to
+@type int
+"""
+self.debuggerInterface.remoteContinueUntil(debuggerId, line)
+def remoteMoveIP(self, debuggerId, line):
 """
 Public method to move the instruction pointer to a different line.
+@param debuggerId ID of the debugger backend
+@type str
 @param line the new line, where execution should be continued
-"""
+@type int
-self.debuggerInterface.remoteMoveIP(line)
+"""
+self.debuggerInterface.remoteMoveIP(debuggerId, line)
-def remoteBreakpoint(self, fn, line, setBreakpoint, cond=None, temp=False):
+def remoteBreakpoint(self, debuggerId, fn, line, setBreakpoint, cond=None,
+temp=False):
 """
 Public method to set or clear a breakpoint.
-@param fn filename the breakpoint belongs to (string)
+@param debuggerId ID of the debugger backend
-@param line linenumber of the breakpoint (int)
+@type str
+@param fn filename the breakpoint belongs to
+@type str
+@param line linenumber of the breakpoint
+@type int
 @param setBreakpoint flag indicating setting or resetting a breakpoint
-(boolean)
+@type bool
-@param cond condition of the breakpoint (string)
+@param cond condition of the breakpoint
-@param temp flag indicating a temporary breakpoint (boolean)
+@type str
-"""
+@param temp flag indicating a temporary breakpoint
-self.debuggerInterface.remoteBreakpoint(fn, line, setBreakpoint, cond,
+@type bool
+"""
+self.debuggerInterface.remoteBreakpoint(
+debuggerId, fn, line, setBreakpoint, cond, temp)
+def __remoteBreakpointEnable(self, debuggerId, fn, line, enable):
+"""
+Private method to enable or disable a breakpoint.
+@param debuggerId ID of the debugger backend
+@type str
+@param fn filename the breakpoint belongs to
+@type str
+@param line linenumber of the breakpoint
+@type int
+@param enable flag indicating enabling or disabling a breakpoint
+@type bool
+"""
+self.debuggerInterface.remoteBreakpointEnable(
+debuggerId, fn, line, enable)
+def __remoteBreakpointIgnore(self, debuggerId, fn, line, count):
+"""
+Private method to ignore a breakpoint the next couple of occurrences.
+@param debuggerId ID of the debugger backend
+@type str
+@param fn filename the breakpoint belongs to
+@type str
+@param line linenumber of the breakpoint
+@type int
+@param count number of occurrences to ignore
+@type int
+"""
+self.debuggerInterface.remoteBreakpointIgnore(
+debuggerId, fn, line, count)
+def __remoteWatchpoint(self, debuggerId, cond, setWatch, temp=False):
+"""
+Private method to set or clear a watch expression.
+@param debuggerId ID of the debugger backend
+@type str
+@param cond expression of the watch expression
+@type str
+@param setWatch flag indicating setting or resetting a watch expression
+@type bool
+@param temp flag indicating a temporary watch expression
+@type bool
+"""
+# cond is combination of cond and special (s. watch expression viewer)
+self.debuggerInterface.remoteWatchpoint(debuggerId, cond, setWatch,
 temp)
-def __remoteBreakpointEnable(self, fn, line, enable):
+def __remoteWatchpointEnable(self, debuggerId, cond, enable):
 """
-Private method to enable or disable a breakpoint.
+Private method to enable or disable a watch expression.
-@param fn filename the breakpoint belongs to (string)
+@param debuggerId ID of the debugger backend
-@param line linenumber of the breakpoint (int)
+@type str
-@param enable flag indicating enabling or disabling a breakpoint
+@param cond expression of the watch expression
-(boolean)
+@type str
-"""
+@param enable flag indicating enabling or disabling a watch expression
-self.debuggerInterface.remoteBreakpointEnable(fn, line, enable)
+@type bool
-def __remoteBreakpointIgnore(self, fn, line, count):
-"""
-Private method to ignore a breakpoint the next couple of occurrences.
-@param fn filename the breakpoint belongs to (string)
-@param line linenumber of the breakpoint (int)
-@param count number of occurrences to ignore (int)
-"""
-self.debuggerInterface.remoteBreakpointIgnore(fn, line, count)
-def __remoteWatchpoint(self, cond, setWatch, temp=False):
-"""
-Private method to set or clear a watch expression.
-@param cond expression of the watch expression (string)
-@param setWatch flag indicating setting or resetting a watch expression
-(boolean)
-@param temp flag indicating a temporary watch expression (boolean)
 """
 # cond is combination of cond and special (s. watch expression viewer)
-self.debuggerInterface.remoteWatchpoint(cond, setWatch, temp)
+self.debuggerInterface.remoteWatchpointEnable(debuggerId, cond, enable)
-def __remoteWatchpointEnable(self, cond, enable):
+def __remoteWatchpointIgnore(self, debuggerId, cond, count):
-"""
-Private method to enable or disable a watch expression.
-@param cond expression of the watch expression (string)
-@param enable flag indicating enabling or disabling a watch expression
-(boolean)
-"""
-# cond is combination of cond and special (s. watch expression viewer)
-self.debuggerInterface.remoteWatchpointEnable(cond, enable)
-def __remoteWatchpointIgnore(self, cond, count):
 """
 Private method to ignore a watch expression the next couple of
 occurrences.
-@param cond expression of the watch expression (string)
+@param debuggerId ID of the debugger backend
-@param count number of occurrences to ignore (int)
+@type str
+@param cond expression of the watch expression
+@type str
+@param count number of occurrences to ignore
+@type int
 """
 # cond is combination of cond and special (s. watch expression viewer)
-self.debuggerInterface.remoteWatchpointIgnore(cond, count)
+self.debuggerInterface.remoteWatchpointIgnore(debuggerId, cond, count)
-def remoteRawInput(self, s):
+def remoteRawInput(self, debuggerId, inputString):
 """
 Public method to send the raw input to the debugged program.
-@param s the raw input (string)
+@param debuggerId ID of the debugger backend
-"""
+@type str
-self.debuggerInterface.remoteRawInput(s)
+@param inputString the raw input
-self.clientRawInputSent.emit()
+@type str
+"""
-def remoteThreadList(self):
+self.debuggerInterface.remoteRawInput(debuggerId, inputString)
+self.clientRawInputSent.emit(debuggerId)
+def remoteThreadList(self, debuggerId):
 """
 Public method to request the list of threads from the client.
-"""
-self.debuggerInterface.remoteThreadList()
+@param debuggerId ID of the debugger backend
+@type str
-def remoteSetThread(self, tid):
+"""
+self.debuggerInterface.remoteThreadList(debuggerId)
+def remoteSetThread(self, debuggerId, tid):
 """
 Public method to request to set the given thread as current thread.
-@param tid id of the thread (integer)
+@param debuggerId ID of the debugger backend
-"""
+@type str
-self.debuggerInterface.remoteSetThread(tid)
+@param tid id of the thread
+@type int
-def remoteClientVariables(self, scope, filterList, framenr=0):
+"""
+self.debuggerInterface.remoteSetThread(debuggerId, tid)
+def remoteClientStack(self, debuggerId):
+"""
+Public method to request the stack of the main thread.
+@param debuggerId ID of the debugger backend
+@type str
+"""
+self.debuggerInterface.remoteClientStack(debuggerId)
+def remoteClientVariables(self, debuggerId, scope, filterList, framenr=0):
 """
 Public method to request the variables of the debugged program.
+@param debuggerId ID of the debugger backend
+@type str
 @param scope the scope of the variables (0 = local, 1 = global)
-@param filterList list of variable types to filter out (list of int)
+@type int
-@param framenr framenumber of the variables to retrieve (int)
+@param filterList list of variable types to filter out
+@type list of str
+@param framenr framenumber of the variables to retrieve
+@type int
 """
 self.debuggerInterface.remoteClientVariables(
-scope, filterList, framenr, self.__maxVariableSize)
+debuggerId, scope, filterList, framenr, self.__maxVariableSize)
-def remoteClientVariable(self, scope, filterList, var, framenr=0):
+def remoteClientVariable(self, debuggerId, scope, filterList, var,
+framenr=0, maxSize=0):
 """
 Public method to request the variables of the debugged program.
+@param debuggerId ID of the debugger backend
+@type str
 @param scope the scope of the variables (0 = local, 1 = global)
-@param filterList list of variable types to filter out (list of int)
+@type int
-@param var list encoded name of variable to retrieve (string)
+@param filterList list of variable types to filter out
-@param framenr framenumber of the variables to retrieve (int)
+@type list of str
+@param var list encoded name of variable to retrieve
+@type list of str
+@param framenr framenumber of the variables to retrieve
+@type int
+@param maxSize maximum size the formatted value of a variable will
+be shown. If it is bigger than that, a 'too big' indication will
+be given (@@TOO_BIG_TO_SHOW@@).
+@type int
 """
 self.debuggerInterface.remoteClientVariable(
-scope, filterList, var, framenr, self.__maxVariableSize)
+debuggerId, scope, filterList, var, framenr,
+self.__maxVariableSize)
-def remoteClientDisassembly(self):
+def remoteClientDisassembly(self, debuggerId):
 """
 Public method to ask the client for the latest traceback disassembly.
+@param debuggerId ID of the debugger backend
+@type str
 """
 try:
-self.debuggerInterface.remoteClientDisassembly()
+self.debuggerInterface.remoteClientDisassembly(debuggerId)
 except AttributeError:
 # remote client doesn't support that
 pass
-def remoteClientSetFilter(self, scope, filterStr):
+def remoteClientSetFilter(self, debuggerId, scope, filterStr):
 """
 Public method to set a variables filter list.
+@param debuggerId ID of the debugger backend
+@type str
 @param scope the scope of the variables (0 = local, 1 = global)
+@type int
 @param filterStr regexp string for variable names to filter out
-(string)
+@type str
 """
-self.debuggerInterface.remoteClientSetFilter(scope, filterStr)
+self.debuggerInterface.remoteClientSetFilter(
+debuggerId, scope, filterStr)
-def setCallTraceEnabled(self, on):
+def setCallTraceEnabled(self, debuggerId, on):
 """
 Public method to set the call trace state.
-@param on flag indicating to enable the call trace function (boolean)
+@param debuggerId ID of the debugger backend
-"""
+@type str
-self.debuggerInterface.setCallTraceEnabled(on)
+@param on flag indicating to enable the call trace function
+@type bool
+"""
+self.debuggerInterface.setCallTraceEnabled(debuggerId, on)
 def remoteBanner(self):
 """
 Public slot to get the banner info of the remote client.
 """
 self.debuggerInterface.remoteBanner()
 def remoteCapabilities(self):
 """
 Public slot to get the debug clients capabilities.
 """
 self.debuggerInterface.remoteCapabilities()
-def remoteCompletion(self, text):
+def remoteCompletion(self, debuggerId, text):
 """
 Public slot to get the a list of possible commandline completions
 from the remote client.
-@param text the text to be completed (string)
+@param debuggerId ID of the debugger backend
-"""
+@type str
-self.debuggerInterface.remoteCompletion(text)
+@param text the text to be completed
+@type str
+"""
+self.debuggerInterface.remoteCompletion(debuggerId, text)
 def remoteUTDiscover(self, clientType, forProject, venvName, syspath,
 workdir, discoveryStart):
 """
 Public method to perform a test case discovery.
 self.running = True
 self.debugging = debug
 if debug:
 self.__restoreBreakpoints()
 self.__restoreWatchpoints()
 def remoteUTRun(self, debug=False, failfast=False):
 """
 Public method to start a unittest run.
 @param debug flag indicating to run unittest with debugging
 @type bool
 @param failfast flag indicating to stop at the first error
 @type bool
 """
 self.debuggerInterface.remoteUTRun(debug, failfast)
 def remoteUTStop(self):
 """
 public method to stop a unittest run.
 """
 self.debuggerInterface.remoteUTStop()
-def signalClientOutput(self, line):
+def signalClientOutput(self, line, debuggerId):
 """
 Public method to process a line of client output.
-@param line client output (string)
+@param line client output
-"""
+@type str
-self.clientOutput.emit(line)
+@param debuggerId ID of the debugger backend
+@type str
-def signalClientLine(self, filename, lineno, forStack=False):
+"""
+if debuggerId:
+self.clientOutput.emit("{0}: {1}".format(debuggerId, line))
+else:
+self.clientOutput.emit(line)
+def signalClientLine(self, filename, lineno, debuggerId, forStack=False,
+threadName=""):
 """
 Public method to process client position feedback.
-@param filename name of the file currently being executed (string)
+@param filename name of the file currently being executed
-@param lineno line of code currently being executed (integer)
+@type str
-@param forStack flag indicating this is for a stack dump (boolean)
+@param lineno line of code currently being executed
-"""
+@type int
-self.clientLine.emit(filename, lineno, forStack)
+@param debuggerId ID of the debugger backend
+@type str
-def signalClientStack(self, stack):
+@param forStack flag indicating this is for a stack dump
+@type bool
+@param threadName name of the thread signaling the event
+@type str
+"""
+self.clientLine.emit(filename, lineno, debuggerId, threadName,
+forStack)
+def signalClientStack(self, stack, debuggerId, threadName=""):
 """
 Public method to process a client's stack information.
 @param stack list of stack entries. Each entry is a tuple of three
 values giving the filename, linenumber and method
-(list of lists of (string, integer, string))
+@type list of lists of (string, integer, string)
-"""
+@param debuggerId ID of the debugger backend
-self.clientStack.emit(stack)
+@type str
+@param threadName name of the thread signaling the event
-def signalClientThreadList(self, currentId, threadList):
+@type str
+"""
+self.clientStack.emit(stack, debuggerId, threadName)
+def signalClientThreadList(self, currentId, threadList, debuggerId):
 """
 Public method to process the client thread list info.
-@param currentId id of the current thread (integer)
+@param currentId id of the current thread
+@type int
 @param threadList list of dictionaries containing the thread data
-"""
+@type list of dict
-self.clientThreadList.emit(currentId, threadList)
+@param debuggerId ID of the debugger backend
+@type str
-def signalClientThreadSet(self):
+"""
+self.clientThreadList.emit(currentId, threadList, debuggerId)
+def signalClientThreadSet(self, debuggerId):
 """
 Public method to handle the change of the client thread.
-"""
-self.clientThreadSet.emit()
+@param debuggerId ID of the debugger backend
+@type str
-def signalClientVariables(self, scope, variables):
+"""
+self.clientThreadSet.emit(debuggerId)
+def signalClientVariables(self, scope, variables, debuggerId):
 """
 Public method to process the client variables info.
 @param scope scope of the variables (-1 = empty global, 1 = global,
 0 = local)
+@type int
 @param variables the list of variables from the client
-"""
+@type list
-self.clientVariables.emit(scope, variables)
+@param debuggerId ID of the debugger backend
+@type str
-def signalClientVariable(self, scope, variables):
+"""
+self.clientVariables.emit(scope, variables, debuggerId)
+def signalClientVariable(self, scope, variables, debuggerId):
 """
 Public method to process the client variable info.
 @param scope scope of the variables (-1 = empty global, 1 = global,
 0 = local)
+@type int
 @param variables the list of members of a classvariable from the client
-"""
+@type list
-self.clientVariable.emit(scope, variables)
+@param debuggerId ID of the debugger backend
+@type str
-def signalClientStatement(self, more):
+"""
+self.clientVariable.emit(scope, variables, debuggerId)
+def signalClientStatement(self, more, debuggerId):
 """
 Public method to process the input response from the client.
 @param more flag indicating that more user input is required
-"""
+@type bool
-self.clientStatement.emit(more)
+@param debuggerId ID of the debugger backend
+@type str
-def signalClientDisassembly(self, disassembly):
+"""
+self.clientStatement.emit(more, debuggerId)
+def signalClientDisassembly(self, disassembly, debuggerId):
 """
 Public method to process the disassembly info from the client.
 @param disassembly dictionary containing the disassembly information
 @type dict
+@param debuggerId ID of the debugger backend
+@type str
 """
 if self.running:
-self.clientDisassembly.emit(disassembly)
+self.clientDisassembly.emit(disassembly, debuggerId)
 def signalClientException(self, exceptionType, exceptionMessage,
-stackTrace):
+stackTrace, debuggerId, threadName=""):
 """
 Public method to process the exception info from the client.
-@param exceptionType type of exception raised (string)
+@param exceptionType type of exception raised
-@param exceptionMessage message given by the exception (string)
+@type str
+@param exceptionMessage message given by the exception
+@type str
 @param stackTrace list of stack entries with the exception position
 first. Each stack entry is a list giving the filename and the
 linenumber.
+@type list
+@param debuggerId ID of the debugger backend
+@type str
+@param threadName name of the thread signaling the event
+@type str
 """
 if self.running:
 self.clientException.emit(exceptionType, exceptionMessage,
-stackTrace)
+stackTrace, debuggerId, threadName)
-def signalClientSyntaxError(self, message, filename, lineNo, characterNo):
+def signalClientSyntaxError(self, message, filename, lineNo, characterNo,
-"""
+debuggerId, threadName=""):
-Public method to process the syntax error info from the client.
+"""
+Public method to process a syntax error info from the client.
-@param message message of the syntax error (string)
+@param message message of the syntax error
+@type str
 @param filename translated filename of the syntax error position
-(string)
+@type str
-@param lineNo line number of the syntax error position (integer)
+@param lineNo line number of the syntax error position
+@type int
 @param characterNo character number of the syntax error position
-(integer)
+@type int
+@param debuggerId ID of the debugger backend
+@type str
+@param threadName name of the thread signaling the event
+@type str
 """
 if self.running:
-self.clientSyntaxError.emit(message, filename, lineNo, characterNo)
+self.clientSyntaxError.emit(message, filename, lineNo, characterNo,
+debuggerId, threadName)
 def signalClientSignal(self, message, filename, lineNo,
-funcName, funcArgs):
+funcName, funcArgs, debuggerId):
 """
 Public method to process a signal generated on the client side.
 @param message message of the syntax error
 @type str
 @param lineNo line number of the syntax error position
 @type int
 @param funcName name of the function causing the signal
 @type str
 @param funcArgs function arguments
+@type str
+@param debuggerId ID of the debugger backend
 @type str
 """
 if self.running:
 self.clientSignal.emit(message, filename, lineNo,
-funcName, funcArgs)
+funcName, funcArgs, debuggerId)
-def signalClientExit(self, status, message=""):
+def signalClientDisconnected(self, debuggerId):
+"""
+Public method to send a signal when a debug client has closed its
+connection.
+@param debuggerId ID of the debugger backend
+@type str
+"""
+self.clientDisconnected.emit(debuggerId)
+def signalClientExit(self, program, status, message, debuggerId):
 """
 Public method to process the client exit status.
+@param program name of the exited program
+@type str
 @param status exit code
 @type int
 @param message message sent with the exit
 @type str
+@param debuggerId ID of the debugger backend
+@type str
+"""
+self.clientExit.emit(program, int(status), message, False, debuggerId)
+def signalLastClientExited(self):
+"""
+Public method to process the last client exit event.
 """
 if self.passive:
 self.__passiveShutDown()
-self.clientExit.emit(int(status), message, False)
+self.lastClientExited.emit()
 if Preferences.getDebugger("AutomaticReset") or (self.running and
 not self.debugging):
 self.debugging = False
 self.startClient(False, forProject=self.__forProject)
 if self.passive:
 self.__createDebuggerInterface("None")
 self.signalClientOutput(self.tr('\nNot connected\n'))
-self.signalClientStatement(False)
+self.signalClientStatement(False, "")
 self.running = False
-def signalClientClearBreak(self, filename, lineno):
+def signalClientClearBreak(self, filename, lineno, debuggerId):
 """
 Public method to process the client clear breakpoint command.
-@param filename filename of the breakpoint (string)
+@param filename filename of the breakpoint
-@param lineno line umber of the breakpoint (integer)
+@type str
-"""
+@param lineno line umber of the breakpoint
-self.clientClearBreak.emit(filename, lineno)
+@type int
+@param debuggerId ID of the debugger backend
-def signalClientBreakConditionError(self, filename, lineno):
+@type str
+"""
+self.clientClearBreak.emit(filename, lineno, debuggerId)
+def signalClientBreakConditionError(self, filename, lineno, debuggerId):
 """
 Public method to process the client breakpoint condition error info.
-@param filename filename of the breakpoint (string)
+@param filename filename of the breakpoint
-@param lineno line umber of the breakpoint (integer)
+@type str
-"""
+@param lineno line umber of the breakpoint
-self.clientBreakConditionError.emit(filename, lineno)
+@type int
+@param debuggerId ID of the debugger backend
-def signalClientClearWatch(self, condition):
+@type str
+"""
+if (filename, lineno) not in self.__reportedBreakpointIssues:
+self.__reportedBreakpointIssues.append((filename, lineno))
+self.clientBreakConditionError.emit(filename, lineno, debuggerId)
+def signalClientClearWatch(self, condition, debuggerId):
 """
 Public slot to handle the clientClearWatch signal.
-@param condition expression of watch expression to clear (string)
+@param condition expression of watch expression to clear
-"""
+@type str
-self.clientClearWatch.emit(condition)
+@param debuggerId ID of the debugger backend
+@type str
-def signalClientWatchConditionError(self, condition):
+"""
+self.clientClearWatch.emit(condition, debuggerId)
+def signalClientWatchConditionError(self, condition, debuggerId):
 """
 Public method to process the client watch expression error info.
-@param condition expression of watch expression to clear (string)
+@param condition expression of watch expression to clear
-"""
+@type str
-self.clientWatchConditionError.emit(condition)
+@param debuggerId ID of the debugger backend
+@type str
-def signalClientRawInput(self, prompt, echo):
+"""
+if condition not in self.__reportedWatchpointIssues:
+self.__reportedWatchpointIssues.append(condition)
+self.clientWatchConditionError.emit(condition, debuggerId)
+def signalClientRawInput(self, prompt, echo, debuggerId):
 """
 Public method to process the client raw input command.
-@param prompt the input prompt (string)
+@param prompt the input prompt
-@param echo flag indicating an echoing of the input (boolean)
+@type str
-"""
+@param echo flag indicating an echoing of the input
-self.clientRawInput.emit(prompt, echo)
+@type bool
+@param debuggerId ID of the debugger backend
-def signalClientBanner(self, version, platform, debugClient, venvName):
+@type str
+"""
+self.clientRawInput.emit(prompt, echo, debuggerId)
+def signalClientBanner(self, version, platform, venvName):
 """
 Public method to process the client banner info.
 @param version interpreter version info
 @type str
 @param platform hostname of the client
 @type str
-@param debugClient additional debugger type info
-@type str
 @param venvName name of the virtual environment
 @type str
 """
-self.clientBanner.emit(version, platform, debugClient, venvName)
+self.clientBanner.emit(version, platform, venvName)
 def signalClientCapabilities(self, capabilities, clientType, venvName):
 """
 Public method to process the client capabilities info.
 self.__debuggerInterfaceRegistry[clientType][0] = capabilities
 self.clientCapabilities.emit(capabilities, clientType, venvName)
 except KeyError:
 # ignore silently
 pass
-def signalClientCompletionList(self, completionList, text):
+def signalClientCompletionList(self, completionList, text, debuggerId):
 """
 Public method to process the client auto completion info.
-@param completionList list of possible completions (list of strings)
+@param completionList list of possible completions
-@param text the text to be completed (string)
+@type list of str
+@param text the text to be completed
+@type str
+@param debuggerId ID of the debugger backend
+@type str
 """
 self.clientCompletionList.emit(completionList, text)
 def signalClientCallTrace(self, isCall, fromFile, fromLine, fromFunction,
-toFile, toLine, toFunction):
+toFile, toLine, toFunction, debuggerId):
 """
 Public method to process the client call trace data.
-@param isCall flag indicating a 'call' (boolean)
+@param isCall flag indicating a 'call'
-@param fromFile name of the originating file (string)
+@type bool
-@param fromLine line number in the originating file (string)
+@param fromFile name of the originating file
-@param fromFunction name of the originating function (string)
+@type str
-@param toFile name of the target file (string)
+@param fromLine line number in the originating file
-@param toLine line number in the target file (string)
+@type str
-@param toFunction name of the target function (string)
+@param fromFunction name of the originating function
+@type str
+@param toFile name of the target file
+@type str
+@param toLine line number in the target file
+@type str
+@param toFunction name of the target function
+@type str
+@param debuggerId ID of the debugger backend
+@type str
 """
 self.callTraceInfo.emit(
 isCall, fromFile, fromLine, fromFunction,
-toFile, toLine, toFunction)
+toFile, toLine, toFunction, debuggerId)
 def clientUtDiscovered(self, testCases, exceptionType, exceptionValue):
 """
 Public method to process the client unittest discover info.
 @param testCases list of detected test cases
 @type str
 @param exceptionValue exception message
 @type str
 """
 self.utDiscovered.emit(testCases, exceptionType, exceptionValue)
 def clientUtPrepared(self, result, exceptionType, exceptionValue):
 """
 Public method to process the client unittest prepared info.
-@param result number of test cases (0 = error) (integer)
+@param result number of test cases (0 = error)
-@param exceptionType exception type (string)
+@type int
-@param exceptionValue exception message (string)
+@param exceptionType exception type
+@type str
+@param exceptionValue exception message
+@type str
 """
 self.utPrepared.emit(result, exceptionType, exceptionValue)
 def clientUtStartTest(self, testname, doc):
 """
 Public method to process the client start test info.
-@param testname name of the test (string)
+@param testname name of the test
-@param doc short description of the test (string)
+@type str
+@param doc short description of the test
+@type str
 """
 self.utStartTest.emit(testname, doc)
 def clientUtStopTest(self):
 """
 Public method to process the client stop test info.
 """
 self.utStopTest.emit()
 def clientUtTestFailed(self, testname, traceback, testId):
 """
 Public method to process the client test failed info.
-@param testname name of the test (string)
+@param testname name of the test
-@param traceback lines of traceback info (list of strings)
+@type str
-@param testId id of the test (string)
+@param traceback lines of traceback info
+@type list of str
+@param testId id of the test
+@type str
 """
 self.utTestFailed.emit(testname, traceback, testId)
 def clientUtTestErrored(self, testname, traceback, testId):
 """
 Public method to process the client test errored info.
-@param testname name of the test (string)
+@param testname name of the test
-@param traceback lines of traceback info (list of strings)
+@type str
-@param testId id of the test (string)
+@param traceback lines of traceback info
+@type list of str
+@param testId id of the test
+@type str
 """
 self.utTestErrored.emit(testname, traceback, testId)
 def clientUtTestSkipped(self, testname, reason, testId):
 """
 Public method to process the client test skipped info.
-@param testname name of the test (string)
+@param testname name of the test
-@param reason reason for skipping the test (string)
+@type str
-@param testId id of the test (string)
+@param reason reason for skipping the test
+@type str
+@param testId id of the test
+@type str
 """
 self.utTestSkipped.emit(testname, reason, testId)
 def clientUtTestFailedExpected(self, testname, traceback, testId):
 """
 Public method to process the client test failed expected info.
-@param testname name of the test (string)
+@param testname name of the test
-@param traceback lines of traceback info (list of strings)
+@type str
-@param testId id of the test (string)
+@param traceback lines of traceback info
+@type list of str
+@param testId id of the test
+@type str
 """
 self.utTestFailedExpected.emit(testname, traceback, testId)
 def clientUtTestSucceededUnexpected(self, testname, testId):
 """
 Public method to process the client test succeeded unexpected info.
-@param testname name of the test (string)
+@param testname name of the test
-@param testId id of the test (string)
+@type str
+@param testId id of the test
+@type str
 """
 self.utTestSucceededUnexpected.emit(testname, testId)
 def clientUtFinished(self, status):
 """
 Public method to process the client unit test finished info.
 @param status exit status of the unit test
 @type int
 """
 self.utFinished.emit()
-self.clientExit.emit(int(status), "", True)
+self.clientExit.emit("", int(status), "", True, "")
 self.debugging = False
 self.running = False
-def passiveStartUp(self, fn, exc):
+def passiveStartUp(self, fn, exc, debuggerId):
 """
 Public method to handle a passive debug connection.
-@param fn filename of the debugged script (string)
+@param fn filename of the debugged script
-@param exc flag to enable exception reporting of the IDE (boolean)
+@type str
+@param exc flag to enable exception reporting of the IDE
+@type bool
+@param debuggerId ID of the debugger backend
+@type str
 """
 self.appendStdout.emit(self.tr("Passive debug connection received\n"))
 self.passiveClientExited = False
 self.debugging = True
 self.running = True
-self.__restoreBreakpoints()
+self.__restoreBreakpoints(debuggerId)
-self.__restoreWatchpoints()
+self.__restoreWatchpoints(debuggerId)
 self.passiveDebugStarted.emit(fn, exc)
 def __passiveShutDown(self):
 """
 Private method to shut down a passive debug connection.
 """
 self.passiveClientExited = True
 self.shutdownServer()
 self.appendStdout.emit(self.tr("Passive debug connection closed\n"))
-def __restoreBreakpoints(self):
+def __restoreBreakpoints(self, debuggerId=""):
 """
 Private method to restore the breakpoints after a restart.
+@param debuggerId ID of the debugger backend to send to. If this is
+empty, they will be broadcast to all connected backends.
+@type str
 """
 if self.debugging:
 self.__addBreakPoints(
-QModelIndex(), 0, self.breakpointModel.rowCount() - 1)
+QModelIndex(), 0, self.breakpointModel.rowCount() - 1,
+debuggerId)
-def __restoreWatchpoints(self):
+def __restoreWatchpoints(self, debuggerId=""):
 """
 Private method to restore the watch expressions after a restart.
+@param debuggerId ID of the debugger backend to send to. If this is
+empty, they will be broadcast to all connected backends.
+@type str
 """
 if self.debugging:
 self.__addWatchPoints(
-QModelIndex(), 0, self.watchpointModel.rowCount() - 1)
+QModelIndex(), 0, self.watchpointModel.rowCount() - 1,
+debuggerId)
 def getBreakPointModel(self):
 """
 Public slot to get a reference to the breakpoint model object.
-@return reference to the breakpoint model object (BreakPointModel)
+@return reference to the breakpoint model object
+@rtype BreakPointModel
 """
 return self.breakpointModel
 def getWatchPointModel(self):
 """
 Public slot to get a reference to the watch expression model object.
 @return reference to the watch expression model object
-(WatchPointModel)
+@rtype WatchPointModel
 """
 return self.watchpointModel
 def isConnected(self):
 """
 Public method to test, if the debug server is connected to a backend.
-@return flag indicating a connection (boolean)
+@return flag indicating a connection
+@rtype bool
 """
 return self.debuggerInterface and self.debuggerInterface.isConnected()
 def isDebugging(self):
 """
 @param on flag indicating the new debugging state
 @type bool
 """
 self.debugging = on
+def signalClientDebuggerId(self, debuggerId):
+"""
+Public method to signal the receipt of a new debugger ID.
+This signal indicates, that a new debugger backend has connected.
+@param debuggerId ID of the newly connected debugger backend
+@type str
+"""
+self.clientDebuggerId.emit(debuggerId)
+def getDebuggerIds(self):
+"""
+Public method to return the IDs of the connected debugger backends.
+@return list of connected debugger backend IDs
+@rtype list of str
+"""
+if self.debuggerInterface:
+return self.debuggerInterface.getDebuggerIds()
+else:
+return []
+def initializeClient(self, debuggerId):
+"""
+Public method to initialize a freshly connected debug client.
+@param debuggerId ID of the connected debugger
+@type str
+"""
+self.__restoreBreakpoints(debuggerId)
+self.__restoreWatchpoints(debuggerId)
+self.__restoreNoDebugList(debuggerId)
+def __restoreNoDebugList(self, debuggerId=""):
+"""
+Private method to restore the list of scripts not to be debugged after
+a restart.
+@param debuggerId ID of the debugger backend to send to. If this is
+empty, they will be broadcast to all connected backends.
+@type str
+"""
+if self.debugging:
+self.debuggerInterface.remoteNoDebugList(
+debuggerId, self.__multiprocessNoDebugList)

Mercurial Repositories > eric / file comparison

comparison: eric6/Debugger/DebugServer.py

eric6/Debugger/DebugServer.py