eric: comparison Debugger/DebuggerInterfacePython.py

-:9552b5e16a07
+:8a7d1b9d18db
 import sys
 import os
 import re
-from PyQt4.QtCore import *
+from PyQt4.QtCore import QObject, QTextCodec, QProcess, QTimer
 from PyQt4.QtGui import QInputDialog
 from E5Gui.E5Application import e5App
 from E5Gui import E5MessageBox
-from .DebugProtocol import *
+from . import DebugProtocol
 from . import DebugClientCapabilities
 import Preferences
 import Utilities
 try:
 key, value = el.split('=', 1)
 if value.startswith('"') or value.startswith("'"):
 value = value[1:-1]
 clientEnv[str(key)] = str(value)
-except UnpackError:
+except ValueError:
 pass
 ipaddr = self.debugServer.getHostAddress(True)
 if runInConsole or Preferences.getDebugger("ConsoleDbgEnabled"):
 ccmd = Preferences.getDebugger("ConsoleDbgCommand")
 try:
 key, value = el.split('=', 1)
 if value.startswith('"') or value.startswith("'"):
 value = value[1:-1]
 clientEnv[str(key)] = str(value)
-except UnpackError:
+except ValueError:
 pass
 ipaddr = self.debugServer.getHostAddress(True)
 if runInConsole or project.getDebugProperty("CONSOLEDEBUGGER"):
 ccmd = project.getDebugProperty("CONSOLECOMMAND") or \
 # do not want any slots called during shutdown
 self.qsock.disconnected.disconnect(self.debugServer.startClient)
 self.qsock.readyRead[()].disconnect(self.__parseClientLine)
 # close down socket, and shut down client as well.
-self.__sendCommand('{0}\n'.format(RequestShutdown))
+self.__sendCommand('{0}\n'.format(DebugProtocol.RequestShutdown))
 self.qsock.flush()
 self.qsock.close()
 # reinitialize
 """
 Public method to set the environment for a program to debug, run, ...
 @param env environment settings (dictionary)
 """
-self.__sendCommand('{0}{1}\n'.format(RequestEnv, str(env)))
+self.__sendCommand('{0}{1}\n'.format(DebugProtocol.RequestEnv, str(env)))
 def remoteLoad(self, fn, argv, wd, traceInterpreter=False, autoContinue=True,
 autoFork=False, forkChild=False):
 """
 Public method to load a new program to debug.
 """
 self.__autoContinue = autoContinue
 wd = self.translate(wd, False)
 fn = self.translate(os.path.abspath(fn), False)
-self.__sendCommand('{0}{1}\n'.format(RequestForkMode, repr((autoFork, forkChild))))
+self.__sendCommand('{0}{1}\n'.format(
+DebugProtocol.RequestForkMode, repr((autoFork, forkChild))))
 self.__sendCommand('{0}{1}|{2}|{3}|{4:d}\n'.format(
-RequestLoad, wd, fn, str(Utilities.parseOptionString(argv)),
+DebugProtocol.RequestLoad, wd, fn, str(Utilities.parseOptionString(argv)),
 traceInterpreter))
 def remoteRun(self, fn, argv, wd, autoFork=False, forkChild=False):
 """
 Public method to load a new program to run.
 @keyparam autoFork flag indicating the automatic fork mode (boolean)
 @keyparam forkChild flag indicating to debug the child after forking (boolean)
 """
 wd = self.translate(wd, False)
 fn = self.translate(os.path.abspath(fn), False)
-self.__sendCommand('{0}{1}\n'.format(RequestForkMode, repr((autoFork, forkChild))))
+self.__sendCommand('{0}{1}\n'.format(
+DebugProtocol.RequestForkMode, repr((autoFork, forkChild))))
 self.__sendCommand('{0}{1}|{2}|{3}\n'.format(
-RequestRun, wd, fn, str(Utilities.parseOptionString(argv))))
+DebugProtocol.RequestRun, wd, fn, str(Utilities.parseOptionString(argv))))
 def remoteCoverage(self, fn, argv, wd, erase=False):
 """
 Public method to load a new program to collect coverage data.
 cleared first (boolean)
 """
 wd = self.translate(wd, False)
 fn = self.translate(os.path.abspath(fn), False)
 self.__sendCommand('{0}{1}@@{2}@@{3}@@{4:d}\n'.format(
-RequestCoverage, wd, fn, str(Utilities.parseOptionString(argv)),
+DebugProtocol.RequestCoverage, wd, fn, str(Utilities.parseOptionString(argv)),
 erase))
 def remoteProfile(self, fn, argv, wd, erase=False):
 """
 Public method to load a new program to collect profiling data.
 @keyparam erase flag indicating that timing info should be cleared first (boolean)
 """
 wd = self.translate(wd, False)
 fn = self.translate(os.path.abspath(fn), False)
 self.__sendCommand('{0}{1}|{2}|{3}|{4:d}\n'.format(
-RequestProfile, wd, fn, str(Utilities.parseOptionString(argv)), erase))
+DebugProtocol.RequestProfile, wd, fn,
+str(Utilities.parseOptionString(argv)), erase))
 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.__sendCommand('{0}\n'.format(stmt))
-self.__sendCommand(RequestOK + '\n')
+self.__sendCommand(DebugProtocol.RequestOK + '\n')
 def remoteStep(self):
 """
 Public method to single step the debugged program.
 """
-self.__sendCommand(RequestStep + '\n')
+self.__sendCommand(DebugProtocol.RequestStep + '\n')
 def remoteStepOver(self):
 """
 Public method to step over the debugged program.
 """
-self.__sendCommand(RequestStepOver + '\n')
+self.__sendCommand(DebugProtocol.RequestStepOver + '\n')
 def remoteStepOut(self):
 """
 Public method to step out the debugged program.
 """
-self.__sendCommand(RequestStepOut + '\n')
+self.__sendCommand(DebugProtocol.RequestStepOut + '\n')
 def remoteStepQuit(self):
 """
 Public method to stop the debugged program.
 """
-self.__sendCommand(RequestStepQuit + '\n')
+self.__sendCommand(DebugProtocol.RequestStepQuit + '\n')
 def remoteContinue(self, special=False):
 """
 Public method to continue the debugged program.
 @param special flag indicating a special continue operation (boolean)
 """
-self.__sendCommand('{0}{1:d}\n'.format(RequestContinue, special))
+self.__sendCommand('{0}{1:d}\n'.format(DebugProtocol.RequestContinue, special))
 def remoteBreakpoint(self, fn, line, set, cond=None, temp=False):
 """
 Public method to set or clear a breakpoint.
 @param cond condition of the breakpoint (string)
 @param temp flag indicating a temporary breakpoint (boolean)
 """
 fn = self.translate(fn, False)
 self.__sendCommand('{0}{1}@@{2:d}@@{3:d}@@{4:d}@@{5}\n'.format(
-RequestBreak, fn, line, temp, set, cond))
+DebugProtocol.RequestBreak, fn, line, temp, set, cond))
 def remoteBreakpointEnable(self, fn, line, enable):
 """
 Public method to enable or disable a breakpoint.
 @param line linenumber of the breakpoint (int)
 @param enable flag indicating enabling or disabling a breakpoint (boolean)
 """
 fn = self.translate(fn, False)
 self.__sendCommand('{0}{1},{2:d},{3:d}\n'.format(
-RequestBreakEnable, fn, line, enable))
+DebugProtocol.RequestBreakEnable, fn, line, enable))
 def remoteBreakpointIgnore(self, fn, line, count):
 """
 Public method to ignore a breakpoint the next couple of occurrences.
 @param line linenumber of the breakpoint (int)
 @param count number of occurrences to ignore (int)
 """
 fn = self.translate(fn, False)
 self.__sendCommand('{0}{1},{2:d},{3:d}\n'.format(
-RequestBreakIgnore, fn, line, count))
+DebugProtocol.RequestBreakIgnore, fn, line, count))
 def remoteWatchpoint(self, cond, set, temp=False):
 """
 Public 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 temp flag indicating a temporary watch expression (boolean)
 """
 # cond is combination of cond and special (s. watch expression viewer)
-self.__sendCommand('{0}{1}@@{2:d}@@{3:d}\n'.format(RequestWatch, cond, temp, set))
+self.__sendCommand('{0}{1}@@{2:d}@@{3:d}\n'.format(
+DebugProtocol.RequestWatch, cond, temp, set))
 def remoteWatchpointEnable(self, cond, enable):
 """
 Public 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.__sendCommand('{0}{1},{2:d}\n'.format(RequestWatchEnable, cond, enable))
+self.__sendCommand('{0}{1},{2:d}\n'.format(
+DebugProtocol.RequestWatchEnable, cond, enable))
 def remoteWatchpointIgnore(self, cond, count):
 """
 Public method to ignore a watch expression the next couple of occurrences.
 @param cond expression of the watch expression (string)
 @param count number of occurrences to ignore (int)
 """
 # cond is combination of cond and special (s. watch expression viewer)
-self.__sendCommand('{0}{1},{2:d}\n'.format(RequestWatchIgnore, cond, count))
+self.__sendCommand('{0}{1},{2:d}\n'.format(
+DebugProtocol.RequestWatchIgnore, cond, count))
 def remoteRawInput(self, s):
 """
 Public method to send the raw input to the debugged program.
 def remoteThreadList(self):
 """
 Public method to request the list of threads from the client.
 """
-self.__sendCommand('{0}\n'.format(RequestThreadList))
+self.__sendCommand('{0}\n'.format(DebugProtocol.RequestThreadList))
 def remoteSetThread(self, tid):
 """
 Public method to request to set the given thread as current thread.
 @param tid id of the thread (integer)
 """
-self.__sendCommand('{0}{1:d}\n'.format(RequestThreadSet, tid))
+self.__sendCommand('{0}{1:d}\n'.format(DebugProtocol.RequestThreadSet, tid))
 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.__sendCommand('{0}{1:d}, {2:d}, {3}\n'.format(
-RequestVariables, framenr, scope, str(filter)))
+DebugProtocol.RequestVariables, framenr, scope, str(filter)))
 def remoteClientVariable(self, scope, filter, var, framenr=0):
 """
 Public method to request the variables of the debugged program.
 @param filter list of variable types to filter out (list of int)
 @param var list encoded name of variable to retrieve (string)
 @param framenr framenumber of the variables to retrieve (int)
 """
 self.__sendCommand('{0}{1}, {2:d}, {3:d}, {4}\n'.format(
-RequestVariable, str(var), framenr, scope, str(filter)))
+DebugProtocol.RequestVariable, str(var), framenr, scope, str(filter)))
 def remoteClientSetFilter(self, scope, filter):
 """
 Public method to set a variables filter list.
 @param scope the scope of the variables (0 = local, 1 = global)
 @param filter regexp string for variable names to filter out (string)
 """
-self.__sendCommand('{0}{1:d}, "{2}"\n'.format(RequestSetFilter, scope, filter))
+self.__sendCommand('{0}{1:d}, "{2}"\n'.format(
+DebugProtocol.RequestSetFilter, scope, filter))
 def remoteEval(self, arg):
 """
 Public method to evaluate arg in the current context of the debugged program.
 @param arg the arguments to evaluate (string)
 """
-self.__sendCommand('{0}{1}\n'.format(RequestEval, arg))
+self.__sendCommand('{0}{1}\n'.format(DebugProtocol.RequestEval, arg))
 def remoteExec(self, stmt):
 """
 Public method to execute stmt in the current context of the debugged program.
 @param stmt statement to execute (string)
 """
-self.__sendCommand('{0}{1}\n'.format(RequestExec, stmt))
+self.__sendCommand('{0}{1}\n'.format(DebugProtocol.RequestExec, stmt))
 def remoteBanner(self):
 """
 Public slot to get the banner info of the remote client.
 """
-self.__sendCommand(RequestBanner + '\n')
+self.__sendCommand(DebugProtocol.RequestBanner + '\n')
 def remoteCapabilities(self):
 """
 Public slot to get the debug clients capabilities.
 """
-self.__sendCommand(RequestCapabilities + '\n')
+self.__sendCommand(DebugProtocol.RequestCapabilities + '\n')
 def remoteCompletion(self, text):
 """
 Public slot to get the a list of possible commandline completions
 from the remote client.
 @param text the text to be completed (string)
 """
-self.__sendCommand("{0}{1}\n".format(RequestCompletion, text))
+self.__sendCommand("{0}{1}\n".format(DebugProtocol.RequestCompletion, text))
 def remoteUTPrepare(self, fn, tn, tfn, cov, covname, coverase):
 """
 Public method to prepare a new unittest run.
 filename
 @param coverase flag indicating erasure of coverage data is requested
 """
 fn = self.translate(os.path.abspath(fn), False)
 self.__sendCommand('{0}{1}|{2}|{3}|{4:d}|{5}|{6:d}\n'.format(
-RequestUTPrepare, fn, tn, tfn, cov, covname, coverase))
+DebugProtocol.RequestUTPrepare, fn, tn, tfn, cov, covname, coverase))
 def remoteUTRun(self):
 """
 Public method to start a unittest run.
 """
-self.__sendCommand('{0}\n'.format(RequestUTRun))
+self.__sendCommand('{0}\n'.format(DebugProtocol.RequestUTRun))
 def remoteUTStop(self):
 """
 Public method to stop a unittest run.
 """
-self.__sendCommand('{0}\n'.format(RequestUTStop))
+self.__sendCommand('{0}\n'.format(DebugProtocol.RequestUTStop))
 def __askForkTo(self):
 """
 Private method to ask the user which branch of a fork to follow.
 """
 self.trUtf8("Client forking"),
 self.trUtf8("Select the fork branch to follow."),
 selections,
 0, False)
 if not ok or res == selections[0]:
-self.__sendCommand(ResponseForkTo + 'parent\n')
+self.__sendCommand(DebugProtocol.ResponseForkTo + 'parent\n')
 else:
-self.__sendCommand(ResponseForkTo + 'child\n')
+self.__sendCommand(DebugProtocol.ResponseForkTo + 'child\n')
 def __parseClientLine(self):
 """
 Private method to handle data from the client.
 """
 qs = self.qsock.readLine()
 if self.codec is not None:
 line = self.codec.toUnicode(qs)
 else:
 line = bytes(qs).decode()
-if line.endswith(EOT):
+if line.endswith(DebugProtocol.EOT):
-line = line[:-len(EOT)]
+line = line[:-len(DebugProtocol.EOT)]
 if not line:
 continue
 ##            print("Server: ", line)          ##debug
 if boc >= 0 and eoc > boc:
 resp = line[boc:eoc]
 evalArg = self.__unicodeRe.sub(r"\1", line[eoc:-1])
-if resp == ResponseLine or resp == ResponseStack:
+if resp == DebugProtocol.ResponseLine or \
+resp == DebugProtocol.ResponseStack:
 stack = eval(evalArg)
 for s in stack:
 s[0] = self.translate(s[0], True)
 cf = stack[0]
 if self.__autoContinue:
 self.__autoContinue = False
 QTimer.singleShot(0, self.remoteContinue)
 else:
 self.debugServer.signalClientLine(cf[0], int(cf[1]),
-resp == ResponseStack)
+resp == DebugProtocol.ResponseStack)
 self.debugServer.signalClientStack(stack)
 continue
-if resp == ResponseThreadList:
+if resp == DebugProtocol.ResponseThreadList:
 currentId, threadList = eval(evalArg)
 self.debugServer.signalClientThreadList(currentId, threadList)
 continue
-if resp == ResponseThreadSet:
+if resp == DebugProtocol.ResponseThreadSet:
 self.debugServer.signalClientThreadSet()
 continue
-if resp == ResponseVariables:
+if resp == DebugProtocol.ResponseVariables:
 vlist = eval(evalArg)
 scope = vlist[0]
 try:
 variables = vlist[1:]
 except IndexError:
 variables = []
 self.debugServer.signalClientVariables(scope, variables)
 continue
-if resp == ResponseVariable:
+if resp == DebugProtocol.ResponseVariable:
 vlist = eval(evalArg)
 scope = vlist[0]
 try:
 variables = vlist[1:]
 except IndexError:
 variables = []
 self.debugServer.signalClientVariable(scope, variables)
 continue
-if resp == ResponseOK:
+if resp == DebugProtocol.ResponseOK:
 self.debugServer.signalClientStatement(False)
 continue
-if resp == ResponseContinue:
+if resp == DebugProtocol.ResponseContinue:
 self.debugServer.signalClientStatement(True)
 continue
-if resp == ResponseException:
+if resp == DebugProtocol.ResponseException:
 exc = self.translate(evalArg, True)
 try:
 exclist = eval(exc)
 exctype = exclist[0]
 excmessage = exclist[1]
 excmessage = ''
 stack = []
 self.debugServer.signalClientException(exctype, excmessage, stack)
 continue
-if resp == ResponseSyntax:
+if resp == DebugProtocol.ResponseSyntax:
 exc = self.translate(evalArg, True)
 try:
 message, (fn, ln, cn) = eval(exc)
 if fn is None:
 fn = ''
 if cn is None:
 cn = 0
 self.debugServer.signalClientSyntaxError(message, fn, ln, cn)
 continue
-if resp == ResponseExit:
+if resp == DebugProtocol.ResponseExit:
 self.debugServer.signalClientExit(evalArg)
 continue
-if resp == ResponseClearBreak:
+if resp == DebugProtocol.ResponseClearBreak:
 fn, lineno = evalArg.split(',')
 lineno = int(lineno)
 fn = self.translate(fn, True)
 self.debugServer.signalClientClearBreak(fn, lineno)
 continue
-if resp == ResponseBPConditionError:
+if resp == DebugProtocol.ResponseBPConditionError:
 fn, lineno = evalArg.split(',')
 lineno = int(lineno)
 fn = self.translate(fn, True)
 self.debugServer.signalClientBreakConditionError(fn, lineno)
 continue
-if resp == ResponseClearWatch:
+if resp == DebugProtocol.ResponseClearWatch:
 self.debugServer.signalClientClearWatch(evalArg)
 continue
-if resp == ResponseWPConditionError:
+if resp == DebugProtocol.ResponseWPConditionError:
 self.debugServer.signalClientWatchConditionError(evalArg)
 continue
-if resp == ResponseRaw:
+if resp == DebugProtocol.ResponseRaw:
 prompt, echo = eval(evalArg)
 self.debugServer.signalClientRawInput(prompt, echo)
 continue
-if resp == ResponseBanner:
+if resp == DebugProtocol.ResponseBanner:
 version, platform, dbgclient = eval(evalArg)
 self.debugServer.signalClientBanner(version, platform, dbgclient)
 continue
-if resp == ResponseCapabilities:
+if resp == DebugProtocol.ResponseCapabilities:
 cap, clType = eval(evalArg)
 self.clientCapabilities = cap
 self.debugServer.signalClientCapabilities(cap, clType)
 continue
-if resp == ResponseCompletion:
+if resp == DebugProtocol.ResponseCompletion:
 clstring, text = evalArg.split('||')
 cl = eval(clstring)
 self.debugServer.signalClientCompletionList(cl, text)
 continue
-if resp == PassiveStartup:
+if resp == DebugProtocol.PassiveStartup:
 fn, exc = evalArg.split('|')
 exc = bool(exc)
 fn = self.translate(fn, True)
 self.debugServer.passiveStartUp(fn, exc)
 continue
-if resp == ResponseUTPrepared:
+if resp == DebugProtocol.ResponseUTPrepared:
 res, exc_type, exc_value = eval(evalArg)
 self.debugServer.clientUtPrepared(res, exc_type, exc_value)
 continue
-if resp == ResponseUTStartTest:
+if resp == DebugProtocol.ResponseUTStartTest:
 testname, doc = eval(evalArg)
 self.debugServer.clientUtStartTest(testname, doc)
 continue
-if resp == ResponseUTStopTest:
+if resp == DebugProtocol.ResponseUTStopTest:
 self.debugServer.clientUtStopTest()
 continue
-if resp == ResponseUTTestFailed:
+if resp == DebugProtocol.ResponseUTTestFailed:
 testname, traceback = eval(evalArg)
 self.debugServer.clientUtTestFailed(testname, traceback)
 continue
-if resp == ResponseUTTestErrored:
+if resp == DebugProtocol.ResponseUTTestErrored:
 testname, traceback = eval(evalArg)
 self.debugServer.clientUtTestErrored(testname, traceback)
 continue
-if resp == ResponseUTFinished:
+if resp == DebugProtocol.ResponseUTFinished:
 self.debugServer.clientUtFinished()
 continue
-if resp == RequestForkTo:
+if resp == DebugProtocol.RequestForkTo:
 self.__askForkTo()
 continue
 self.debugServer.signalClientOutput(line)

Mercurial Repositories > eric / file comparison

comparison: Debugger/DebuggerInterfacePython.py

Debugger/DebuggerInterfacePython.py