eric: comparison Debugger/DebuggerInterfacePython3.py

-:d07dd3cf0dc3
+:1ba8ee313b57
 # 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(DebugProtocol.RequestShutdown))
+##        self.__sendCommand('{0}\n'.format(DebugProtocol.RequestShutdown))
+self.__sendJsonCommand("RequestShutdown", {})
 self.qsock.flush()
 self.qsock.close()
 # reinitialize
 ##            DebugProtocol.RequestContinue, special))
 self.__sendJsonCommand("RequestContinue", {
 "special": special,
 })
-def remoteBreakpoint(self, fn, line, set, cond=None, temp=False):
+def remoteBreakpoint(self, fn, line, setBreakpoint, cond=None, temp=False):
 """
 Public method to set or clear a breakpoint.
 @param fn filename the breakpoint belongs to (string)
 @param line linenumber of the breakpoint (int)
-@param set flag indicating setting or resetting a breakpoint (boolean)
+@param setBreakpoint flag indicating setting or resetting a
+breakpoint (boolean)
 @param cond condition of the breakpoint (string)
 @param temp flag indicating a temporary breakpoint (boolean)
 """
-fn = self.translate(fn, False)
+##        fn = self.translate(fn, False)
-self.__sendCommand('{0}{1}@@{2:d}@@{3:d}@@{4:d}@@{5}\n'.format(
+##        self.__sendCommand('{0}{1}@@{2:d}@@{3:d}@@{4:d}@@{5}\n'.format(
-DebugProtocol.RequestBreak, fn, line, temp, set, cond))
+##            DebugProtocol.RequestBreak, fn, line, temp, set, cond))
+self.__sendJsonCommand("RequestBreakpoint", {
+"filename": self.translate(fn, False),
+"line": line,
+"temporary": temp,
+"setBreakpoint": setBreakpoint,
+"condition": cond,
+})
 def remoteBreakpointEnable(self, fn, line, enable):
 """
 Public method to enable or disable a breakpoint.
 @param fn filename the breakpoint belongs to (string)
 @param line linenumber of the breakpoint (int)
 @param enable flag indicating enabling or disabling a breakpoint
 (boolean)
 """
-fn = self.translate(fn, False)
+##        fn = self.translate(fn, False)
-self.__sendCommand('{0}{1},{2:d},{3:d}\n'.format(
+##        self.__sendCommand('{0}{1},{2:d},{3:d}\n'.format(
-DebugProtocol.RequestBreakEnable, fn, line, enable))
+##            DebugProtocol.RequestBreakEnable, fn, line, enable))
+self.__sendJsonCommand("RequestBreakpointEnable", {
+"filename": self.translate(fn, False),
+"line": line,
+"enable": enable,
+})
 def remoteBreakpointIgnore(self, fn, line, count):
 """
 Public method to ignore a breakpoint the next couple of occurrences.
 @param fn filename the breakpoint belongs to (string)
 @param line linenumber of the breakpoint (int)
 @param count number of occurrences to ignore (int)
 """
-fn = self.translate(fn, False)
+##        fn = self.translate(fn, False)
-self.__sendCommand('{0}{1},{2:d},{3:d}\n'.format(
+##        self.__sendCommand('{0}{1},{2:d},{3:d}\n'.format(
-DebugProtocol.RequestBreakIgnore, fn, line, count))
+##            DebugProtocol.RequestBreakIgnore, fn, line, count))
+self.__sendJsonCommand("RequestBreakpointIgnore", {
-def remoteWatchpoint(self, cond, set, temp=False):
+"filename": self.translate(fn, False),
+"line": line,
+"count": count,
+})
+def remoteWatchpoint(self, cond, setWatch, 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
+@param setWatch flag indicating setting or resetting a watch expression
 (boolean)
 @param temp flag indicating a temporary watch expression (boolean)
 """
 # cond is combination of cond and special (s. watch expression viewer)
-self.__sendCommand('{0}{1}@@{2:d}@@{3:d}\n'.format(
+##        self.__sendCommand('{0}{1}@@{2:d}@@{3:d}\n'.format(
-DebugProtocol.RequestWatch, cond, temp, set))
+##            DebugProtocol.RequestWatch, cond, temp, set))
+self.__sendJsonCommand("RequestWatch", {
+"temporary": temp,
+"setWatch": setWatch,
+"condition": cond,
+})
 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(
+##        self.__sendCommand('{0}{1},{2:d}\n'.format(
-DebugProtocol.RequestWatchEnable, cond, enable))
+##            DebugProtocol.RequestWatchEnable, cond, enable))
+self.__sendJsonCommand("RequestWatchEnable", {
+"condition": cond,
+"enable": 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(
+##        self.__sendCommand('{0}{1},{2:d}\n'.format(
-DebugProtocol.RequestWatchIgnore, cond, count))
+##            DebugProtocol.RequestWatchIgnore, cond, count))
+self.__sendJsonCommand("RequestWatchIgnore", {
+"condition": cond,
+"count": 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(DebugProtocol.RequestThreadList))
+##        self.__sendCommand('{0}\n'.format(DebugProtocol.RequestThreadList))
+self.__sendJsonCommand("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(
+##        self.__sendCommand('{0}{1:d}\n'.format(
-DebugProtocol.RequestThreadSet, tid))
+##            DebugProtocol.RequestThreadSet, tid))
+self.__sendJsonCommand("RequestThreadSet", {
+"threadID": 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(
+##        self.__sendCommand('{0}{1:d}, {2:d}, {3}\n'.format(
-DebugProtocol.RequestVariables, framenr, scope, str(filter)))
+##            DebugProtocol.RequestVariables, framenr, scope, str(filter)))
+self.__sendJsonCommand("RequestVariables", {
+"frameNumber": framenr,
+"scope": scope,
+"filters": filter,
+})
 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 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(
+##        self.__sendCommand('{0}{1}, {2:d}, {3:d}, {4}\n'.format(
-DebugProtocol.RequestVariable, str(var), framenr, scope,
+##            DebugProtocol.RequestVariable, str(var), framenr, scope,
-str(filter)))
+##            str(filter)))
+self.__sendJsonCommand("RequestVariable", {
+"variable": var,
+"frameNumber": framenr,
+"scope": scope,
+"filters": 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(
+##        self.__sendCommand('{0}{1:d}, "{2}"\n'.format(
-DebugProtocol.RequestSetFilter, scope, filter))
+##            DebugProtocol.RequestSetFilter, scope, filter))
+self.__sendJsonCommand("RequestSetFilter", {
+"scope": scope,
+"filter": filter,
+})
 def setCallTraceEnabled(self, on):
 """
 Public method to set the call trace state.
 @param on flag indicating to enable the call trace function (boolean)
 """
-if on:
+##        if on:
-cmd = "on"
+##            cmd = "on"
-else:
+##        else:
-cmd = "off"
+##            cmd = "off"
-self.__sendCommand('{0}{1}\n'.format(
+##        self.__sendCommand('{0}{1}\n'.format(
-DebugProtocol.RequestCallTrace, cmd))
+##            DebugProtocol.RequestCallTrace, cmd))
+self.__sendJsonCommand("RequestCallTrace", {
-def remoteEval(self, arg):
+"enable": on,
-"""
+})
-Public method to evaluate arg in the current context of the debugged
-program.
+##    def remoteEval(self, arg):
+##        """
-@param arg the arguments to evaluate (string)
+##        Public method to evaluate arg in the current context of the debugged
-"""
+##        program.
-self.__sendCommand('{0}{1}\n'.format(DebugProtocol.RequestEval, arg))
+##
+##        @param arg the arguments to evaluate (string)
-def remoteExec(self, stmt):
+##        """
-"""
+####        self.__sendCommand('{0}{1}\n'.format(DebugProtocol.RequestEval, arg))
-Public method to execute stmt in the current context of the debugged
+##        self.__sendJsonCommand("RequestEval", {
-program.
+##            "argument": arg,
+##        })
-@param stmt statement to execute (string)
+##
-"""
+##    def remoteExec(self, stmt):
-self.__sendCommand('{0}{1}\n'.format(DebugProtocol.RequestExec, 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(DebugProtocol.RequestExec, stmt))
+##
 def remoteBanner(self):
 """
 Public slot to get the banner info of the remote client.
 """
 ##        self.__sendCommand(DebugProtocol.RequestBanner + '\n')
 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(
+##        self.__sendCommand("{0}{1}\n".format(
-DebugProtocol.RequestCompletion, text))
+##            DebugProtocol.RequestCompletion, text))
+self.__sendJsonCommand("RequestCompletion", {
+"text": text,
+})
 def remoteUTPrepare(self, fn, tn, tfn, failed, cov, covname, coverase):
 """
 Public method to prepare a new unittest run.
 boc = line.find('>')
 if boc >= 0 and eoc > boc:
 resp = line[boc:eoc]
-if resp == DebugProtocol.ResponseLine or \
+##                if resp == DebugProtocol.ResponseLine or \
-resp == DebugProtocol.ResponseStack:
+##                   resp == DebugProtocol.ResponseStack:
-stack = eval(line[eoc:-1])
+##                    stack = eval(line[eoc:-1])
-for s in stack:
+##                    for s in stack:
-s[0] = self.translate(s[0], True)
+##                        s[0] = self.translate(s[0], True)
-cf = stack[0]
+##                    cf = stack[0]
-if self.__autoContinue:
+##                    if self.__autoContinue:
-self.__autoContinue = False
+##                        self.__autoContinue = False
-QTimer.singleShot(0, self.remoteContinue)
+##                        QTimer.singleShot(0, self.remoteContinue)
-else:
+##                    else:
-self.debugServer.signalClientLine(
+##                        self.debugServer.signalClientLine(
-cf[0], int(cf[1]),
+##                            cf[0], int(cf[1]),
-resp == DebugProtocol.ResponseStack)
+##                            resp == DebugProtocol.ResponseStack)
-self.debugServer.signalClientStack(stack)
+##                        self.debugServer.signalClientStack(stack)
-continue
+##                    continue
+##
-if resp == DebugProtocol.CallTrace:
+##                if resp == DebugProtocol.CallTrace:
-event, fromStr, toStr = line[eoc:-1].split("@@")
+##                    event, fromStr, toStr = line[eoc:-1].split("@@")
-isCall = event.lower() == "c"
+##                    isCall = event.lower() == "c"
-fromFile, fromLineno, fromFunc = fromStr.rsplit(":", 2)
+##                    fromFile, fromLineno, fromFunc = fromStr.rsplit(":", 2)
-toFile, toLineno, toFunc = toStr.rsplit(":", 2)
+##                    toFile, toLineno, toFunc = toStr.rsplit(":", 2)
-self.debugServer.signalClientCallTrace(
+##                    self.debugServer.signalClientCallTrace(
-isCall,
+##                        isCall,
-fromFile, fromLineno, fromFunc,
+##                        fromFile, fromLineno, fromFunc,
-toFile, toLineno, toFunc)
+##                        toFile, toLineno, toFunc)
-continue
+##                    continue
+##
-if resp == DebugProtocol.ResponseThreadList:
+##                if resp == DebugProtocol.ResponseThreadList:
-currentId, threadList = eval(line[eoc:-1])
+##                    currentId, threadList = eval(line[eoc:-1])
-self.debugServer.signalClientThreadList(
+##                    self.debugServer.signalClientThreadList(
-currentId, threadList)
+##                        currentId, threadList)
-continue
+##                    continue
+##
-if resp == DebugProtocol.ResponseThreadSet:
+##                if resp == DebugProtocol.ResponseThreadSet:
-self.debugServer.signalClientThreadSet()
+##                    self.debugServer.signalClientThreadSet()
-continue
+##                    continue
+##
-if resp == DebugProtocol.ResponseVariables:
+##                if resp == DebugProtocol.ResponseVariables:
-vlist = eval(line[eoc:-1])
+##                    vlist = eval(line[eoc:-1])
-scope = vlist[0]
+##                    scope = vlist[0]
-try:
+##                    try:
-variables = vlist[1:]
+##                        variables = vlist[1:]
-except IndexError:
+##                    except IndexError:
-variables = []
+##                        variables = []
-self.debugServer.signalClientVariables(scope, variables)
+##                    self.debugServer.signalClientVariables(scope, variables)
-continue
+##                    continue
+##
-if resp == DebugProtocol.ResponseVariable:
+##                if resp == DebugProtocol.ResponseVariable:
-vlist = eval(line[eoc:-1])
+##                    vlist = eval(line[eoc:-1])
-scope = vlist[0]
+##                    scope = vlist[0]
-try:
+##                    try:
-variables = vlist[1:]
+##                        variables = vlist[1:]
-except IndexError:
+##                    except IndexError:
-variables = []
+##                        variables = []
-self.debugServer.signalClientVariable(scope, variables)
+##                    self.debugServer.signalClientVariable(scope, variables)
-continue
+##                    continue
+##
 ##                if resp == DebugProtocol.ResponseOK:
 ##                    self.debugServer.signalClientStatement(False)
 ##                    continue
 ##
 ##                if resp == DebugProtocol.ResponseContinue:
 ##                    self.debugServer.signalClientStatement(True)
 ##                    continue
 ##
-if resp == DebugProtocol.ResponseException:
+##                if resp == DebugProtocol.ResponseException:
-exc = line[eoc:-1]
+##                    exc = line[eoc:-1]
-exc = self.translate(exc, True)
+##                    exc = self.translate(exc, True)
-try:
+##                    try:
-exclist = eval(exc)
+##                        exclist = eval(exc)
-exctype = exclist[0]
+##                        exctype = exclist[0]
-excmessage = exclist[1]
+##                        excmessage = exclist[1]
-stack = exclist[2:]
+##                        stack = exclist[2:]
-if stack and stack[0] and stack[0][0] == "<string>":
+##                        if stack and stack[0] and stack[0][0] == "<string>":
-for stackEntry in stack:
+##                            for stackEntry in stack:
-if stackEntry[0] == "<string>":
+##                                if stackEntry[0] == "<string>":
-stackEntry[0] = self.__scriptName
+##                                    stackEntry[0] = self.__scriptName
-else:
+##                                else:
-break
+##                                    break
-except (IndexError, ValueError, SyntaxError):
+##                    except (IndexError, ValueError, SyntaxError):
-exctype = None
+##                        exctype = None
-excmessage = ''
+##                        excmessage = ''
-stack = []
+##                        stack = []
-self.debugServer.signalClientException(
+##                    self.debugServer.signalClientException(
-exctype, excmessage, stack)
+##                        exctype, excmessage, stack)
-continue
+##                    continue
+##
-if resp == DebugProtocol.ResponseSyntax:
+##                if resp == DebugProtocol.ResponseSyntax:
-exc = line[eoc:-1]
+##                    exc = line[eoc:-1]
-exc = self.translate(exc, True)
+##                    exc = self.translate(exc, True)
-try:
+##                    try:
-message, (fn, ln, cn) = eval(exc)
+##                        message, (fn, ln, cn) = eval(exc)
-if fn is None:
+##                        if fn is None:
-fn = ''
+##                            fn = ''
-except (IndexError, ValueError):
+##                    except (IndexError, ValueError):
-message = None
+##                        message = None
-fn = ''
+##                        fn = ''
-ln = 0
+##                        ln = 0
-cn = 0
+##                        cn = 0
-if cn is None:
+##                    if cn is None:
-cn = 0
+##                        cn = 0
-self.debugServer.signalClientSyntaxError(
+##                    self.debugServer.signalClientSyntaxError(
-message, fn, ln, cn)
+##                        message, fn, ln, cn)
-continue
+##                    continue
+##
-if resp == DebugProtocol.ResponseSignal:
+##                if resp == DebugProtocol.ResponseSignal:
-sig = line[eoc:-1]
+##                    sig = line[eoc:-1]
-sig = self.translate(sig, True)
+##                    sig = self.translate(sig, True)
-message, (fn, ln, func, args) = eval(sig)
+##                    message, (fn, ln, func, args) = eval(sig)
-self.debugServer.signalClientSignal(
+##                    self.debugServer.signalClientSignal(
-message, fn, ln, func, args)
+##                        message, fn, ln, func, args)
-continue
+##                    continue
+##
-if resp == DebugProtocol.ResponseExit:
+##                if resp == DebugProtocol.ResponseExit:
-self.__scriptName = ""
+##                    self.__scriptName = ""
-self.debugServer.signalClientExit(line[eoc:-1])
+##                    self.debugServer.signalClientExit(line[eoc:-1])
-continue
+##                    continue
+##
-if resp == DebugProtocol.ResponseClearBreak:
+##                if resp == DebugProtocol.ResponseClearBreak:
-fn, lineno = line[eoc:-1].split(',')
+##                    fn, lineno = line[eoc:-1].split(',')
-lineno = int(lineno)
+##                    lineno = int(lineno)
-fn = self.translate(fn, True)
+##                    fn = self.translate(fn, True)
-self.debugServer.signalClientClearBreak(fn, lineno)
+##                    self.debugServer.signalClientClearBreak(fn, lineno)
-continue
+##                    continue
+##
-if resp == DebugProtocol.ResponseBPConditionError:
+##                if resp == DebugProtocol.ResponseBPConditionError:
-fn, lineno = line[eoc:-1].split(',')
+##                    fn, lineno = line[eoc:-1].split(',')
-lineno = int(lineno)
+##                    lineno = int(lineno)
-fn = self.translate(fn, True)
+##                    fn = self.translate(fn, True)
-self.debugServer.signalClientBreakConditionError(
+##                    self.debugServer.signalClientBreakConditionError(
-fn, lineno)
+##                        fn, lineno)
-continue
+##                    continue
+##
-if resp == DebugProtocol.ResponseClearWatch:
+##                if resp == DebugProtocol.ResponseClearWatch:
-cond = line[eoc:-1]
+##                    cond = line[eoc:-1]
-self.debugServer.signalClientClearWatch(cond)
+##                    self.debugServer.signalClientClearWatch(cond)
-continue
+##                    continue
+##
-if resp == DebugProtocol.ResponseWPConditionError:
+##                if resp == DebugProtocol.ResponseWPConditionError:
-cond = line[eoc:-1]
+##                    cond = line[eoc:-1]
-self.debugServer.signalClientWatchConditionError(cond)
+##                    self.debugServer.signalClientWatchConditionError(cond)
-continue
+##                    continue
+##
 ##                if resp == DebugProtocol.ResponseRaw:
 ##                    prompt, echo = eval(line[eoc:-1])
 ##                    self.debugServer.signalClientRawInput(prompt, echo)
 ##                    continue
 ##
 ##                    cap, clType = eval(line[eoc:-1])
 ##                    self.clientCapabilities = cap
 ##                    self.debugServer.signalClientCapabilities(cap, clType)
 ##                    continue
 ##
-if resp == DebugProtocol.ResponseCompletion:
+##                if resp == DebugProtocol.ResponseCompletion:
-clstring, text = line[eoc:-1].split('||')
+##                    clstring, text = line[eoc:-1].split('||')
-cl = eval(clstring)
+##                    cl = eval(clstring)
-self.debugServer.signalClientCompletionList(cl, text)
+##                    self.debugServer.signalClientCompletionList(cl, text)
-continue
+##                    continue
+##
-if resp == DebugProtocol.PassiveStartup:
+##                if resp == DebugProtocol.PassiveStartup:
-fn, exc = line[eoc:-1].split('|')
+##                    fn, exc = line[eoc:-1].split('|')
-exc = bool(exc)
+##                    exc = bool(exc)
-fn = self.translate(fn, True)
+##                    fn = self.translate(fn, True)
-self.debugServer.passiveStartUp(fn, exc)
+##                    self.debugServer.passiveStartUp(fn, exc)
-continue
+##                    continue
+##
 if resp == DebugProtocol.ResponseUTPrepared:
 res, exc_type, exc_value = eval(line[eoc:-1])
 self.debugServer.clientUtPrepared(res, exc_type, exc_value)
 continue
 import json
 try:
 commandDict = json.loads(jsonStr.strip())
 except json.JSONDecodeError as err:
+# TODO: implement real error handling
 print(str(err))
 return
 method = commandDict["method"]
 params = commandDict["params"]
+if method in ["ResponseLine", "ResponseStack"]:
+for s in params["stack"]:
+s[0] = self.translate(s[0], True)
+cf = params["stack"][0]
+if self.__autoContinue:
+self.__autoContinue = False
+QTimer.singleShot(0, self.remoteContinue)
+else:
+self.debugServer.signalClientLine(
+cf[0], int(cf[1]),
+method == "ResponseStack")
+self.debugServer.signalClientStack(params["stack"])
+return
+if method == "CallTrace":
+isCall = params["event"].lower() == "c"
+fromFile, fromLineno, fromFunc = params["from"].rsplit(":", 2)
+toFile, toLineno, toFunc = params["to"].rsplit(":", 2)
+self.debugServer.signalClientCallTrace(
+isCall,
+fromFile, fromLineno, fromFunc,
+toFile, toLineno, toFunc)
+return
+if method == "ResponseVariables":
+self.debugServer.signalClientVariables(
+params["scope"], params["variables"])
+return
+if method == "ResponseVariable":
+self.debugServer.signalClientVariable(
+params["scope"], [params["variable"]] + params["variables"])
+return
+if method == "ResponseThreadList":
+self.debugServer.signalClientThreadList(
+params["currentID"], params["threadList"])
+return
+if method == "ResponseThreadSet":
+self.debugServer.signalClientThreadSet()
+return
 if method == "ResponseCapabilities":
 self.clientCapabilities = params["capabilities"]
 self.debugServer.signalClientCapabilities(
 params["capabilities"], params["clientType"])
 return
 if method == "RequestRaw":
 self.debugServer.signalClientRawInput(
 params["prompt"], params["echo"])
+return
+if method == "ResponseBPConditionError":
+params["filename"] = self.translate(params["filename"], True)
+self.debugServer.signalClientBreakConditionError(
+params["filename"], params["line"])
+return
+if method == "ResponseClearBreakpoint":
+params["filename"] = self.translate(params["filename"], True)
+self.debugServer.signalClientClearBreak(
+params["filename"], params["line"])
+return
+if method == "ResponseWatchConditionError":
+self.debugServer.signalClientWatchConditionError(
+params["condition"])
+return
+if method == "ResponseClearWatch":
+self.debugServer.signalClientClearWatch(params["condition"])
+return
+if method == "ResponseException":
+if params:
+exctype = params["type"]
+excmessage = params["message"]
+stack = params["stack"]
+if stack:
+for stackEntry in stack:
+stackEntry[0] = self.translate(stackEntry[0], True)
+if stack[0] and stack[0][0] == "<string>":
+for stackEntry in stack:
+if stackEntry[0] == "<string>":
+stackEntry[0] = self.__scriptName
+else:
+break
+else:
+exctype = None
+excmessage = ''
+stack = []
+self.debugServer.signalClientException(
+exctype, excmessage, stack)
+return
+if method == "ResponseSyntax":
+self.debugServer.signalClientSyntaxError(
+params["message"], self.translate(params["filename"], True),
+params["linenumber"], params["characternumber"])
+return
+if method == "ResponseSignal":
+self.debugServer.signalClientSignal(
+params["message"], self.translate(params["filename"], True),
+params["linenumber"], params["function"], params["arguments"])
+return
+if method == "ResponseExit":
+self.__scriptName = ""
+self.debugServer.signalClientExit(params["status"])
+return
+if method == "PassiveStartup":
+self.debugServer.passiveStartUp(
+self.translate(params["filename"], True), params["exceptions"])
+return
+if method == "ResponseCompletion":
+##                    clstring, text = line[eoc:-1].split('||')
+##                    cl = eval(clstring)
+self.debugServer.signalClientCompletionList(
+params["completions"], params["text"])
 return
 def __sendCommand(self, cmd):
 """
 Private method to send a single line command to the client.

Mercurial Repositories > eric / file comparison

comparison: Debugger/DebuggerInterfacePython3.py

Debugger/DebuggerInterfacePython3.py