eric: comparison Debugger/DebugServer.py

-:b1ea4ea0190e
+:a6b2acd1a355
 import Preferences
 import Utilities
-DebuggerInterfaces = [
+DebuggerInterfaces = {
-"DebuggerInterfacePython",
+"Python": "DebuggerInterfacePython",
-"DebuggerInterfacePython3",
+"Python3": "DebuggerInterfacePython3",
-##    "DebuggerInterfaceRuby",
+"None": "DebuggerInterfaceNone",
-"DebuggerInterfaceNone",
+}
-]
 class DebugServer(QTcpServer):
 """
 Class implementing the debug server embedded within the IDE.
 """
 Constructor
 """
 super(DebugServer, self).__init__()
+self.__debuggerInterfaceRegistry = {}
+# the client language is the key, a list containing the client
+# capabilities, the list of associated file extensions, a
+# function reference to create the debugger interface (see
+# __createDebuggerInterface() below) and a function to be called
+# to get the registration data as values
 # create our models
 self.breakpointModel = BreakPointModel(self)
 self.watchpointModel = WatchPointModel(self)
 self.watchSpecialCreated = \
 self.tr("created", "must be same as in EditWatchpointDialog")
 def preferencesChanged(self):
 """
 Public slot to handle the preferencesChanged signal.
 """
-# TODO: eric 6.2: change this to call all registered debugger
+registeredInterfaces = {}
-#       interfaces getRegistryData() method ignoring the client
+for language in self.__debuggerInterfaceRegistry:
-#       language and update the client capabilities and client
+registeredInterfaces[language] = \
-#       associations.
+self.__debuggerInterfaceRegistry[language][-1]
-self.__registerDebuggerInterfaces()
+# last entry is the registry data function
+self.__debuggerInterfaceRegistry = {}
+for language, getRegistryData in registeredInterfaces.items():
+self.registerDebuggerInterface(language, getRegistryData)
+def registerDebuggerInterface(self, name, getRegistryData):
+"""
+Public method to register a debugger interface.
+@param name 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
+"""
+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
+clientLanguage, clientCapabilities, clientExtensions, \
+interfaceCreator = getRegistryData()
+if clientLanguage:
+self.__debuggerInterfaceRegistry[clientLanguage] = \
+[clientCapabilities, clientExtensions, interfaceCreator,
+getRegistryData]
+def unregisterDebuggerInterface(self, name):
+"""
+Private method to unregister a debugger interface.
+@param name name of the debugger interface
+@type str
+"""
+if name in self.__debuggerInterfaceRegistry:
+del self.__debuggerInterfaceRegistry[name]
+def __findLanguageForExtension(self, ext):
+"""
+Private method to get the language associated with a file extension.
+@param ext file extension
+@type str
+@return associated language
+@rtype str
+"""
+for language in self.__debuggerInterfaceRegistry:
+if ext in self.__debuggerInterfaceRegistry[language][1]:
+return language
+return ""
 def __registerDebuggerInterfaces(self):
 """
-Private method to register the available debugger interface modules.
+Private method to register the available internal debugger interfaces.
 """
-self.__clientCapabilities = {}
+for name, interface in DebuggerInterfaces.items():
-self.__clientAssociations = {}
-# TODO: eric 6.2: Add a debugger interface registry dictionary with the
-#       debugger name (language) as a key
-# TODO: eric 6.2: Add a registerDebuggerInterface() method taking a
-#       name and a getRegistryData() method. This method should be
-#       called when a debugger backend plug-in is activated.
-#       getRegistryData() 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() below
-# TODO: eric 6.2: Add an unregisterDebuggerInterface() method with a
-#       name as parameter to revert the above.
-for interface in DebuggerInterfaces:
 modName = "Debugger.{0}".format(interface)
 mod = __import__(modName)
 components = modName.split('.')
 for comp in components[1:]:
 mod = getattr(mod, comp)
-clientLanguage, clientCapabilities, clientExtensions = \
+self.registerDebuggerInterface(name, mod.getRegistryData)
-mod.getRegistryData()
-if clientLanguage:
-self.__clientCapabilities[clientLanguage] = clientCapabilities
-for extension in clientExtensions:
-if extension not in self.__clientAssociations:
-self.__clientAssociations[extension] = clientLanguage
 def getSupportedLanguages(self, shellOnly=False):
 """
 Public slot to return the supported programming languages.
 @param shellOnly flag indicating only languages supporting an
 interactive shell should be returned
 @return list of supported languages (list of strings)
 """
-languages = list(self.__clientCapabilities.keys())
+languages = list(self.__debuggerInterfaceRegistry.keys())
 try:
 languages.remove("None")
 except ValueError:
 pass    # it is not in the list
 if shellOnly:
 languages = \
 [lang for lang in languages
-if self.__clientCapabilities[lang] &
+if self.__debuggerInterfaceRegistry[lang][0] &
 DebugClientCapabilities.HasShell]
 return languages[:]
 def getExtensions(self, language):
 @param language language to get extensions for (string)
 @return tuple of extensions associated with the language
 (tuple of strings)
 """
-extensions = []
+if language in self.__debuggerInterfaceRegistry:
-for ext, lang in list(self.__clientAssociations.items()):
+return tuple(self.__debuggerInterfaceRegistry[language][1])
-if lang == language:
+else:
-extensions.append(ext)
+return tuple()
-return tuple(extensions)
 def __createDebuggerInterface(self, clientType=None):
 """
 Private slot to create the debugger interface object.
 @param clientType type of the client interface to be created (string)
 """
-# TODO: eric 6.2: make debugger interfaces be registered in order to
-# allow to implement a debugger backend as a plug-in.
 if self.lastClientType != self.clientType or clientType is not None:
 if clientType is None:
 clientType = self.clientType
-if clientType == "Python2":
+if clientType in self.__debuggerInterfaceRegistry:
-from .DebuggerInterfacePython import DebuggerInterfacePython
+self.debuggerInterface = \
-self.debuggerInterface = DebuggerInterfacePython(
+self.__debuggerInterfaceRegistry[clientType][2](
 self, self.passive)
-elif clientType == "Python3":
-from .DebuggerInterfacePython3 import DebuggerInterfacePython3
-self.debuggerInterface = DebuggerInterfacePython3(
-self, self.passive)
-elif clientType == "Ruby":
-from .DebuggerInterfaceRuby import DebuggerInterfaceRuby
-self.debuggerInterface = DebuggerInterfaceRuby(
-self, self.passive)
-elif clientType == "None":
-from .DebuggerInterfaceNone import DebuggerInterfaceNone
-self.debuggerInterface = DebuggerInterfaceNone(
-self, self.passive)
 else:
-from .DebuggerInterfaceNone import DebuggerInterfaceNone
+self.debuggerInterface = \
-self.debuggerInterface = DebuggerInterfaceNone(
+self.__debuggerInterfaceRegistry["None"][2](
 self, self.passive)
 self.clientType = "None"
 def __setClientType(self, clType):
 """
 Private method to set the client type.
 @param type debug client type (string)
 @return debug client capabilities (integer)
 """
 try:
-return self.__clientCapabilities[type]
+return self.__debuggerInterfaceRegistry[type][0]
 except KeyError:
 return 0    # no capabilities
 def getClientInterpreter(self):
 """
 try:
 if clientType:
 self.__setClientType(clientType)
 else:
 self.__setClientType(
-self.__clientAssociations[os.path.splitext(fn)[1]])
+self.__findLanguageForExtension(os.path.splitext(fn)[1]))
 except KeyError:
 self.__setClientType('Python3')    # assume it is a Python3 file
 self.startClient(False, forProject=forProject,
 runInConsole=runInConsole)
 try:
 if clientType:
 self.__setClientType(clientType)
 else:
 self.__setClientType(
-self.__clientAssociations[os.path.splitext(fn)[1]])
+self.__findLanguageForExtension(os.path.splitext(fn)[1]))
 except KeyError:
 self.__setClientType('Python3')    # assume it is a Python3 file
 self.startClient(False, forProject=forProject,
 runInConsole=runInConsole)
 try:
 if clientType:
 self.__setClientType(clientType)
 else:
 self.__setClientType(
-self.__clientAssociations[os.path.splitext(fn)[1]])
+self.__findLanguageForExtension(os.path.splitext(fn)[1]))
 except KeyError:
 self.__setClientType('Python3')    # assume it is a Python3 file
 self.startClient(False, forProject=forProject,
 runInConsole=runInConsole)
 try:
 if clientType:
 self.__setClientType(clientType)
 else:
 self.__setClientType(
-self.__clientAssociations[os.path.splitext(fn)[1]])
+self.__findLanguageForExtension(os.path.splitext(fn)[1]))
 except KeyError:
 self.__setClientType('Python3')    # assume it is a Python3 file
 self.startClient(False, forProject=forProject,
 runInConsole=runInConsole)
 try:
 if clientType:
 self.__setClientType(clientType)
 else:
 self.__setClientType(
-self.__clientAssociations[os.path.splitext(fn)[1]])
+self.__findLanguageForExtension(os.path.splitext(fn)[1]))
 except KeyError:
 self.__setClientType('Python3')    # assume it is a Python3 file
 self.startClient(False)
 self.debuggerInterface.remoteUTPrepare(
 Public method to process the client capabilities info.
 @param capabilities bitmaks with the client capabilities (integer)
 @param clientType type of the debug client (string)
 """
-self.__clientCapabilities[clientType] = capabilities
+self.__debuggerInterfaceRegistry[clientType][0] = capabilities
 self.clientCapabilities.emit(capabilities, clientType)
 def signalClientCompletionList(self, completionList, text):
 """
 Public method to process the client auto completion info.

Mercurial Repositories > eric / file comparison

comparison: Debugger/DebugServer.py

Debugger/DebugServer.py