eric: comparison src/eric7/Debugger/DebuggerInterfacePython.py

-:c2ae0dd2021a
+:983477114d3c
 self.passive = passive
 self.process = None
 self.__startedVenv = ""
 self.queue = []
-self.__master = None
+self.__mainDebugger = None
 self.__connections = {}
 self.__pendingConnections = []
 self.__inShutdown = False
 # set default values for capabilities of clients
 """
 if sock in self.__pendingConnections:
 self.__connections[debuggerId] = sock
 self.__pendingConnections.remove(sock)
-if self.__master is None:
+if self.__mainDebugger is None:
-self.__master = debuggerId
+self.__mainDebugger = debuggerId
 # Get the remote clients capabilities
 self.remoteCapabilities(debuggerId)
 self.debugServer.signalClientDebuggerId(debuggerId)
-if debuggerId == self.__master:
+if debuggerId == self.__mainDebugger:
 self.__flush()
-self.debugServer.masterClientConnected()
+self.debugServer.mainClientConnected()
 self.debugServer.initializeClient(debuggerId)
-# perform auto-continue except for master
+# perform auto-continue except for main
 if (
-debuggerId != self.__master
+debuggerId != self.__mainDebugger
 and self.__autoContinue
 and not self.__isStepCommand
 ):
 self.__autoContinued.append(debuggerId)
 QTimer.singleShot(0, lambda: self.remoteContinue(debuggerId))
 @type QTcpSocket
 """
 for debuggerId in self.__connections:
 if self.__connections[debuggerId] is sock:
 del self.__connections[debuggerId]
-if debuggerId == self.__master:
+if debuggerId == self.__mainDebugger:
-self.__master = None
+self.__mainDebugger = None
 if debuggerId in self.__autoContinued:
 self.__autoContinued.remove(debuggerId)
 if not self.__inShutdown:
 with contextlib.suppress(RuntimeError):
 # can be ignored during a shutdown
 def __flush(self):
 """
 Private slot to flush the queue.
 """
-if self.__master:
+if self.__mainDebugger:
 # Send commands that were waiting for the connection.
 for cmd in self.queue:
-self.__writeJsonCommandToSocket(cmd, self.__connections[self.__master])
+self.__writeJsonCommandToSocket(
+cmd, self.__connections[self.__mainDebugger]
+)
 self.queue = []
 def shutdown(self):
 """
 Public method to cleanly shut down.
 It closes our sockets and shuts down the debug clients.
 (Needed on Win OS)
 """
-if not self.__master:
+if not self.__mainDebugger:
 return
 self.__inShutdown = True
 while self.__connections:
 self.__shutdownSocket(sock)
 # reinitialize
 self.queue = []
-self.__master = None
+self.__mainDebugger = None
 def __shutdownSocket(self, sock):
 """
 Private slot to shut down a socket.
 @param env environment settings
 @type dict
 """
 self.__sendJsonCommand(
-"RequestEnvironment", {"environment": env}, self.__master
+"RequestEnvironment", {"environment": env}, self.__mainDebugger
 )
 def remoteLoad(
 self,
 fn,
 "filename": fn,
 "argv": Utilities.parseOptionString(argv),
 "traceInterpreter": traceInterpreter,
 "multiprocess": enableMultiprocess,
 },
-self.__master,
+self.__mainDebugger,
 )
 def remoteRun(self, fn, argv, wd):
 """
 Public method to load a new program to run.
 {
 "workdir": wd,
 "filename": fn,
 "argv": Utilities.parseOptionString(argv),
 },
-self.__master,
+self.__mainDebugger,
 )
 def remoteCoverage(self, fn, argv, wd, erase=False):
 """
 Public method to load a new program to collect coverage data.
 "workdir": wd,
 "filename": fn,
 "argv": Utilities.parseOptionString(argv),
 "erase": erase,
 },
-self.__master,
+self.__mainDebugger,
 )
 def remoteProfile(self, fn, argv, wd, erase=False):
 """
 Public method to load a new program to collect profiling data.
 "workdir": wd,
 "filename": fn,
 "argv": Utilities.parseOptionString(argv),
 "erase": erase,
 },
-self.__master,
+self.__mainDebugger,
 )
 def remoteStatement(self, debuggerId, stmt):
 """
 Public method to execute a Python statement.
 elif method == "ResponseThreadSet":
 self.debugServer.signalClientThreadSet(params["debuggerId"])
 elif method == "ResponseCapabilities":
 self.clientCapabilities = params["capabilities"]
-if params["debuggerId"] == self.__master:
+if params["debuggerId"] == self.__mainDebugger:
-# signal only for the master connection
+# signal only for the main connection
 self.debugServer.signalClientCapabilities(
 params["capabilities"],
 params["clientType"],
 self.__startedVenv,
 )
 elif method == "ResponseBanner":
-if params["debuggerId"] == self.__master:
+if params["debuggerId"] == self.__mainDebugger:
-# signal only for the master connection
+# signal only for the main connection
 self.debugServer.signalClientBanner(
 params["version"],
 params["platform"],
 self.__startedVenv,
 )
 params["program"],
 params["status"],
 params["message"],
 params["debuggerId"],
 )
-if params["debuggerId"] == self.__master:
+if params["debuggerId"] == self.__mainDebugger:
 self.debugServer.signalMainClientExit()
 elif method == "PassiveStartup":
 self.debugServer.passiveStartUp(
 self.translate(params["filename"], True),
 }
 cmd = json.dumps(commandDict) + "\n"
 if debuggerId and debuggerId in self.__connections:
 sock = self.__connections[debuggerId]
-elif sock is None and self.__master is not None:
+elif sock is None and self.__mainDebugger is not None:
-sock = self.__connections[self.__master]
+sock = self.__connections[self.__mainDebugger]
 if sock is not None:
 self.__writeJsonCommandToSocket(cmd, sock)
 else:
 self.queue.append(cmd)

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Debugger/DebuggerInterfacePython.py

src/eric7/Debugger/DebuggerInterfacePython.py