eric: comparison Debugger/DebugServer.py

-:96232974dcdb
+:645c12de6b0c
 Module implementing the debug server.
 """
 from __future__ import unicode_literals
 try:
-str = unicode    # __IGNORE_WARNING__
+str = unicode
-except (NameError):
+except NameError:
 pass
 import os
 from PyQt4.QtCore import pyqtSignal, QModelIndex
 received from the client
 @signal passiveDebugStarted(str, bool) emitted after the debug client has
 connected in passive debug mode
 @signal clientGone(bool) emitted if the client went away (planned or
 unplanned)
+@signal clientInterpreterChanged(str) emitted to signal a change of the
+client interpreter
 @signal utPrepared(nrTests, exc_type, exc_value) emitted after the client
 has loaded a unittest suite
 @signal utFinished() emitted after the client signalled the end of the
 unittest
 @signal utStartTest(testname, testdocu) emitted after the client has
 clientWatchConditionError = pyqtSignal(str)
 clientRawInput = pyqtSignal(str, bool)
 clientBanner = pyqtSignal(str, str, str)
 clientCapabilities = pyqtSignal(int, str)
 clientCompletionList = pyqtSignal(list, str)
+clientInterpreterChanged = pyqtSignal(str)
 utPrepared = pyqtSignal(int, str, str)
 utStartTest = pyqtSignal(str, str)
 utStopTest = pyqtSignal()
 utTestFailed = pyqtSignal(str, str, str)
 utTestErrored = pyqtSignal(str, str, str)
 # create our models
 self.breakpointModel = BreakPointModel(self)
 self.watchpointModel = WatchPointModel(self)
 self.watchSpecialCreated = \
-self.trUtf8("created", "must be same as in EditWatchpointDialog")
+self.tr("created", "must be same as in EditWatchpointDialog")
 self.watchSpecialChanged = \
-self.trUtf8("changed", "must be same as in EditWatchpointDialog")
+self.tr("changed", "must be same as in EditWatchpointDialog")
 self.networkInterface = Preferences.getDebugger("NetworkInterface")
 if self.networkInterface == "all":
 hostAddress = QHostAddress("0.0.0.0")  # QHostAddress.Any)
 elif self.networkInterface == "allv6":
 self.debuggerInterface = None
 self.debugging = False
 self.running = False
 self.clientProcess = None
+self.clientInterpreter = ""
 self.clientType = \
 Preferences.Prefs.settings.value('DebugClient/Type')
 if self.clientType is None:
 import sys
 if sys.version_info[0] == 2:
 self.lastClientType = ''
 self.__autoClearShell = False
 self.clientClearBreak.connect(self.__clientClearBreakPoint)
 self.clientClearWatch.connect(self.__clientClearWatchPoint)
-self.newConnection[()].connect(self.__newConnection)
+self.newConnection.connect(self.__newConnection)
 self.breakpointModel.rowsAboutToBeRemoved.connect(
 self.__deleteBreakPoints)
 self.breakpointModel.dataAboutToBeChanged.connect(
 self.__breakPointDataAboutToBeChanged)
 self.__createDebuggerInterface()
 if forProject:
 project = e5App().getObject("Project")
 if not project.isDebugPropertiesLoaded():
-self.clientProcess, isNetworked = \
+self.clientProcess, isNetworked, clientInterpreter = \
 self.debuggerInterface.startRemote(self.serverPort(),
 runInConsole)
 else:
-self.clientProcess, isNetworked = \
+self.clientProcess, isNetworked, clientInterpreter = \
 self.debuggerInterface.startRemoteForProject(
 self.serverPort(), runInConsole)
 else:
-self.clientProcess, isNetworked = \
+self.clientProcess, isNetworked, clientInterpreter = \
 self.debuggerInterface.startRemote(
 self.serverPort(), runInConsole)
 if self.clientProcess:
 self.clientProcess.readyReadStandardError.connect(
 self.__clientProcessError)
 self.clientProcess.readyReadStandardOutput.connect(
 self.__clientProcessOutput)
-if not isNetworked:
+# Perform actions necessary, if client type has changed
-# the client is connected through stdin and stdout
+if self.lastClientType != self.clientType:
-# Perform actions necessary, if client type has changed
+self.lastClientType = self.clientType
-if self.lastClientType != self.clientType:
+self.remoteBanner()
-self.lastClientType = self.clientType
+elif self.__autoClearShell:
-self.remoteBanner()
+self.__autoClearShell = False
-elif self.__autoClearShell:
+self.remoteBanner()
-self.__autoClearShell = False
+else:
-self.remoteBanner()
+if clType and self.lastClientType:
+self.__setClientType(self.lastClientType)
-self.debuggerInterface.flush()
 else:
 self.__createDebuggerInterface("None")
+clientInterpreter = ""
+if clientInterpreter != self.clientInterpreter:
+self.clientInterpreter = clientInterpreter
+self.clientInterpreterChanged.emit(clientInterpreter)
 def __clientProcessOutput(self):
 """
 Private slot to process client output received via stdout.
 """
 try:
 return self.__clientCapabilities[type]
 except KeyError:
 return 0    # no capabilities
+def getClientInterpreter(self):
+"""
+Public method to get the interpreter of the debug client.
+@return interpreter of the debug client (string)
+"""
+return self.clientInterpreter
 def __newConnection(self):
 """
 Private slot to handle a new connection.
 """
 sock = self.nextPendingConnection()
 peerAddress = sock.peerAddress().toString()
 if peerAddress not in Preferences.getDebugger("AllowedHosts"):
 # the peer is not allowed to connect
 res = E5MessageBox.yesNo(
 None,
-self.trUtf8("Connection from illegal host"),
+self.tr("Connection from illegal host"),
-self.trUtf8(
+self.tr(
 """<p>A connection was attempted by the illegal host"""
 """ <b>{0}</b>. Accept this connection?</p>""")
 .format(peerAddress),
 icon=E5MessageBox.Warning)
 if not res:
 self.clientExit.emit(int(status))
 if Preferences.getDebugger("AutomaticReset"):
 self.startClient(False)
 if self.passive:
 self.__createDebuggerInterface("None")
-self.signalClientOutput(self.trUtf8('\nNot connected\n'))
+self.signalClientOutput(self.tr('\nNot connected\n'))
 self.signalClientStatement(False)
 self.running = False
 def signalClientClearBreak(self, filename, lineno):
 """
 Public method to handle a passive debug connection.
 @param fn filename of the debugged script (string)
 @param exc flag to enable exception reporting of the IDE (boolean)
 """
-print(self.trUtf8("Passive debug connection received"))
+print(self.tr("Passive debug connection received"))
 self.passiveClientExited = False
 self.debugging = True
 self.running = True
 self.__restoreBreakpoints()
 self.__restoreWatchpoints()
 """
 Private method to shut down a passive debug connection.
 """
 self.passiveClientExited = True
 self.shutdownServer()
-print(self.trUtf8("Passive debug connection closed"))
+print(self.tr("Passive debug connection closed"))
 def __restoreBreakpoints(self):
 """
 Private method to restore the breakpoints after a restart.
 """

Mercurial Repositories > eric / file comparison

comparison: Debugger/DebugServer.py

Debugger/DebugServer.py