eric: comparison Debugger/DebugServer.py

-:1b59c4ba121e
+:8cd4d08fa9f6
 "DebuggerInterfacePython",
 "DebuggerInterfacePython3",
 "DebuggerInterfaceRuby",
 "DebuggerInterfaceNone",
 ]
 class DebugServer(QTcpServer):
 """
 Class implementing the debug server embedded within the IDE.
 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 debug client
 @signal clientLine(filename, lineno, forStack) emitted after the debug client
 has executed a line of code
 @signal clientStack(stack) emitted after the debug client has executed a
 line of code
 @signal clientThreadList(currentId, threadList) emitted after a thread list
 has been received
 @signal clientThreadSet() emitted after the client has acknowledged the change
 of the current thread
 @signal clientVariables(scope, variables) emitted after a variables dump has
 been received
 @signal clientVariable(scope, variables) emitted after a dump for one class
 variable has been received
 @signal clientStatement(bool) emitted after an interactive command has
 been executed. The parameter is 0 to indicate that the command is
 complete and 1 if it needs more input.
 @signal clientException(exception) emitted after an exception occured on the
 client side
 @signal clientSyntaxError(exception) emitted after a syntax error has been detected
 on the client side
 @signal clientExit(int) emitted with the exit status after the client has exited
 @signal clientClearBreak(filename, lineno) emitted after the debug client
 passive debug mode
 @signal clientGone(bool) emitted if the client went away (planned or unplanned)
 @signal utPrepared(nrTests, exc_type, exc_value) emitted after the client has
 loaded a unittest suite
 @signal utFinished() emitted after the client signalled the end of the unittest
 @signal utStartTest(testname, testdocu) emitted after the client has started
 a test
 @signal utStopTest() emitted after the client has finished a test
 @signal utTestFailed(testname, exc_info) emitted after the client reported
 a failed test
 @signal utTestErrored(testname, exc_info) emitted after the client reported
 an errored test
 """
 clientClearBreak = pyqtSignal(str, int)
 clientClearWatch = pyqtSignal(str)
 clientGone = pyqtSignal(bool)
 # create our models
 self.breakpointModel = BreakPointModel(self)
 self.watchpointModel = WatchPointModel(self)
 self.watchSpecialCreated = \
 self.trUtf8("created", "must be same as in EditWatchpointDialog")
 self.watchSpecialChanged = \
 self.trUtf8("changed", "must be same as in EditWatchpointDialog")
 self.networkInterface = Preferences.getDebugger("NetworkInterface")
 if self.networkInterface == "all":
-hostAddress = QHostAddress("0.0.0.0")#QHostAddress.Any)
+hostAddress = QHostAddress("0.0.0.0")  # QHostAddress.Any)
 elif self.networkInterface == "allv6":
-hostAddress = QHostAddress("::")#QHostAddress.AnyIPv6)
+hostAddress = QHostAddress("::")  # QHostAddress.AnyIPv6)
 else:
 hostAddress = QHostAddress(Preferences.getDebugger("NetworkInterface"))
 if Preferences.getDebugger("PassiveDbgEnabled"):
-socket = Preferences.getDebugger("PassiveDbgPort") # default: 42424
+socket = Preferences.getDebugger("PassiveDbgPort")  # default: 42424
 self.listen(hostAddress, socket)
 self.passive = True
 self.passiveClientExited = False
 else:
 self.listen(hostAddress)
 self.__clientCapabilities[clientLanguage] = clientCapabilities
 for extension in clientExtensions:
 if extension not in self.__clientAssociations:
 self.__clientAssociations[extension] = clientLanguage
-def getSupportedLanguages(self, shellOnly = False):
+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
 if lang == language:
 extensions.append(ext)
 return tuple(extensions)
-def __createDebuggerInterface(self, clientType = None):
+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 clType type of client to be started (string)
 """
 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,
+def startClient(self, unplanned=True, clType=None, forProject=False,
-runInConsole = False):
+runInConsole=False):
 """
 Public method to start a debug client.
 @keyparam unplanned flag indicating that the client has died (boolean)
 @keyparam clType type of client to be started (string)
 @keyparam forProject flag indicating a project related action (boolean)
 @keyparam runInConsole flag indicating to start the debugger in a
 console window (boolean)
 """
 self.running = False
 if not self.passive or not self.passiveClientExited:
 if self.debuggerInterface and self.debuggerInterface.isConnected():
 self.shutdownServer()
 self.clientGone.emit(unplanned and self.debugging)
 if clType:
 self.__createDebuggerInterface()
 if forProject:
 project = e5App().getObject("Project")
 if not project.isDebugPropertiesLoaded():
 self.clientProcess, isNetworked = \
 self.debuggerInterface.startRemote(self.serverPort(),
 runInConsole)
 else:
 self.clientProcess, isNetworked = \
 self.debuggerInterface.startRemoteForProject(self.serverPort(),
 runInConsole)
 else:
 self.clientProcess, isNetworked = \
 self.debuggerInterface.startRemote(self.serverPort(), runInConsole)
 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)
 def __clientClearBreakPoint(self, fn, lineno):
 """
 @param parentIndex index of parent item (QModelIndex)
 @param start start row (integer)
 @param end end row (integer)
 """
 if self.debugging:
-for row in range(start, end+1):
+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)
 def __changeBreakPoints(self, startIndex, endIndex):
 @param parentIndex index of parent item (QModelIndex)
 @param start start row (integer)
 @param end end row (integer)
 """
 if self.debugging:
-for row in range(start, end+1):
+for row in range(start, end + 1):
 index = self.breakpointModel.index(row, 0, parentIndex)
 fn, line, cond, temp, enabled, ignorecount = \
 self.breakpointModel.getBreakPointByIndex(index)[:6]
 self.remoteBreakpoint(fn, line, True, cond, temp)
 if not enabled:
 @param parentIndex index of parent item (QModelIndex)
 @param start start row (integer)
 @param end end row (integer)
 """
 if self.debugging:
-for row in range(start, end+1):
+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)
 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 endIndex end index of the rows to be changed (QModelIndex)
 """
 res = E5MessageBox.yesNo(None,
 self.trUtf8("Connection from illegal host"),
 self.trUtf8("""<p>A connection was attempted by the"""
 """ illegal host <b>{0}</b>. Accept this connection?</p>""")\
 .format(peerAddress),
-icon = E5MessageBox.Warning)
+icon=E5MessageBox.Warning)
 if not res:
 sock.abort()
 return
 else:
 allowedHosts = Preferences.getDebugger("AllowedHosts")
 envdict[key] = value
 except UnpackError:
 pass
 self.debuggerInterface.remoteEnvironment(envdict)
-def remoteLoad(self, fn, argv, wd, env, autoClearShell = True,
+def remoteLoad(self, fn, argv, wd, env, autoClearShell=True,
-tracePython = False, autoContinue = True, forProject = False,
+tracePython=False, autoContinue=True, forProject=False,
-runInConsole = False, autoFork = False, forkChild = False,
+runInConsole=False, autoFork=False, forkChild=False,
-clientType = ""):
+clientType=""):
 """
 Public method to load a new program to debug.
 @param fn the filename to debug (string)
 @param argv the commandline arguments to pass to the program (string)
 @keyparam tracePython flag indicating if the Python library should be traced
 as well (boolean)
 @keyparam autoContinue flag indicating, that the debugger should not stop
 at the first executable line (boolean)
 @keyparam forProject flag indicating a project related action (boolean)
 @keyparam runInConsole flag indicating to start the debugger in a
 console window (boolean)
 @keyparam autoFork flag indicating the automatic fork mode (boolean)
 @keyparam forkChild flag indicating to debug the child after forking (boolean)
 @keyparam clientType client type to be used (string)
 """
 self.__setClientType(clientType)
 else:
 self.__setClientType(self.__clientAssociations[os.path.splitext(fn)[1]])
 except KeyError:
 self.__setClientType('Python3')    # assume it is a Python3 file
-self.startClient(False, forProject = forProject, runInConsole = runInConsole)
+self.startClient(False, forProject=forProject, runInConsole=runInConsole)
 self.remoteEnvironment(env)
 self.debuggerInterface.remoteLoad(fn, argv, wd, tracePython, autoContinue,
 autoFork, forkChild)
 self.debugging = True
 self.running = True
 self.__restoreBreakpoints()
 self.__restoreWatchpoints()
-def remoteRun(self, fn, argv, wd, env, autoClearShell = True,
+def remoteRun(self, fn, argv, wd, env, autoClearShell=True,
-forProject = False, runInConsole = False,
+forProject=False, runInConsole=False,
-autoFork = False, forkChild = False,
+autoFork=False, forkChild=False,
-clientType = ""):
+clientType=""):
 """
 Public method to load a new program to run.
 @param fn the filename to run (string)
 @param argv the commandline arguments to pass to the program (string)
 @param wd the working directory for the program (string)
 @param env environment settings (string)
 @keyparam autoClearShell flag indicating, that the interpreter window should
 be cleared (boolean)
 @keyparam forProject flag indicating a project related action (boolean)
 @keyparam runInConsole flag indicating to start the debugger in a
 console window (boolean)
 @keyparam autoFork flag indicating the automatic fork mode (boolean)
 @keyparam forkChild flag indicating to debug the child after forking (boolean)
 @keyparam clientType client type to be used (string)
 """
 self.__setClientType(clientType)
 else:
 self.__setClientType(self.__clientAssociations[os.path.splitext(fn)[1]])
 except KeyError:
 self.__setClientType('Python3')    # assume it is a Python3 file
-self.startClient(False, forProject = forProject, runInConsole = runInConsole)
+self.startClient(False, forProject=forProject, runInConsole=runInConsole)
 self.remoteEnvironment(env)
 self.debuggerInterface.remoteRun(fn, argv, wd, autoFork, forkChild)
 self.debugging = False
 self.running = True
-def remoteCoverage(self, fn, argv, wd, env, autoClearShell = True,
+def remoteCoverage(self, fn, argv, wd, env, autoClearShell=True,
-erase = False, forProject = False, runInConsole = False,
+erase=False, forProject=False, runInConsole=False,
-clientType = ""):
+clientType=""):
 """
 Public method to load a new program to collect coverage data.
 @param fn the filename to run (string)
 @param argv the commandline arguments to pass to the program (string)
 @param wd the working directory for the program (string)
 @param env environment settings (string)
 @keyparam autoClearShell flag indicating, that the interpreter window should
 be cleared (boolean)
 @keyparam erase flag indicating that coverage info should be
 cleared first (boolean)
 @keyparam forProject flag indicating a project related action (boolean)
 @keyparam runInConsole flag indicating to start the debugger in a
 console window (boolean)
 @keyparam clientType client type to be used (string)
 """
 self.__autoClearShell = autoClearShell
 self.__setClientType(clientType)
 else:
 self.__setClientType(self.__clientAssociations[os.path.splitext(fn)[1]])
 except KeyError:
 self.__setClientType('Python3')    # assume it is a Python3 file
-self.startClient(False, forProject = forProject, runInConsole = runInConsole)
+self.startClient(False, forProject=forProject, runInConsole=runInConsole)
 self.remoteEnvironment(env)
 self.debuggerInterface.remoteCoverage(fn, argv, wd, erase)
 self.debugging = False
 self.running = True
-def remoteProfile(self, fn, argv, wd, env, autoClearShell = True,
+def remoteProfile(self, fn, argv, wd, env, autoClearShell=True,
-erase = False, forProject = False,
+erase=False, forProject=False,
-runInConsole = False,
+runInConsole=False,
-clientType = ""):
+clientType=""):
 """
 Public method to load a new program to collect profiling data.
 @param fn the filename to run (string)
 @param argv the commandline arguments to pass to the program (string)
 @param env environment settings (string)
 @keyparam autoClearShell flag indicating, that the interpreter window should
 be cleared (boolean)
 @keyparam erase flag indicating that timing info should be cleared first (boolean)
 @keyparam forProject flag indicating a project related action (boolean)
 @keyparam runInConsole flag indicating to start the debugger in a
 console window (boolean)
 @keyparam clientType client type to be used (string)
 """
 self.__autoClearShell = autoClearShell
 self.__setClientType(clientType)
 else:
 self.__setClientType(self.__clientAssociations[os.path.splitext(fn)[1]])
 except KeyError:
 self.__setClientType('Python3')    # assume it is a Python3 file
-self.startClient(False, forProject = forProject, runInConsole = runInConsole)
+self.startClient(False, forProject=forProject, runInConsole=runInConsole)
 self.remoteEnvironment(env)
 self.debuggerInterface.remoteProfile(fn, argv, wd, erase)
 self.debugging = False
 self.running = True
 def remoteStatement(self, stmt):
 """
 Public method to execute a Python statement.
 @param stmt the Python statement to execute (string). It
 should not have a trailing newline.
 """
 self.debuggerInterface.remoteStatement(stmt)
 """
 Public method to stop the debugged program.
 """
 self.debuggerInterface.remoteStepQuit()
-def remoteContinue(self, special = False):
+def remoteContinue(self, special=False):
 """
 Public method to continue the debugged program.
 @param special flag indicating a special continue operation
 """
 @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, set, temp = False):
+def __remoteWatchpoint(self, cond, set, temp=False):
 """
 Private method to set or clear a watch expression.
 @param cond expression of the watch expression (string)
 @param set flag indicating setting or resetting a watch expression (boolean)
 @param count number of occurrences to ignore (int)
 """
 # cond is combination of cond and special (s. watch expression viewer)
 self.debuggerInterface.remoteWatchpointIgnore(cond, count)
-def remoteRawInput(self,s):
+def remoteRawInput(self, s):
 """
 Public method to send the raw input to the debugged program.
 @param s the raw input (string)
 """
 @param tid id of the thread (integer)
 """
 self.debuggerInterface.remoteSetThread(tid)
-def remoteClientVariables(self, scope, filter, framenr = 0):
+def remoteClientVariables(self, scope, filter, framenr=0):
 """
 Public method to request the variables of the debugged program.
 @param scope the scope of the variables (0 = local, 1 = global)
 @param filter list of variable types to filter out (list of int)
 @param framenr framenumber of the variables to retrieve (int)
 """
 self.debuggerInterface.remoteClientVariables(scope, filter, framenr)
-def remoteClientVariable(self, scope, filter, var, framenr = 0):
+def remoteClientVariable(self, scope, filter, var, framenr=0):
 """
 Public method to request the variables of the debugged program.
 @param scope the scope of the variables (0 = local, 1 = global)
 @param filter list of variable types to filter out (list of int)
 @param line client output (string)
 """
 self.clientOutput.emit(line)
-def signalClientLine(self, filename, lineno, forStack = False):
+def signalClientLine(self, filename, lineno, forStack=False):
 """
 Public method to process client position feedback.
 @param filename name of the file currently being executed (string)
 @param lineno line of code currently being executed (integer)
 def __restoreBreakpoints(self):
 """
 Private method to restore the breakpoints after a restart.
 """
 if self.debugging:
-self.__addBreakPoints(QModelIndex(), 0, self.breakpointModel.rowCount()-1)
+self.__addBreakPoints(QModelIndex(), 0, self.breakpointModel.rowCount() - 1)
 def __restoreWatchpoints(self):
 """
 Private method to restore the watch expressions after a restart.
 """
 if self.debugging:
-self.__addWatchPoints(QModelIndex(), 0, self.watchpointModel.rowCount()-1)
+self.__addWatchPoints(QModelIndex(), 0, self.watchpointModel.rowCount() - 1)
 def getBreakPointModel(self):
 """
 Public slot to get a reference to the breakpoint model object.

Mercurial Repositories > eric / file comparison

comparison: Debugger/DebugServer.py

Debugger/DebugServer.py