eric: comparison Debugger/DebugServer.py

-:512001065055
+:7fae79975686
 import Preferences
 import Utilities
-# TODO: change this to a list of debugger interfaces and unite the two Python
-#       variants because they are nearly identical
 DebuggerInterfaces = {
-"Python2": "DebuggerInterfacePython2",
+"Python": "DebuggerInterfacePython",
-"Python3": "DebuggerInterfacePython3",
 "None": "DebuggerInterfaceNone",
 }
 class DebugServer(QTcpServer):
 @param preventPassiveDebugging flag overriding the PassiveDbgEnabled
 setting (boolean)
 """
 super(DebugServer, self).__init__()
+self.__debuggerInterfaces = {}
+# the interface name is the key, a function to get the
+# registration data is the value
 self.__debuggerInterfaceRegistry = {}
 # the client language is the key, a list containing the client
-# capabilities, the list of associated file extensions, a
+# capabilities, a list of associated file extensions, a
 # function reference to create the debugger interface (see
-# __createDebuggerInterface() below) and a function to be called
+# __createDebuggerInterface() below) and the interface name is
-# to get the registration data as values
+# the value
 # create our models
 self.breakpointModel = BreakPointModel(self)
 self.watchpointModel = WatchPointModel(self)
 self.watchSpecialCreated = \
 def preferencesChanged(self):
 """
 Public slot to handle the preferencesChanged signal.
 """
-# TODO: just build a set of registry data functions and call
-#       registerDebuggerInterface with each of them
 registeredInterfaces = {}
-for language in self.__debuggerInterfaceRegistry:
+for interfaceName in self.__debuggerInterfaces:
-registeredInterfaces[language] = \
+registeredInterfaces[interfaceName] = \
-self.__debuggerInterfaceRegistry[language][-1]
+self.__debuggerInterfaces[interfaceName]
-# last entry is the registry data function
+self.__debuggerInterfaces = {}
 self.__debuggerInterfaceRegistry = {}
-for language, getRegistryData in registeredInterfaces.items():
+for interfaceName, getRegistryData in registeredInterfaces.items():
-self.registerDebuggerInterface(language, getRegistryData)
+self.registerDebuggerInterface(interfaceName, getRegistryData)
-def registerDebuggerInterface(self, name, getRegistryData):
+def registerDebuggerInterface(self, interfaceName, getRegistryData):
 """
 Public method to register a debugger interface.
-@param name name of the debugger interface
+@param interfaceName name of the debugger interface
 @type str
 @param getRegistryData reference to a function to be called
 to get the debugger interface details. This method shall
 return the client language, the client capabilities, the
 list of associated file extensions and a function reference
 to create the debugger interface (see __createDebuggerInterface())
 @type function
 """
-# TODO: remove the 'name' parameter and move the check below against
+if interfaceName in self.__debuggerInterfaces:
-#       clientLanguage
-if name in self.__debuggerInterfaceRegistry:
 E5MessageBox.warning(
 None,
 self.tr("Register Debugger Interface"),
 self.tr("""<p>The debugger interface <b>{0}</b> has already"""
 """ been registered. Ignoring this request.</p>"""))
 return
-# TODO: change getRegistryData to return a list of registry entries
+registryDataList = getRegistryData()
-clientLanguage, clientCapabilities, clientExtensions, \
+if registryDataList:
-interfaceCreator = getRegistryData()
+self.__debuggerInterfaces[interfaceName] = getRegistryData
-if clientLanguage:
+for clientLanguage, clientCapabilities, clientExtensions, \
-self.__debuggerInterfaceRegistry[clientLanguage] = \
+interfaceCreator in registryDataList:
-[clientCapabilities, clientExtensions, interfaceCreator,
+self.__debuggerInterfaceRegistry[clientLanguage] = [
-getRegistryData]
+clientCapabilities, clientExtensions, interfaceCreator,
+interfaceName]
-def unregisterDebuggerInterface(self, name):
+def unregisterDebuggerInterface(self, interfaceName):
 """
 Public method to unregister a debugger interface.
-@param name name of the debugger interface
+@param interfaceName interfaceName of the debugger interface
 @type str
 """
-# TODO: change name to a list of names
+if interfaceName in self.__debuggerInterfaces:
-if name in self.__debuggerInterfaceRegistry:
+clientLanguages = []
-del self.__debuggerInterfaceRegistry[name]
+for clientLanguage, registryData in \
+self.__debuggerInterfaceRegistry.items():
+if interfaceName == registryData[-1]:
+clientLanguages.append(clientLanguage)
+for clientLanguage in clientLanguages:
+del self.__debuggerInterfaceRegistry[clientLanguage]
+del self.__debuggerInterfaces[interfaceName]
 def __findLanguageForExtension(self, ext):
 """
 Private method to get the language associated with a file extension.
 def __registerDebuggerInterfaces(self):
 """
 Private method to register the available internal debugger interfaces.
 """
-# TODO: apply DebuggerInterfaces being a list
 for name, interface in DebuggerInterfaces.items():
 modName = "Debugger.{0}".format(interface)
 mod = __import__(modName)
 components = modName.split('.')
 for comp in components[1:]:
 mod = getattr(mod, comp)
-# TODO: remove name parameter
 self.registerDebuggerInterface(name, mod.getRegistryData)
 def getSupportedLanguages(self, shellOnly=False):
 """
 Public slot to return the supported programming languages.

Mercurial Repositories > eric / file comparison

comparison: Debugger/DebugServer.py

Debugger/DebugServer.py