File indexing completed on 2024-05-05 05:51:31

 /**
  * Description: Common interface for GDB and DAP clients
  *
  *  SPDX-FileCopyrightText: 2022 Héctor Mesa Jiménez <wmj.py@gmx.com>
  *
  *  SPDX-License-Identifier: LGPL-2.0-or-later
  */
 
 #include "backend.h"
 #include "dapbackend.h"
 #include "gdbbackend.h"
 #include <KLocalizedString>
 #include <KMessageBox>
 
 Backend::Backend(QObject *parent)
     : BackendInterface(parent)
     , m_debugger(nullptr)
 {
 }
 
 void Backend::runDebugger(const GDBTargetConf &conf, const QStringList &ioFifos)
 {
     if (m_debugger && m_debugger->debuggerRunning()) {
         KMessageBox::error(nullptr, i18n("A debugging session is on course. Please, use re-run or stop the current session."));
         return;
     }
 
     GdbBackend *gdb;
 
     if (m_mode != GDB) {
         unbind();
         m_debugger = gdb = new GdbBackend(this);
         m_mode = GDB;
         bind();
     } else {
         gdb = qobject_cast<GdbBackend *>(m_debugger);
     }
 
     gdb->runDebugger(conf, ioFifos);
 
     if (m_displayQueryLocals) {
         gdb->slotQueryLocals(*m_displayQueryLocals);
     }
 }
 
 void Backend::runDebugger(const DAPTargetConf &conf)
 {
     if (m_debugger && m_debugger->debuggerRunning()) {
         KMessageBox::error(nullptr, i18n("A debugging session is on course. Please, use re-run or stop the current session."));
         return;
     }
 
     DapBackend *dap;
 
     unbind();
     m_debugger = dap = new DapBackend(this);
     m_mode = DAP;
     bind();
 
     dap->runDebugger(conf);
 
     if (m_displayQueryLocals) {
         dap->slotQueryLocals(*m_displayQueryLocals);
     }
 }
 
 void Backend::bind()
 {
     connect(m_debugger, &BackendInterface::debugLocationChanged, this, &BackendInterface::debugLocationChanged);
     connect(m_debugger, &BackendInterface::breakPointSet, this, &BackendInterface::breakPointSet);
     connect(m_debugger, &BackendInterface::breakPointCleared, this, &BackendInterface::breakPointCleared);
     connect(m_debugger, &BackendInterface::clearBreakpointMarks, this, &BackendInterface::clearBreakpointMarks);
     connect(m_debugger, &BackendInterface::stackFrameInfo, this, &BackendInterface::stackFrameInfo);
     connect(m_debugger, &BackendInterface::stackFrameChanged, this, &BackendInterface::stackFrameChanged);
     connect(m_debugger, &BackendInterface::threadInfo, this, &BackendInterface::threadInfo);
 
     connect(m_debugger, &BackendInterface::variableInfo, this, &BackendInterface::variableInfo);
     connect(m_debugger, &BackendInterface::variableScopeOpened, this, &BackendInterface::variableScopeOpened);
     connect(m_debugger, &BackendInterface::variableScopeClosed, this, &BackendInterface::variableScopeClosed);
 
     connect(m_debugger, &BackendInterface::outputText, this, &BackendInterface::outputText);
     connect(m_debugger, &BackendInterface::outputError, this, &BackendInterface::outputError);
     connect(m_debugger, &BackendInterface::readyForInput, this, &BackendInterface::readyForInput);
     connect(m_debugger, &BackendInterface::programEnded, this, &BackendInterface::programEnded);
     connect(m_debugger, &BackendInterface::gdbEnded, this, &BackendInterface::gdbEnded);
     connect(m_debugger, &BackendInterface::sourceFileNotFound, this, &BackendInterface::sourceFileNotFound);
     connect(m_debugger, &BackendInterface::scopesInfo, this, &BackendInterface::scopesInfo);
 
     connect(m_debugger, &BackendInterface::debuggerCapabilitiesChanged, this, &BackendInterface::debuggerCapabilitiesChanged);
 
     connect(m_debugger, &BackendInterface::debuggeeOutput, this, &BackendInterface::debuggeeOutput);
     connect(m_debugger, &BackendInterface::backendError, this, &BackendInterface::backendError);
 }
 
 void Backend::unbind()
 {
     if (!m_debugger)
         return;
     disconnect(m_debugger, nullptr, this, nullptr);
     delete m_debugger;
 }
 
 bool Backend::debuggerRunning() const
 {
     return m_debugger && m_debugger->debuggerRunning();
 }
 
 bool Backend::debuggerBusy() const
 {
     return !m_debugger || m_debugger->debuggerBusy();
 }
 
 bool Backend::hasBreakpoint(QUrl const &url, int line) const
 {
     return m_debugger && m_debugger->hasBreakpoint(url, line);
 }
 
 bool Backend::supportsMovePC() const
 {
     return m_debugger && m_debugger->supportsMovePC();
 }
 
 bool Backend::supportsRunToCursor() const
 {
     return m_debugger && m_debugger->supportsRunToCursor();
 }
 
 bool Backend::canSetBreakpoints() const
 {
     return m_debugger && m_debugger->canSetBreakpoints();
 }
 
 bool Backend::canMove() const
 {
     return m_debugger && m_debugger->canMove();
 }
 
 bool Backend::canContinue() const
 {
     return m_debugger && m_debugger->canContinue();
 }
 
 void Backend::toggleBreakpoint(QUrl const &url, int line)
 {
     if (m_debugger)
         m_debugger->toggleBreakpoint(url, line);
 }
 
 void Backend::movePC(QUrl const &url, int line)
 {
     if (m_debugger)
         m_debugger->movePC(url, line);
 }
 
 void Backend::runToCursor(QUrl const &url, int line)
 {
     if (m_debugger)
         m_debugger->runToCursor(url, line);
 }
 
 void Backend::issueCommand(QString const &cmd)
 {
     if (m_debugger)
         m_debugger->issueCommand(cmd);
 }
 
 QString Backend::targetName() const
 {
     if (m_debugger)
         return m_debugger->targetName();
     return QString();
 }
 
 void Backend::setFileSearchPaths(const QStringList &paths)
 {
     if (m_debugger)
         m_debugger->setFileSearchPaths(paths);
 }
 
 void Backend::slotInterrupt()
 {
     if (m_debugger)
         m_debugger->slotInterrupt();
 }
 
 void Backend::slotStepInto()
 {
     if (m_debugger)
         m_debugger->slotStepInto();
 }
 
 void Backend::slotStepOver()
 {
     if (m_debugger)
         m_debugger->slotStepOver();
 }
 
 void Backend::slotStepOut()
 {
     if (m_debugger)
         m_debugger->slotStepOut();
 }
 
 void Backend::slotContinue()
 {
     if (m_debugger)
         m_debugger->slotContinue();
 }
 
 void Backend::slotKill()
 {
     if (m_debugger)
         m_debugger->slotKill();
 }
 
 void Backend::slotReRun()
 {
     if (m_debugger)
         m_debugger->slotReRun();
 }
 
 QString Backend::slotPrintVariable(const QString &variable)
 {
     if (m_debugger)
         return m_debugger->slotPrintVariable(variable);
     return QString();
 }
 
 void Backend::slotQueryLocals(bool display)
 {
     if (m_debugger) {
         m_debugger->slotQueryLocals(display);
         m_displayQueryLocals = std::nullopt;
     } else {
         m_displayQueryLocals = display;
     }
 }
 
 void Backend::changeStackFrame(int index)
 {
     if (m_debugger)
         m_debugger->changeStackFrame(index);
 }
 
 void Backend::changeThread(int thread)
 {
     if (m_debugger)
         m_debugger->changeThread(thread);
 }
 
 void Backend::changeScope(int scopeId)
 {
     if (m_debugger)
         m_debugger->changeScope(scopeId);
 }
 
 #include "moc_backend.cpp"