File indexing completed on 2024-04-21 12:11:07

 /*
  * XDebug Debugger Support
  *
  * Copyright 2009 Niko Sams <niko.sams@gmail.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public
  * License along with this program; if not, write to the
  * Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "debugsession.h"
 
 #include <QTime>
 #include <QTcpSocket>
 #include <QTcpServer>
 #include <QFile>
 
 #include <QDebug>
 #include <KLocalizedString>
 
 #include <interfaces/ilaunchconfiguration.h>
 #include <debugger/util/pathmappings.h>
 
 #include "connection.h"
 #include "breakpointcontroller.h"
 #include "framestackmodel.h"
 #include "variablecontroller.h"
 #include "launchconfig.h"
 #include "debuggerdebug.h"
 
 namespace XDebug {
 DebugSession::DebugSession()
     : KDevelop::IDebugSession()
     , m_breakpointController(new BreakpointController(this))
     , m_variableController(new VariableController(this))
     , m_frameStackModel(new FrameStackModel(this))
     , m_server(nullptr)
     , m_connection(nullptr)
     , m_launchConfiguration(nullptr)
     , m_acceptMultipleConnections(false)
 {
 }
 
 DebugSession::~DebugSession()
 {
     emit finished();
 }
 
 void DebugSession::setLaunchConfiguration(KDevelop::ILaunchConfiguration* cfg)
 {
     m_launchConfiguration = cfg;
 }
 
 void DebugSession::setAcceptMultipleConnections(bool v)
 {
     m_acceptMultipleConnections = v;
 }
 
 bool DebugSession::listenForConnection(QString& error)
 {
     Q_ASSERT(!m_server);
     m_server = new QTcpServer(this);
     qCDebug(KDEV_PHP_DEBUGGER);
     int remotePortSetting = m_launchConfiguration->config().readEntry("RemotePort", 9000);
     if (m_server->listen(QHostAddress::Any, remotePortSetting)) {
         connect(m_server, &QTcpServer::newConnection, this, &DebugSession::incomingConnection);
         // avoid 'debug launch' button
         stateChanged(ActiveState);
     } else {
         error = i18n("Opening port %1 failed: %2.", remotePortSetting, m_server->errorString());
         qCWarning(KDEV_PHP_DEBUGGER) << "Error" << m_server->errorString();
         delete m_server;
         m_server = nullptr;
         return false;
     }
     return m_server->isListening();
 }
 
 void DebugSession::closeServer()
 {
     if (m_server) {
         m_server->close();
         m_server->deleteLater();
         m_server = nullptr;
     }
 }
 
 void DebugSession::incomingConnection()
 {
     qCDebug(KDEV_PHP_DEBUGGER);
     QTcpSocket* client = m_server->nextPendingConnection();
 
     if (m_connection) {
         m_connection->disconnect();
         m_connection->deleteLater();
         m_connection = nullptr;
     }
 
     m_connection = new Connection(client, this);
     connect(m_connection, &Connection::output, this, &DebugSession::output);
     connect(m_connection, &Connection::outputLine, this, &DebugSession::outputLine);
     connect(m_connection, &Connection::stateChanged, this, &DebugSession::stateChanged);
     connect(m_connection, &Connection::stateChanged, this, &DebugSession::_stateChanged);
     connect(m_connection, &Connection::currentPositionChanged,this, &DebugSession::currentPositionChanged);
     connect(m_connection, &Connection::closed, this,  &DebugSession::connectionClosed);
 
     if (!m_acceptMultipleConnections) {
         closeServer();
     }
 }
 
 void DebugSession::connectionClosed()
 {
     Q_ASSERT(sender() == m_connection);
 
     if (m_acceptMultipleConnections && m_server && m_server->isListening() 
        ) {
         // clear variable widget
         emit stateChanged(NotStartedState);
         // avoid 'debug launch' button
         emit stateChanged(ActiveState);
     } else {
         m_connection->setState(DebugSession::EndedState);
     }
     m_connection->deleteLater();
     m_connection = nullptr;
 }
 
 void DebugSession::_stateChanged(KDevelop::IDebugSession::DebuggerState state)
 {
     qCDebug(KDEV_PHP_DEBUGGER) << state;
     if (state == StartingState) {
         run();
     } else if (state == PausedState) {
         raiseEvent(program_state_changed);
     } else if (state == StoppingState) {
         m_connection->sendCommand("stop");
     } else if (state == EndedState) {
         raiseEvent(debugger_exited);
         emit finished();
     }
 }
 
 DebugSession::DebuggerState DebugSession::state() const
 {
     if (!m_connection) {
         return NotStartedState;
     }
     return m_connection->currentState();
 }
 
 void DebugSession::run()
 {
     Q_ASSERT(m_connection);
     m_connection->sendCommand("run");
     m_connection->setState(ActiveState);
 }
 
 void DebugSession::stepOut()
 {
     Q_ASSERT(m_connection);
     m_connection->sendCommand("step_out");
     m_connection->setState(ActiveState);
 }
 
 void DebugSession::stepOverInstruction()
 {
 }
 
 void DebugSession::stepInto()
 {
     Q_ASSERT(m_connection);
     m_connection->sendCommand("step_into");
     m_connection->setState(ActiveState);
 }
 
 void DebugSession::stepIntoInstruction()
 {
 }
 
 void DebugSession::stepOver()
 {
     Q_ASSERT(m_connection);
     m_connection->sendCommand("step_over");
     m_connection->setState(ActiveState);
 }
 
 void DebugSession::jumpToCursor()
 {
 }
 
 void DebugSession::runToCursor()
 {
 }
 
 void DebugSession::interruptDebugger()
 {
 }
 
 void DebugSession::stopDebugger()
 {
     closeServer();
     // finish debugger when no connection active
     if ( state() == DebugSession::NotStartedState && !m_connection ) {
         stateChanged(DebugSession::EndedState);
         emit finished();
     } else {
         m_connection->sendCommand("stop");
     }
 }
 
 void DebugSession::killDebuggerNow()
 {
     closeServer();
     if (m_connection) {
         m_connection->close();
     } else {
         emit stateChanged(EndedState);
         emit finished();
     }
 }
 
 void DebugSession::restartDebugger()
 {
 }
 void DebugSession::eval(QByteArray source)
 {
     Q_ASSERT(m_connection);
     m_connection->sendCommand("eval", QStringList(), source);
 }
 
 bool DebugSession::waitForFinished(int msecs)
 {
     QTime stopWatch;
     stopWatch.start();
     if (!waitForState(DebugSession::StoppingState, msecs)) {
         return false;
     }
     if (msecs != -1) {
         msecs = msecs - stopWatch.elapsed();
     }
     return true;
 }
 
 bool DebugSession::waitForState(KDevelop::IDebugSession::DebuggerState state, int msecs)
 {
     if (!m_connection) {
         return false;
     }
     if (m_connection->currentState() == state) {
         return true;
     }
     QTime stopWatch;
     stopWatch.start();
     if (!waitForConnected(msecs)) {
         return false;
     }
     while (m_connection->currentState() != state) {
         if (!m_connection) {
             return false;
         }
         if (!m_connection->socket()) {
             return false;
         }
         if (!m_connection->socket()->isOpen()) {
             return false;
         }
         m_connection->socket()->waitForReadyRead(100);
         if (msecs != -1 && stopWatch.elapsed() > msecs) {
             return false;
         }
     }
     return true;
 }
 
 bool DebugSession::waitForConnected(int msecs)
 {
     if (!m_connection) {
         Q_ASSERT(m_server);
         if (!m_server->waitForNewConnection(msecs)) {
             return false;
         }
     }
     Q_ASSERT(m_connection);
     Q_ASSERT(m_connection->socket());
     return m_connection->socket()->waitForConnected(msecs);
 }
 
 Connection* DebugSession::connection()
 {
     return m_connection;
 }
 
 bool DebugSession::restartAvaliable() const
 {
     //not supported at all by xdebug
     return false;
 }
 
 KDevelop::IBreakpointController* DebugSession::breakpointController() const
 {
     return m_breakpointController;
 }
 
 KDevelop::IVariableController* DebugSession::variableController() const
 {
     return m_variableController;
 }
 
 KDevelop::IFrameStackModel* DebugSession::frameStackModel() const
 {
     return m_frameStackModel;
 }
 
 QPair<QUrl, int> DebugSession::convertToLocalUrl(const QPair<QUrl, int>& remoteUrl) const
 {
     Q_ASSERT(m_launchConfiguration);
     QPair<QUrl, int> ret = remoteUrl;
     ret.first = KDevelop::PathMappings::convertToLocalUrl(m_launchConfiguration->config(), remoteUrl.first);
     return ret;
 }
 
 QPair<QUrl, int> DebugSession::convertToRemoteUrl(const QPair<QUrl, int>& localUrl) const
 {
     Q_ASSERT(m_launchConfiguration);
     QPair<QUrl, int> ret = localUrl;
     ret.first = KDevelop::PathMappings::convertToRemoteUrl(m_launchConfiguration->config(), localUrl.first);
     return ret;
 }
 
 void DebugSession::currentPositionChanged(const QUrl& url, int line)
 {
     setCurrentPosition(url, line, QString());
 }
 }