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 );

	// 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 );
	
// 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 );

// 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;
};