eric: comparison eric6/Debugger/DebugServer.py

-:3de001de249c
+:770ffcb88be5
 import os
 import sys
-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, debuggerId, forStack) emitted after
 the debug client has executed a line of code
 @signal clientStack(stack, debuggerId) emitted after the debug client has
 executed a line of code
 @signal clientThreadList(currentId, threadList, debuggerId) emitted after
 @signal clientExit(int, str, bool, str) emitted after the client has exited
 giving the exit status, an exit message, an indication to be quiet and
 the ID of the exited client
 @signal lastClientExited() emitted to indicate that the last connected
 debug client has terminated
-@signal clientClearBreak(filename, lineno) emitted after the debug client
+@signal clientClearBreak(filename, lineno, debuggerId) emitted after the
-has decided to clear a temporary breakpoint
+debug client has decided to clear a temporary breakpoint
-@signal clientBreakConditionError(fn, lineno) emitted after the client has
+@signal clientBreakConditionError(fn, lineno, debuggerId) emitted after the
-signaled a syntax error in a breakpoint condition
+client has signaled a syntax error in a breakpoint condition
-@signal clientClearWatch(condition) emitted after the debug client
+@signal clientClearWatch(condition, debuggerId) emitted after the debug
-has decided to clear a temporary watch expression
+client has decided to clear a temporary watch expression
-@signal clientWatchConditionError(condition) emitted after the client has
+@signal clientWatchConditionError(condition, debuggerId) emitted after the
-signaled a syntax error in a watch expression
+client has signaled a syntax error in a watch expression
-@signal clientRawInput(prompt, echo) emitted after a raw input request was
+@signal clientRawInput(prompt, echo, debuggerId) emitted after a raw input
-received
+request was received
 @signal clientBanner(version, platform, dbgclient, 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 appendStdout(msg) emitted when a passive debug connection is
 established or lost
 @signal clientDebuggerIds(debuggerIds) emitted to give the list of IDs of
 attached debugger backends
 """
-clientClearBreak = pyqtSignal(str, int)
+clientClearBreak = pyqtSignal(str, int, str)
-clientClearWatch = pyqtSignal(str)
+clientClearWatch = pyqtSignal(str, str)
+# TODO: check this signal for debuggerId
 clientGone = pyqtSignal(bool)
 clientProcessStdout = pyqtSignal(str)
 clientProcessStderr = pyqtSignal(str)
-clientRawInputSent = pyqtSignal()
+clientRawInputSent = pyqtSignal(str)
 clientOutput = pyqtSignal(str)
 clientLine = pyqtSignal(str, int, str, bool)
 clientStack = pyqtSignal(list, str)
 clientThreadList = pyqtSignal(int, list, str)
 clientThreadSet = pyqtSignal(str)
 clientException = pyqtSignal(str, str, list, str)
 clientSyntaxError = pyqtSignal(str, str, int, int, str)
 clientSignal = pyqtSignal(str, str, int, str, str, str)
 clientExit = pyqtSignal(int, str, bool, str)
 lastClientExited = pyqtSignal()
-clientBreakConditionError = pyqtSignal(str, int)
+clientBreakConditionError = pyqtSignal(str, int, str)
-clientWatchConditionError = pyqtSignal(str)
+clientWatchConditionError = pyqtSignal(str, str)
-clientRawInput = pyqtSignal(str, bool)
+clientRawInput = pyqtSignal(str, bool, str)
 clientBanner = pyqtSignal(str, str, str, str)
 clientCapabilities = pyqtSignal(int, str, str)
 clientCompletionList = pyqtSignal(list, str)
+# TODO: check this signal for debuggerId
 clientInterpreterChanged = pyqtSignal(str)
 clientDebuggerIds = pyqtSignal(list)
 utDiscovered = pyqtSignal(list, str, str)
 utPrepared = pyqtSignal(int, str, str)
 utStartTest = pyqtSignal(str, str)
 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)
 elif self.networkInterface == "allv6":
 self.watchpointModel.rowsInserted.connect(self.__addWatchPoints)
 self.__maxVariableSize = Preferences.getDebugger("MaxVariableSize")
 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.
 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])
 # 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, debuggerId=""):
 """
 Private slot to add breakpoints.
 @param parentIndex index of parent item
 @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(debuggerId, 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(debuggerId, fn, line, False)
+self.__remoteBreakpointEnable(
+debuggerId, fn, lineno, False)
 if ignorecount:
 self.__remoteBreakpointIgnore(
-debuggerId, fn, line, ignorecount)
+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
 index = self.watchpointModel.index(row, 0, parentIndex)
 cond, special = (
 self.watchpointModel.getWatchPointByIndex(index)[0:2])
 cond = self.__makeWatchCondition(cond, special)
 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.
 @type QModelIndex
 """
 if self.debugging:
 self.__deleteWatchPoints(
 QModelIndex(), startIndex.row(), endIndex.row())
 def __addWatchPoints(self, parentIndex, start, end, debuggerId=""):
 """
 Private slot to set a watch expression.
 @param parentIndex index of parent item
 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)
+if cond in self.__reportedWatchpointIssues:
+self.__reportedWatchpointIssues.remove(cond)
 self.__remoteWatchpoint(debuggerId, cond, True, temp)
 if not enabled:
 self.__remoteWatchpointEnable(debuggerId, cond, False)
 if 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):
 """
 elif self.__autoClearShell:
 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,
 clientType="", enableCallTrace=False):
 """
 autoContinue, autoFork, forkChild)
 self.debugging = True
 self.running = True
 self.__restoreBreakpoints()
 self.__restoreWatchpoints()
 def remoteRun(self, venvName, fn, argv, wd, env, autoClearShell=True,
 forProject=False, runInConsole=False, autoFork=False,
 forkChild=False, clientType=""):
 """
 Public method to load a new program to run.
 self.remoteEnvironment(env)
 self.debuggerInterface.remoteRun(fn, argv, wd, autoFork, forkChild)
 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.
 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.
 self.remoteEnvironment(env)
 self.debuggerInterface.remoteProfile(fn, argv, wd, erase)
 self.debugging = False
 self.running = True
 def remoteStatement(self, debuggerId, stmt):
 """
 Public method to execute a Python statement.
 @param debuggerId ID of the debugger backend
 @type str
 @param stmt the Python statement to execute.
 @type str
 """
 self.debuggerInterface.remoteStatement(debuggerId, stmt.rstrip())
 def remoteStep(self, debuggerId):
 """
 Public method to single step the debugged program.
 @param debuggerId ID of the debugger backend
 @type str
 """
 self.debuggerInterface.remoteStep(debuggerId)
 def remoteStepOver(self, debuggerId):
 """
 Public method to step over the debugged program.
 @param debuggerId ID of the debugger backend
 @type str
 """
 self.debuggerInterface.remoteStepOver(debuggerId)
 def remoteStepOut(self, debuggerId):
 """
 Public method to step out the debugged program.
 @param debuggerId ID of the debugger backend
 @type str
 """
 self.debuggerInterface.remoteStepOut(debuggerId)
 def remoteStepQuit(self, debuggerId):
 """
 Public method to stop the debugged program.
 @param debuggerId ID of the debugger backend
 @type str
 """
 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(debuggerId, special)
 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(debuggerId, line)
 def remoteBreakpoint(self, debuggerId, fn, line, setBreakpoint, cond=None,
 temp=False):
 """
 Public method to set or clear a breakpoint.
 @param temp flag indicating a temporary breakpoint
 @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
 @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
 @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 int
 """
 # cond is combination of cond and special (s. watch expression viewer)
 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
+"""
+self.debuggerInterface.remoteRawInput(debuggerId, inputString)
+self.clientRawInputSent.emit(debuggerId)
 def remoteThreadList(self, debuggerId):
 """
 Public method to request the list of threads from the client.
 @param debuggerId ID of the debugger backend
 @type str
 """
 self.debuggerInterface.remoteThreadList(debuggerId)
 def remoteSetThread(self, debuggerId, tid):
 """
 Public method to request to set the given thread as current thread.
 @param debuggerId ID of the debugger backend
 @param framenr framenumber of the variables to retrieve
 @type int
 """
 self.debuggerInterface.remoteClientVariables(
 debuggerId, scope, filterList, framenr, self.__maxVariableSize)
 def remoteClientVariable(self, debuggerId, scope, filterList, var,
 framenr=0, maxSize=0):
 """
 Public method to request the variables of the debugged program.
 @type int
 """
 self.debuggerInterface.remoteClientVariable(
 debuggerId, scope, filterList, var, framenr,
 self.__maxVariableSize)
-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, debuggerId, on):
 """
 Public method to set the call trace state.
 @param debuggerId ID of the debugger backend
 @type str
 @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):
 """
 Public slot to get the a list of possible commandline completions
 from the remote client.
 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, debuggerId):
 """
 Public method to process a line of client output.
 @param line client output
 """
 if debuggerId:
 self.clientOutput.emit("{0}: {1}".format(debuggerId, line))
 else:
 self.clientOutput.emit(line)
 def signalClientLine(self, filename, lineno, debuggerId, forStack=False):
 """
 Public method to process client position feedback.
 @param filename name of the file currently being executed
 @type str
 @param forStack flag indicating this is for a stack dump
 @type bool
 """
 self.clientLine.emit(filename, lineno, debuggerId, forStack)
 def signalClientStack(self, stack, debuggerId):
 """
 Public method to process a client's stack information.
 @param stack list of stack entries. Each entry is a tuple of three
 @type list of lists of (string, integer, string)
 @param debuggerId ID of the debugger backend
 @type str
 """
 self.clientStack.emit(stack, debuggerId)
 def signalClientThreadList(self, currentId, threadList, debuggerId):
 """
 Public method to process the client thread list info.
 @param currentId id of the current thread
 @type list of dict
 @param debuggerId ID of the debugger backend
 @type str
 """
 self.clientThreadList.emit(currentId, threadList, debuggerId)
 def signalClientThreadSet(self, debuggerId):
 """
 Public method to handle the change of the client thread.
 @param debuggerId ID of the debugger backend
 @type str
 """
 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,
 @type list
 @param debuggerId ID of the debugger backend
 @type str
 """
 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,
 @type list
 @param debuggerId ID of the debugger backend
 @type str
 """
 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
 @param debuggerId ID of the debugger backend
 @type str
 """
 self.clientStatement.emit(more, debuggerId)
 def signalClientException(self, exceptionType, exceptionMessage,
 stackTrace, debuggerId):
 """
 Public method to process the exception info from the client.
 @type str
 """
 if self.running:
 self.clientException.emit(exceptionType, exceptionMessage,
 stackTrace, debuggerId)
 def signalClientSyntaxError(self, message, filename, lineNo, characterNo,
 debuggerId):
 """
 Public method to process a syntax error info from the client.
 @type str
 """
 if self.running:
 self.clientSyntaxError.emit(message, filename, lineNo, characterNo,
 debuggerId)
 def signalClientSignal(self, message, filename, lineNo,
 funcName, funcArgs, debuggerId):
 """
 Public method to process a signal generated on the client side.
 @type str
 """
 if self.running:
 self.clientSignal.emit(message, filename, lineNo,
 funcName, funcArgs, debuggerId)
 def signalClientExit(self, status, message, debuggerId):
 """
 Public method to process the client exit status.
 @param status exit code
 self.__createDebuggerInterface("None")
 self.signalClientOutput(self.tr('\nNot connected\n'))
 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
+@type str
+"""
+self.clientRawInput.emit(prompt, echo, debuggerId)
 def signalClientBanner(self, version, platform, debugClient, venvName):
 """
 Public method to process the client banner info.
 @param version interpreter version info
 self.__debuggerInterfaceRegistry[clientType][0] = capabilities
 self.clientCapabilities.emit(capabilities, clientType, venvName)
 except KeyError:
 # ignore silently
 pass
 def signalClientCompletionList(self, completionList, text):
 """
 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
 """
 self.clientCompletionList.emit(completionList, text)
 def signalClientCallTrace(self, isCall, fromFile, fromLine, fromFunction,
 toFile, toLine, toFunction, debuggerId):
 """
 Public method to process the client call trace data.
 @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
 self.utFinished.emit()
 self.clientExit.emit(int(status), "", True, "")
 self.debugging = False
 self.running = False
 def passiveStartUp(self, fn, exc):
 """
 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
 """
 self.appendStdout.emit(self.tr("Passive debug connection received\n"))
 self.passiveClientExited = False
 self.debugging = True
 self.running = True
 self.__restoreBreakpoints()
 self.__restoreWatchpoints()
 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, debuggerId=""):
 """
 Private method to restore the breakpoints after a restart.
 @param debuggerId ID of the debugger backend to send to. If this is
 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):
 """

Mercurial Repositories > eric / file comparison

comparison: eric6/Debugger/DebugServer.py

eric6/Debugger/DebugServer.py