eric: comparison DebugClients/Python/DebugClientBase.py

-:ab851fd69434
+:548a9ba8c970
 """
 Constructor
 """
 self.breakpoints = {}
 self.redirect = True
-self.__receiveBuffer = ""
 # special objects representing the main scripts thread and frame
 self.mainThread = self
 self.framenr = 0
 self.sendSyntaxError(message, filename, lineno, charno)
 return None
 return code
-def handleLine(self, line):
-"""
-Public method to handle the receipt of a complete line.
-It first looks for a valid protocol token at the start of the line.
-Thereafter it trys to execute the lines accumulated so far.
-@param line the received line
-"""
-# Remove any newline.
-if line[-1] == '\n':
-line = line[:-1]
-##        printerr(line)          ##debug
-self.handleJsonCommand(line)
 def handleJsonCommand(self, jsonStr):
 """
 Public method to handle a command serialized as a JSON string.
 @param jsonStr string containing the command received from the IDE
 @type str
 """
+##        printerr(jsonStr)          ##debug
 try:
 commandDict = json.loads(jsonStr.strip())
 except (TypeError, ValueError) as err:
+printerr("Error handling command: " + jsonStr)
 printerr(str(err))
 return
 method = commandDict["method"]
 params = commandDict["params"]
 params["filename"] = params["filename"].encode(
 sys.getfilesystemencoding())
 if method == "RequestVariables":
 self.__dumpVariables(
-params["frameNumber"], params["scope"], params["filters"])
+params["frameNumber"], params["scope"], params["filters"],
+params["maxSize"])
 elif method == "RequestVariable":
 self.__dumpVariable(
 params["variable"], params["frameNumber"],
-params["scope"], params["filters"])
+params["scope"], params["filters"],
+params["maxSize"])
 elif method == "RequestThreadList":
 self.dumpThreadList()
 elif method == "RequestThreadSet":
 Public method called when there is data ready to be read.
 @param stream file like object that has data to be written
 """
 try:
-got = stream.readline_p()
+self.lockClient()
+command = stream.readCommand()
+self.unlockClient()
 except Exception:
 return
-if len(got) == 0:
+if len(command) == 0:
 self.sessionClose()
 return
-self.__receiveBuffer = self.__receiveBuffer + got
+self.handleJsonCommand(command)
-# Call handleLine for the line if it is complete.
-eol = self.__receiveBuffer.find('\n')
-while eol >= 0:
-line = self.__receiveBuffer[:eol + 1]
-self.__receiveBuffer = self.__receiveBuffer[eol + 1:]
-self.handleLine(line)
-eol = self.__receiveBuffer.find('\n')
 def writeReady(self, stream):
 """
 Public method called when we are ready to write data.
 })
 # reset coding
 self.__coding = self.defaultCoding
-def __dumpVariables(self, frmnr, scope, filterList):
+def __dumpVariables(self, frmnr, scope, filterList, maxSize):
 """
 Private method to return the variables of a frame to the debug server.
 @param frmnr distance of frame reported on. 0 is the current frame
-(int)
+@type int
-@param scope 1 to report global variables, 0 for local variables (int)
+@param scope 1 to report global variables, 0 for local variables
+@type int
 @param filterList the indices of variable types to be filtered
-(list of int)
+@type list of int
+@param maxSize maximum size the formatted value of a variable will
+be shown. If it is bigger than that, a 'too big' indication will
+be given.
+@type int
 """
 if self.currentThread is None:
 return
 frmnr += self.currentThread.skipFrames
 if scope != -1:
 keylist = varDict.keys()
 vlist = self.__formatVariablesList(
-keylist, varDict, scope, filterList)
+keylist, varDict, scope, filterList, maxSize=maxSize)
 varlist.extend(vlist)
 self.sendJsonCommand("ResponseVariables", {
 "scope": scope,
 "variables": varlist,
 })
-def __dumpVariable(self, var, frmnr, scope, filterList):
+def __dumpVariable(self, var, frmnr, scope, filterList, maxSize):
 """
 Private method to return the variables of a frame to the debug server.
 @param var list encoded name of the requested variable
-(list of strings)
+@type list of strings
 @param frmnr distance of frame reported on. 0 is the current frame
-(int)
+@type int
 @param scope 1 to report global variables, 0 for local variables (int)
 @param filterList the indices of variable types to be filtered
-(list of int)
+@type list of int
+@param maxSize maximum size the formatted value of a variable will
+be shown. If it is bigger than that, a 'too big' indication will
+be given.
+@type int
 """
 if self.currentThread is None:
 return
 frmnr += self.currentThread.skipFrames
 vlist = self.__formatQtVariable(variable, typeName)
 varlist.extend(vlist)
 elif resolver:
 varDict = resolver.getDictionary(variable)
 vlist = self.__formatVariablesList(
-list(varDict.keys()), varDict, scope, filterList)
+list(varDict.keys()), varDict, scope, filterList,
+maxSize=maxSize)
 varlist.extend(vlist)
 self.sendJsonCommand("ResponseVariable", {
 "scope": scope,
 "variable": var,
 ("address", "QHostAddress", "{0}".format(value.toString())))
 return varlist
 def __formatVariablesList(self, keylist, dict_, scope, filterList=None,
-formatSequences=False):
+formatSequences=False, maxSize=0):
 """
 Private method to produce a formated variables list.
 The dictionary passed in to it is scanned. Variables are
 only added to the list, if their type is not contained
 in the filter list and their name doesn't match any of the filter
 expressions. The formated variables list (a list of tuples of 3
 values) is returned.
-@param keylist keys of the dictionary
+@param keylist keys of the dictionary to be formatted
+@type list of str
 @param dict_ the dictionary to be scanned
+@type dict
 @param scope 1 to filter using the globals filter, 0 using the locals
-filter (int).
+filter.
 Variables are only added to the list, if their name do not match
 any of the filter expressions.
+@type int
 @param filterList the indices of variable types to be filtered.
 Variables are only added to the list, if their type is not
 contained in the filter list.
+@type list of int
 @param formatSequences flag indicating, that sequence or dictionary
 variables should be formatted. If it is 0 (or false), just the
-number of items contained in these variables is returned. (boolean)
+number of items contained in these variables is returned.
+@type bool
+@param maxSize maximum size the formatted value of a variable will
+be shown. If it is bigger than that, a 'too big' indication will
+be placed in the value field.
+@type int
 @return A tuple consisting of a list of formatted variables. Each
 variable entry is a tuple of three elements, the variable name,
 its type and value.
+@rtype list of tuple of (str, str, str)
 """
 filterList = [] if filterList is None else filterList[:]
 varlist = []
 if scope:
 else:
 rvalue = repr(value)
 if valtype.startswith('class') and \
 rvalue[0] in ['{', '(', '[']:
 rvalue = ""
+elif maxSize and len(rvalue) > maxSize:
+rvalue = "@@TOO_BIG_TO_SHOW@@"
 except Exception:
 rvalue = ''
 if formatSequences:
 if str(key) == key:
 if sys.argv[2] == "True":
 redirect = True
 elif sys.argv[2] == "False":
 redirect = False
 else:
 try:
 redirect = int(sys.argv[2])
 except (ValueError, IndexError):
 redirect = True

Mercurial Repositories > eric / file comparison

comparison: DebugClients/Python/DebugClientBase.py

DebugClients/Python/DebugClientBase.py