hanchenye-llvm-project/lldb/tools/lldb-mi/MIDriver.h

//===-- MIDriver.h ----------------------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

//++
// File:        MIDriver.h
//
// Overview:    CMIDriver interface.
//
// Environment: Compilers:  Visual C++ 12.
//                          gcc (Ubuntu/Linaro 4.8.1-10ubuntu9) 4.8.1
//              Libraries:  See MIReadmetxt.
//
// Copyright:   None.
//--

#pragma once

// Third party headers
#include <queue>

// In-house headers:
#include "MICmnConfig.h"
#include "MICmnBase.h"
#include "MIDriverBase.h"
#include "MIDriverMgr.h"
#include "MICmnStreamStdin.h"
#include "MICmdData.h"
#include "MIUtilSingletonBase.h"

// Declarations:
class CMICmnLLDBDebugger;
class CMICmnStreamStdout;

//++ ============================================================================
// Details: MI driver implementation class. A singleton class derived from
//          LLDB SBBroadcaster class. Register the instance of *this class with
//          the CMIDriverMgr. The CMIDriverMgr sets the driver(s) of to start
//          work depending on the one selected to work. A driver can if not able
//          to handle an instruction or 'command' can pass that command onto
//          another driver object registered with the Driver Manager.
// Gotchas: None.
// Authors: Illya Rudkin 29/01/2014.
// Changes: None.
//--
class CMIDriver : public CMICmnBase,
                  public CMIDriverMgr::IDriver,
                  public CMIDriverBase,
                  public CMICmnStreamStdin::IStreamStdin,
                  public MI::ISingleton<CMIDriver>
{
    friend class MI::ISingleton<CMIDriver>;

    // Enumerations:
  public:
    //++ ----------------------------------------------------------------------
    // Details: The MI Driver has a running state which is used to help determin
    //          which specific action(s) it should take or not allow.
    //          The driver when operational and not shutting down alternates
    //          between eDriverState_RunningNotDebugging and
    //          eDriverState_RunningDebugging. eDriverState_RunningNotDebugging
    //          is normally set when a breakpoint is hit or halted.
    //          eDriverState_RunningDebugging is normally set when "exec-continue"
    //          or "exec-run" is issued.
    //--
    enum DriverState_e
    {
        eDriverState_NotRunning = 0,      // The MI Driver is not operating
        eDriverState_Initialising,        // The MI Driver is setting itself up
        eDriverState_RunningNotDebugging, // The MI Driver is operational acting on any MI commands sent to it
        eDriverState_RunningDebugging,    // The MI Driver is currently overseeing an inferior program that is running
        eDriverState_ShuttingDown,        // The MI Driver is tearing down resources and about exit
        eDriverState_count                // Always last
    };

    // Methods:
  public:
    // MI system
    bool Initialize(void);
    bool Shutdown(void);

    // MI state
    bool GetExitApplicationFlag(void) const;
    DriverState_e GetCurrentDriverState(void) const;
    bool SetDriverStateRunningNotDebugging(void);
    bool SetDriverStateRunningDebugging(void);
    void SetDriverDebuggingArgExecutable(void);
    bool IsDriverDebuggingArgExecutable(void) const;

    // MI information about itself
    const CMIUtilString &GetAppNameShort(void) const;
    const CMIUtilString &GetAppNameLong(void) const;
    const CMIUtilString &GetVersionDescription(void) const;

    // MI do work
    bool WriteMessageToLog(const CMIUtilString &vMessage);
    bool SetEnableFallThru(const bool vbYes);
    bool GetEnableFallThru(void) const;
    bool InjectMICommand(const CMIUtilString &vMICmd);
    bool HaveExecutableFileNamePathOnCmdLine(void) const;
    const CMIUtilString &GetExecutableFileNamePathOnCmdLine(void) const;

    // Overridden:
  public:
    // From CMIDriverMgr::IDriver
    virtual bool DoInitialize(void);
    virtual bool DoShutdown(void);
    virtual bool DoMainLoop(void);
    virtual void DoResizeWindow(const uint32_t vWindowSizeWsCol);
    virtual lldb::SBError DoParseArgs(const int argc, const char *argv[], FILE *vpStdOut, bool &vwbExiting);
    virtual CMIUtilString GetError(void) const;
    virtual const CMIUtilString &GetName(void) const;
    virtual lldb::SBDebugger &GetTheDebugger(void);
    virtual bool GetDriverIsGDBMICompatibleDriver(void) const;
    virtual bool SetId(const CMIUtilString &vId);
    virtual const CMIUtilString &GetId(void) const;
    // From CMIDriverBase
    virtual void SetExitApplicationFlag(const bool vbForceExit);
    virtual bool DoFallThruToAnotherDriver(const CMIUtilString &vCmd, CMIUtilString &vwErrMsg);
    virtual bool SetDriverToFallThruTo(const CMIDriverBase &vrOtherDriver);
    virtual FILE *GetStdin(void) const;
    virtual FILE *GetStdout(void) const;
    virtual FILE *GetStderr(void) const;
    virtual const CMIUtilString &GetDriverName(void) const;
    virtual const CMIUtilString &GetDriverId(void) const;
    // From CMICmnStreamStdin
    virtual bool ReadLine(const CMIUtilString &vStdInBuffer, bool &vrbYesExit);

    // Typedefs:
  private:
    typedef std::queue<CMIUtilString> QueueStdinLine_t;

    // Methods:
  private:
    /* ctor */ CMIDriver(void);
    /* ctor */ CMIDriver(const CMIDriver &);
    void operator=(const CMIDriver &);

    lldb::SBError ParseArgs(const int argc, const char *argv[], FILE *vpStdOut, bool &vwbExiting);
    bool ReadStdinLineQueue(void);
    bool DoAppQuit(void);
    bool InterpretCommand(const CMIUtilString &vTextLine);
    bool InterpretCommandThisDriver(const CMIUtilString &vTextLine, bool &vwbCmdYesValid);
    bool InterpretCommandFallThruDriver(const CMIUtilString &vTextLine, bool &vwbCmdYesValid);
    bool ExecuteCommand(const SMICmdData &vCmdData);
    bool StartWorkerThreads(void);
    bool StopWorkerThreads(void);
    bool InitClientIDEToMIDriver(void) const;
    bool InitClientIDEEclipse(void) const;
    bool QueueMICommand(const CMIUtilString &vMICmd);
    bool LocalDebugSessionStartupInjectCommands(void);

    // Overridden:
  private:
    // From CMICmnBase
    /* dtor */ virtual ~CMIDriver(void);

    // Attributes:
  private:
    static const CMIUtilString ms_constAppNameShort;
    static const CMIUtilString ms_constAppNameLong;
    static const CMIUtilString ms_constMIVersion;
    //
    bool m_bFallThruToOtherDriverEnabled; // True = yes fall through, false = do not pass on command
    CMIUtilThreadMutex m_threadMutex;
    QueueStdinLine_t m_queueStdinLine; // Producer = stdin monitor, consumer = *this driver
    bool m_bDriverIsExiting;           // True = yes, driver told to quit, false = continue working
    void *m_handleMainThread;          // *this driver is run by the main thread
    CMICmnStreamStdin &m_rStdin;
    CMICmnLLDBDebugger &m_rLldbDebugger;
    CMICmnStreamStdout &m_rStdOut;
    DriverState_e m_eCurrentDriverState;
    bool m_bHaveExecutableFileNamePathOnCmdLine; // True = Yes executable given as one of the parameters to the MI Driver, false = not found
    CMIUtilString m_strCmdLineArgExecuteableFileNamePath;
    bool m_bDriverDebuggingArgExecutable; // True = The MI Driver (MI mode) is debugging executable passed as argument, false = running via
                                          // a client i.e Eclipse
};