eric: comparison DebugClients/Python/DebugClientBase.py

-:884cd9c9ce05
+:b93cb6353cc0
 DebugClient classes. Do not instantiate it directly.
 """
 clientCapabilities = DebugClientCapabilities.HasAll
 # keep these in sync with VariablesViewer.VariableItem.Indicators
-Indicators = ("()", "[]", "{:}", "{}")         # __IGNORE_WARNING__
+Indicators = ("()", "[]", "{:}", "{}")      # __IGNORE_WARNING_M613__
 def __init__(self):
 """
 Constructor
 """
 self.pollingDisabled = False
 self.callTraceEnabled = None
 self.variant = 'You should not see this'
-# commandline completion stuff
-self.complete = Completer(self.debugMod.__dict__).complete
 self.compile_command = codeop.CommandCompiler()
 self.coding_re = re.compile(r"coding[:=]\s*([-\w_.]+)")
 self.defaultCoding = 'utf-8'
 @param prompt the prompt to be shown (string)
 @return the entered string evaluated as a Python expresion
 """
 return eval(self.raw_input(prompt, True))
-def sessionClose(self, exit=True):
+def sessionClose(self, terminate=True):
 """
 Public method to close the session with the debugger and optionally
 terminate.
-@param exit flag indicating to terminate (boolean)
+@param terminate flag indicating to terminate (boolean)
 """
 try:
 self.set_quit()
 except Exception:
 pass
 # SHOULD be closed on exit, but it does not hurt to do it here
 self.readstream.close(True)
 self.writestream.close(True)
 self.errorstream.close(True)
-if exit:
+if terminate:
 # Ok, go away.
 sys.exit()
 def __compileFileSource(self, filename, mode='exec'):
 """
 self.progTerminated(42)
 else:
 self.set_quit()
 self.eventExit = True
+elif method == "RequestMoveIP":
+newLine = params["newLine"]
+self.currentThreadExec.move_instruction_pointer(newLine)
 elif method == "RequestContinue":
 self.currentThreadExec.go(params["special"])
 self.eventExit = True
 elif method == "RawInput":
 })
 # reset coding
 self.__coding = self.defaultCoding
-def __dumpVariables(self, frmnr, scope, filter):
+def __dumpVariables(self, frmnr, scope, filterList):
 """
 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)
 @param scope 1 to report global variables, 0 for local variables (int)
-@param filter the indices of variable types to be filtered
+@param filterList the indices of variable types to be filtered
 (list of int)
 """
 if self.currentThread is None:
 return
 f = f.f_back
 frmnr -= 1
 if f is None:
 if scope:
-dict = self.debugMod.__dict__
+varDict = self.debugMod.__dict__
 else:
 scope = -1
 elif scope:
-dict = f.f_globals
+varDict = f.f_globals
 elif f.f_globals is f.f_locals:
 scope = -1
 else:
-dict = f.f_locals
+varDict = f.f_locals
 varlist = []
 if scope != -1:
-keylist = dict.keys()
+keylist = varDict.keys()
-vlist = self.__formatVariablesList(keylist, dict, scope, filter)
+vlist = self.__formatVariablesList(
+keylist, varDict, scope, filterList)
 varlist.extend(vlist)
 self.sendJsonCommand("ResponseVariables", {
 "scope": scope,
 "variables": varlist,
 })
-def __dumpVariable(self, var, frmnr, scope, filter):
+def __dumpVariable(self, var, frmnr, scope, filterList):
 """
 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)
 @param frmnr distance of frame reported on. 0 is the current frame
 (int)
 @param scope 1 to report global variables, 0 for local variables (int)
-@param filter the indices of variable types to be filtered
+@param filterList the indices of variable types to be filtered
 (list of int)
 """
 if self.currentThread is None:
 return
 f = f.f_back
 frmnr -= 1
 if f is None:
 if scope:
-dict = self.debugMod.__dict__
+varDict = self.debugMod.__dict__
 else:
 scope = -1
 elif scope:
-dict = f.f_globals
+varDict = f.f_globals
 elif f.f_globals is f.f_locals:
 scope = -1
 else:
-dict = f.f_locals
+varDict = f.f_locals
 varlist = []
 if scope != -1:
-variable = dict
+variable = varDict
 for attribute in var:
 attribute = self.__extractIndicators(attribute)[0]
 typeObject, typeName, typeStr, resolver = \
 DebugVariables.getType(variable)
 if resolver:
 DebugVariables.getType(variable)
 if typeStr.startswith(("PyQt5.", "PyQt4.")):
 vlist = self.__formatQtVariable(variable, typeName)
 varlist.extend(vlist)
 elif resolver:
-dict = resolver.getDictionary(variable)
+varDict = resolver.getDictionary(variable)
 vlist = self.__formatVariablesList(
-list(dict.keys()), dict, scope, filter)
+list(varDict.keys()), varDict, scope, filterList)
 varlist.extend(vlist)
 self.sendJsonCommand("ResponseVariable", {
 "scope": scope,
 "variable": var,
 varlist.append(
 ("address", "QHostAddress", "{0}".format(value.toString())))
 return varlist
-def __formatVariablesList(self, keylist, dict_, scope, filter=[],
+def __formatVariablesList(self, keylist, dict_, scope, filterList=None,
 formatSequences=False):
 """
 Private method to produce a formated variables list.
 The dictionary passed in to it is scanned. Variables are
 @param dict_ the dictionary to be scanned
 @param scope 1 to filter using the globals filter, 0 using the locals
 filter (int).
 Variables are only added to the list, if their name do not match
 any of the filter expressions.
-@param filter the indices of variable types to be filtered. Variables
+@param filterList the indices of variable types to be filtered.
-are only added to the list, if their type is not contained in the
+Variables are only added to the list, if their type is not
-filter list.
+contained in the filter list.
 @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)
 @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.
 """
+filterList = [] if filterList is None else filterList[:]
 varlist = []
 if scope:
 patternFilterObjects = self.globalsFilterObjects
 else:
 patternFilterObjects = self.localsFilterObjects
 break
 if matched:
 continue
 # filter hidden attributes (filter #0)
-if 0 in filter and str(key)[:2] == '__' and not (
+if 0 in filterList and str(key)[:2] == '__' and not (
 key == "___len___" and
 DebugVariables.TooLargeAttribute in keylist):
 continue
 # special handling for '__builtins__' (it's way too big)
 _, valtype = valtypestr.split(' ', 1)
 valtype = valtype[1:-1]
 valtypename = type(value).__name__
 if valtype not in ConfigVarTypeStrings:
 if valtype in ["numpy.ndarray", "array.array"]:
-if ConfigVarTypeStrings.index('list') in filter:
+if ConfigVarTypeStrings.index('list') in filterList:
 continue
 elif valtypename == "MultiValueDict":
-if ConfigVarTypeStrings.index('dict') in filter:
+if ConfigVarTypeStrings.index('dict') in filterList:
 continue
 elif valtype == "sip.methoddescriptor":
 if ConfigVarTypeStrings.index(
-'method') in filter:
+'method') in filterList:
 continue
 elif valtype == "sip.enumtype":
-if ConfigVarTypeStrings.index('class') in filter:
+if ConfigVarTypeStrings.index('class') in filterList:
 continue
-elif ConfigVarTypeStrings.index('instance') in filter:
+elif ConfigVarTypeStrings.index('instance') in filterList:
 continue
 if (not valtypestr.startswith('type ') and
 valtypename not in
 ["ndarray", "MultiValueDict", "array"]):
 try:
 # Strip 'instance' to be equal with Python 3
 if valtype == "instancemethod":
 valtype = "method"
-if ConfigVarTypeStrings.index(valtype) in filter:
+if ConfigVarTypeStrings.index(valtype) in filterList:
 continue
 except ValueError:
 if valtype == "classobj":
 if ConfigVarTypeStrings.index(
-'instance') in filter:
+'instance') in filterList:
 continue
 elif valtype == "sip.methoddescriptor":
 if ConfigVarTypeStrings.index(
-'method') in filter:
+'method') in filterList:
 continue
 elif valtype == "sip.enumtype":
-if ConfigVarTypeStrings.index('class') in filter:
+if ConfigVarTypeStrings.index('class') in \
+filterList:
 continue
 elif not valtype.startswith("PySide") and \
-ConfigVarTypeStrings.index('other') in filter:
+(ConfigVarTypeStrings.index('other') in
+filterList):
 continue
 try:
 if valtype in ['list', 'tuple', 'dict', 'set',
 'frozenset', 'array.array']:
 localdict = self.currentThread.getFrameLocals(self.framenr)
 localCompleter = Completer(localdict).complete
 self.__getCompletionList(text, localCompleter, completions)
 except AttributeError:
 pass
-self.__getCompletionList(text, self.complete, completions)
+cf = self.currentThread.getCurrentFrame()
+frmnr = self.framenr
+while cf is not None and frmnr > 0:
+cf = cf.f_back
+frmnr -= 1
+if cf is None:
+globaldict = self.debugMod.__dict__
+else:
+globaldict = cf.f_globals
+globalCompleter = Completer(globaldict).complete
+self.__getCompletionList(text, globalCompleter, completions)
 self.sendJsonCommand("ResponseCompletion", {
 "completions": list(completions),
 "text": text,
 })
 del args[0]
 break
 else:   # unknown option
 del args[0]
 if not args:
-print("No program given. Aborting!")    # __IGNORE_WARNING__
+print("No program given. Aborting!")
+# __IGNORE_WARNING_M801__
 else:
 if not self.noencoding:
 self.__coding = self.defaultCoding
 self.startProgInDebugger(args, wd, host, port,
 exceptions=exceptions,
 if not self.noencoding:
 self.__coding = self.defaultCoding
 self.connectDebugger(port, remoteAddress, redirect)
 self.__interact()
 else:
-print("No network port given. Aborting...")     # __IGNORE_WARNING__
+print("No network port given. Aborting...")
+# __IGNORE_WARNING_M801__
 def fork(self):
 """
 Public method implementing a fork routine deciding which branch
 to follow.
 if pid == 0:
 # child
 if not self.fork_child:
 sys.settrace(None)
 sys.setprofile(None)
-self.sessionClose(0)
+self.sessionClose(False)
 else:
 # parent
 if self.fork_child:
 sys.settrace(None)
 sys.setprofile(None)
-self.sessionClose(0)
+self.sessionClose(False)
 return pid
 def close(self, fd):
 """
 Public method implementing a close method as a replacement for

Mercurial Repositories > eric / file comparison

comparison: DebugClients/Python/DebugClientBase.py

DebugClients/Python/DebugClientBase.py