eric4.Debugger.DebugServer

Module implementing the debug server.

Classes

DebugServer Class implementing the debug server embedded within the IDE.

Functions

None


DebugServer

Class implementing the debug server embedded within the IDE.

Signals

clientBanner(banner)
emitted after the client banner was received
clientBreakConditionError(fn, lineno)
emitted after the client has signaled a syntax error in a breakpoint condition
clientCapabilities(int capabilities, QString cltype)
emitted after the clients capabilities were received
clientClearBreak(filename, lineno)
emitted after the debug client has decided to clear a temporary breakpoint
clientClearWatch(condition)
emitted after the debug client has decided to clear a temporary watchpoint
clientCompletionList(completionList, text)
emitted after the client the commandline completion list and the reworked searchstring was received from the client
clientException(exception)
emitted after an exception occured on the client side
clientExit(exitcode)
emitted after the client has exited
clientGone
emitted if the client went away (planned or unplanned)
clientLine(filename, lineno)
emitted after the debug client has executed a line of code
clientOutput
emitted after the client has sent some output
clientRawInput(prompt, echo)
emitted after a raw input request was received
clientRawInputSent
emitted after the data was sent to the debug client
clientStack(stack)
emitted after the debug client has executed a line of code
clientStatement(boolean)
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.
clientSyntaxError(exception)
emitted after a syntax error has been detected on the client side
clientVariable(variables)
emitted after a dump for one class variable has been received
clientVariables(variables)
emitted after a variables dump has been received
clientWatchConditionError(fn, lineno)
emitted after the client has signaled a syntax error in a watchpoint condition
cyclopsError(fn, modfunc)
emitted after the client reported an error while performing a Cyclops run
passiveDebugStarted
emitted after the debug client has connected in passive debug mode
utFinished
emitted after the client signalled the end of the unittest
utPrepared(nrTests, exc_type, exc_value)
emitted after the client has loaded a unittest suite
utStartTest(testname, testdocu)
emitted after the client has started a test
utStopTest
emitted after the client has finished a test
utTestErrored(testname, exc_info)
emitted after the client reported an errored test
utTestFailed(testname, exc_info)
emitted after the client reported a failed test

Derived from

QTcpServer

Methods

DebugServer Constructor
__addBreakPoints Private slot to add breakpoints.
__addWatchPoints Private slot to set a watchpoint.
__breakPointDataAboutToBeChanged Private slot to handle the dataAboutToBeChanged signal of the breakpoint model.
__changeBreakPoints Private slot to set changed breakpoints.
__changeWatchPoints Private slot to set changed watchpoints.
__clientCapabilities Private slot to handle the reporting of the clients capabilities.
__clientClearBreakPoint Private slot to handle the clientClearBreak signal.
__clientClearWatchPoint Private slot to handle the clientClearWatch signal.
__deleteBreakPoints Private slot to delete breakpoints.
__deleteWatchPoints Private slot to delete watchpoints.
__identityTranslation Private method to perform the identity path translation.
__makeWatchCondition Private method to construct the condition string.
__newConnection Private slot to handle a new connection.
__parseClientLine Private method to handle data from the client.
__passiveShutDown Private method to shut down a passive debug connection.
__passiveStartUp Private method to handle a passive debug connection.
__remoteBreakpoint Private method to set or clear a breakpoint.
__remoteBreakpointEnable Private method to enable or disable a breakpoint.
__remoteBreakpointIgnore Private method to ignore a breakpoint the next couple of occurences.
__remoteTranslation Private method to perform the path translation.
__remoteWatchpoint Private method to set or clear a watchpoint.
__remoteWatchpointEnable Private method to enable or disable a watchpoint.
__remoteWatchpointIgnore Private method to ignore a watchpoint the next couple of occurences.
__restoreBreakpoints Private method to restore the breakpoints after a restart.
__restoreWatchpoints Private method to restore the watchpoints after a restart.
__sendCommand Private method to send a single line command to the client.
__setClientType Private method to set the client type.
__splitWatchCondition Private method to split a remote watchpoint condition.
__startRemoteForProject Private method to start a remote interpreter for a project.
__startRemotePython Private method to start a remote Python interpreter.
__startRemoteRuby Private method to start a remote Ruby interpreter.
__watchPointDataAboutToBeChanged Private slot to handle the dataAboutToBeChanged signal of the watchpoint model.
getBreakPointModel Public slot to get a reference to the breakpoint model object.
getClientCapabilities Public method to retrieve the debug clients capabilities.
getWatchPointModel Public slot to get a reference to the watchpoint model object.
remoteBanner Public slot to get the banner info of the remote client.
remoteCapabilities Public slot to get the debug clients capabilities.
remoteClientSetFilter Public method to set a variables filter list.
remoteClientVariable Public method to request the variables of the debugged program.
remoteClientVariables Public method to request the variables of the debugged program.
remoteCompletion Public slot to get the a list of possible commandline completions from the remote client.
remoteContinue Public method to continue the debugged program.
remoteCoverage Public method to load a new program to collect coverage data.
remoteCyclops Public method to load a new program to collect profiling data.
remoteEnvironment Public method to set the environment for a program to debug, run, ...
remoteEval Public method to evaluate arg in the current context of the debugged program.
remoteExec Public method to execute stmt in the current context of the debugged program.
remoteLoad Public method to load a new program to debug.
remoteProfile Public method to load a new program to collect profiling data.
remoteRawInput Public method to send the raw input to the debugged program.
remoteRun Public method to load a new program to run.
remoteStatement Public method to execute a Python statement.
remoteStep Public method to single step the debugged program.
remoteStepOut Public method to step out the debugged program.
remoteStepOver Public method to step over the debugged program.
remoteStepQuit Public method to stop the debugged program.
remoteUTPrepare Public method to prepare a new unittest run.
remoteUTRun Public method to start a unittest run.
remoteUTStop public method to stop a unittest run.
shutdownServer Public method to cleanly shut down.
startClient Public method to start a debug client.
startRemote Public method to start a remote interpreter.

DebugServer (Constructor)

DebugServer()

Constructor

DebugServer.__addBreakPoints

__addBreakPoints(parentIndex, start, end)

Private slot to add breakpoints.

parentIndex
index of parent item (QModelIndex)
start
start row (integer)
end
end row (integer)

DebugServer.__addWatchPoints

__addWatchPoints(parentIndex, start, end)

Private slot to set a watchpoint.

parentIndex
index of parent item (QModelIndex)
start
start row (integer)
end
end row (integer)

DebugServer.__breakPointDataAboutToBeChanged

__breakPointDataAboutToBeChanged(startIndex, endIndex)

Private slot to handle the dataAboutToBeChanged signal of the breakpoint model.

startIndex
start index of the rows to be changed (QModelIndex)
endIndex
end index of the rows to be changed (QModelIndex)

DebugServer.__changeBreakPoints

__changeBreakPoints(startIndex, endIndex)

Private slot to set changed breakpoints.

indexes
indexes of changed breakpoints.

DebugServer.__changeWatchPoints

__changeWatchPoints(startIndex, endIndex)

Private slot to set changed watchpoints.

startIndex
start index of the rows to be changed (QModelIndex)
endIndex
end index of the rows to be changed (QModelIndex)

DebugServer.__clientCapabilities

__clientCapabilities(cap, clType)

Private slot to handle the reporting of the clients capabilities.

cap
client capabilities (integer)
clType
type of the debug client (QString)

DebugServer.__clientClearBreakPoint

__clientClearBreakPoint(fn, lineno)

Private slot to handle the clientClearBreak signal.

fn
filename of breakpoint to clear (string or QString)
lineno
line number of breakpoint to clear (integer)

DebugServer.__clientClearWatchPoint

__clientClearWatchPoint(condition)

Private slot to handle the clientClearWatch signal.

condition
condition of watchpoint to clear (string or QString)

DebugServer.__deleteBreakPoints

__deleteBreakPoints(parentIndex, start, end)

Private slot to delete breakpoints.

parentIndex
index of parent item (QModelIndex)
start
start row (integer)
end
end row (integer)

DebugServer.__deleteWatchPoints

__deleteWatchPoints(parentIndex, start, end)

Private slot to delete watchpoints.

parentIndex
index of parent item (QModelIndex)
start
start row (integer)
end
end row (integer)

DebugServer.__identityTranslation

__identityTranslation(fn, remote2local=1)

Private method to perform the identity path translation.

fn
filename to be translated (string or QString)
remote2local
flag indicating the direction of translation (0 = local to remote, 1 = remote to local [default])
Returns:
translated filename (string)

DebugServer.__makeWatchCondition

__makeWatchCondition(cond, special)

Private method to construct the condition string.

cond
condition (string or QString)
special
special condition (string or QString)
Returns:
condition string (QString)

DebugServer.__newConnection

__newConnection()

Private slot to handle a new connection.

DebugServer.__parseClientLine

__parseClientLine()

Private method to handle data from the client.

DebugServer.__passiveShutDown

__passiveShutDown()

Private method to shut down a passive debug connection.

DebugServer.__passiveStartUp

__passiveStartUp(fn, exc)

Private method to handle a passive debug connection.

fn
filename of the debugged script (string)
exc
flag to enable exception reporting of the IDE (boolean)

DebugServer.__remoteBreakpoint

__remoteBreakpoint(fn, line, set, cond=None, temp=0)

Private method to set or clear a breakpoint.

fn
filename the breakpoint belongs to (string)
line
linenumber of the breakpoint (int)
set
flag indicating setting or resetting a breakpoint (boolean)
cond
condition of the breakpoint (string)
temp
flag indicating a temporary breakpoint (boolean)

DebugServer.__remoteBreakpointEnable

__remoteBreakpointEnable(fn, line, enable)

Private method to enable or disable a breakpoint.

fn
filename the breakpoint belongs to (string)
line
linenumber of the breakpoint (int)
enable
flag indicating enabling or disabling a breakpoint (boolean)

DebugServer.__remoteBreakpointIgnore

__remoteBreakpointIgnore(fn, line, count)

Private method to ignore a breakpoint the next couple of occurences.

fn
filename the breakpoint belongs to (string)
line
linenumber of the breakpoint (int)
count
number of occurences to ignore (int)

DebugServer.__remoteTranslation

__remoteTranslation(fn, remote2local=1)

Private method to perform the path translation.

fn
filename to be translated (string or QString)
remote2local
flag indicating the direction of translation (0 = local to remote, 1 = remote to local [default])
Returns:
translated filename (string)

DebugServer.__remoteWatchpoint

__remoteWatchpoint(cond, set, temp=0)

Private method to set or clear a watchpoint.

cond
condition of the watchpoint (string)
set
flag indicating setting or resetting a watchpoint (boolean)
temp
flag indicating a temporary watchpoint (boolean)

DebugServer.__remoteWatchpointEnable

__remoteWatchpointEnable(cond, enable)

Private method to enable or disable a watchpoint.

cond
condition of the watchpoint (string)
enable
flag indicating enabling or disabling a watchpoint (boolean)

DebugServer.__remoteWatchpointIgnore

__remoteWatchpointIgnore(cond, count)

Private method to ignore a watchpoint the next couple of occurences.

cond
condition of the watchpoint (string)
count
number of occurences to ignore (int)

DebugServer.__restoreBreakpoints

__restoreBreakpoints()

Private method to restore the breakpoints after a restart.

DebugServer.__restoreWatchpoints

__restoreWatchpoints()

Private method to restore the watchpoints after a restart.

DebugServer.__sendCommand

__sendCommand(cmd)

Private method to send a single line command to the client.

cmd
command to send to the debug client (string)

DebugServer.__setClientType

__setClientType(clType)

Private method to set the client type.

clType
type of client to be started (string, Python or Ruby)

DebugServer.__splitWatchCondition

__splitWatchCondition(cond)

Private method to split a remote watchpoint condition.

cond
remote condition (string or QString)
Returns:
tuple of local condition (string) and special condition (string)

DebugServer.__startRemoteForProject

__startRemoteForProject()

Private method to start a remote interpreter for a project.

DebugServer.__startRemotePython

__startRemotePython()

Private method to start a remote Python interpreter.

DebugServer.__startRemoteRuby

__startRemoteRuby()

Private method to start a remote Ruby interpreter.

DebugServer.__watchPointDataAboutToBeChanged

__watchPointDataAboutToBeChanged(startIndex, endIndex)

Private slot to handle the dataAboutToBeChanged signal of the watchpoint model.

startIndex
start index of the rows to be changed (QModelIndex)
endIndex
end index of the rows to be changed (QModelIndex)

DebugServer.getBreakPointModel

getBreakPointModel()

Public slot to get a reference to the breakpoint model object.

Returns:
reference to the breakpoint model object (BreakPointModel)

DebugServer.getClientCapabilities

getClientCapabilities(type)

Public method to retrieve the debug clients capabilities.

type
debug client type (string)
Returns:
debug client capabilities (integer)

DebugServer.getWatchPointModel

getWatchPointModel()

Public slot to get a reference to the watchpoint model object.

Returns:
reference to the watchpoint model object (WatchPointModel)

DebugServer.remoteBanner

remoteBanner()

Public slot to get the banner info of the remote client.

DebugServer.remoteCapabilities

remoteCapabilities()

Public slot to get the debug clients capabilities.

DebugServer.remoteClientSetFilter

remoteClientSetFilter(scope, filter)

Public method to set a variables filter list.

scope
the scope of the variables (0 = local, 1 = global)
filter
regexp string for variable names to filter out (string)

DebugServer.remoteClientVariable

remoteClientVariable(scope, filter, var, framenr=0)

Public method to request the variables of the debugged program.

scope
the scope of the variables (0 = local, 1 = global)
filter
list of variable types to filter out (list of int)
var
list encoded name of variable to retrieve (string)
framenr
framenumber of the variables to retrieve (int)

DebugServer.remoteClientVariables

remoteClientVariables(scope, filter, framenr=0)

Public method to request the variables of the debugged program.

scope
the scope of the variables (0 = local, 1 = global)
filter
list of variable types to filter out (list of int)
framenr
framenumber of the variables to retrieve (int)

DebugServer.remoteCompletion

remoteCompletion(text)

Public slot to get the a list of possible commandline completions from the remote client.

text
the text to be completed (string or QString)

DebugServer.remoteContinue

remoteContinue(special=0)

Public method to continue the debugged program.

special
flag indicating a special continue operation

DebugServer.remoteCoverage

remoteCoverage(fn, argv, wd, env, autoClearShell = True, erase = False, exclude = "", forProject = False)

Public method to load a new program to collect coverage data.

fn
the filename to run (string)
argv
the commandline arguments to pass to the program (string or QString)
wd
the working directory for the program (string)
env
environment settings (string)
autoClearShell=
flag indicating, that the interpreter window should be cleared (boolean)
erase=
flag indicating that coverage info should be cleared first (boolean)
exclude=
searchpattern marking line to exclude from coverage
forProject=
flag indicating a project related action (boolean)

DebugServer.remoteCyclops

remoteCyclops(fn, argv, wd, env, modfunc, reports, autoClearShell = True, forProject = False)

Public method to load a new program to collect profiling data.

fn
the filename to run (string)
argv
the commandline arguments to pass to the program (string or QString)
wd
the working directory for the program (string)
env
environment settings (string)
modfunc
name of a module function which is the main entry point (string)
reports
bit mask specifying the reports wanted (integer)
autoClearShell=
flag indicating, that the interpreter window should be cleared (boolean)
forProject=
flag indicating a project related action (boolean)

DebugServer.remoteEnvironment

remoteEnvironment(env)

Public method to set the environment for a program to debug, run, ...

env
environment settings (string)

DebugServer.remoteEval

remoteEval(arg)

Public method to evaluate arg in the current context of the debugged program.

arg
the arguments to evaluate (string)

DebugServer.remoteExec

remoteExec(stmt)

Public method to execute stmt in the current context of the debugged program.

stmt
statement to execute (string)

DebugServer.remoteLoad

remoteLoad(fn, argv, wd, env, autoClearShell = True, tracePython = False, autoContinue = True, forProject = False)

Public method to load a new program to debug.

fn
the filename to debug (string)
argv
the commandline arguments to pass to the program (string or QString)
wd
the working directory for the program (string)
env
environment settings (string)
autoClearShell=
flag indicating, that the interpreter window should be cleared (boolean)
tracePython=
flag indicating if the Python library should be traced as well (boolean)
autoContinue=
flag indicating, that the debugger should not stop at the first executable line (boolean)
forProject=
flag indicating a project related action (boolean)

DebugServer.remoteProfile

remoteProfile(fn, argv, wd, env, autoClearShell = True, erase = False, forProject = False)

Public method to load a new program to collect profiling data.

fn
the filename to run (string)
argv
the commandline arguments to pass to the program (string or QString)
wd
the working directory for the program (string)
env
environment settings (string)
autoClearShell=
flag indicating, that the interpreter window should be cleared (boolean)
erase=
flag indicating that timing info should be cleared first (boolean)
forProject=
flag indicating a project related action (boolean)

DebugServer.remoteRawInput

remoteRawInput(s)

Public method to send the raw input to the debugged program.

s
the raw input (string)

DebugServer.remoteRun

remoteRun(fn, argv, wd, env, autoClearShell = True, forProject = False)

Public method to load a new program to run.

fn
the filename to run (string)
argv
the commandline arguments to pass to the program (string or QString)
wd
the working directory for the program (string)
env
environment settings (string)
autoClearShell=
flag indicating, that the interpreter window should be cleared (boolean)
forProject=
flag indicating a project related action (boolean)

DebugServer.remoteStatement

remoteStatement(stmt)

Public method to execute a Python statement.

stmt
the Python statement to execute (string). It should not have a trailing newline.

DebugServer.remoteStep

remoteStep()

Public method to single step the debugged program.

DebugServer.remoteStepOut

remoteStepOut()

Public method to step out the debugged program.

DebugServer.remoteStepOver

remoteStepOver()

Public method to step over the debugged program.

DebugServer.remoteStepQuit

remoteStepQuit()

Public method to stop the debugged program.

DebugServer.remoteUTPrepare

remoteUTPrepare(fn, tn, tfn, cov, covname, coverase)

Public method to prepare a new unittest run.

fn
the filename to load (string)
tn
the testname to load (string)
tfn
the test function name to load tests from (string)
cov
flag indicating collection of coverage data is requested
covname
filename to be used to assemble the coverage caches filename
coverase
flag indicating erasure of coverage data is requested

DebugServer.remoteUTRun

remoteUTRun()

Public method to start a unittest run.

DebugServer.remoteUTStop

remoteUTStop()

public method to stop a unittest run.

DebugServer.shutdownServer

shutdownServer()

Public method to cleanly shut down.

It closes our socket and shuts down the debug client. (Needed on Win OS)

DebugServer.startClient

startClient(unplanned = True, clType = None, forProject = False)

Public method to start a debug client.

unplanned
flag indicating that the client has died (boolean)
clType
type of client to be started (string, Python or Ruby)
forProject
flag indicating a project related action (boolean)

DebugServer.startRemote

startRemote(forProject = False)

Public method to start a remote interpreter.

forProject
flag indicating a project related action (boolean)

Up