1 //===-- MIDriver.cpp --------------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // Third party headers:
11 #include "lldb/API/SBError.h"
17 #include "MICmdArgValFile.h"
18 #include "MICmdArgValString.h"
20 #include "MICmnConfig.h"
21 #include "MICmnLLDBDebugSessionInfo.h"
22 #include "MICmnLLDBDebugger.h"
24 #include "MICmnMIResultRecord.h"
25 #include "MICmnMIValueConst.h"
26 #include "MICmnResources.h"
27 #include "MICmnStreamStderr.h"
28 #include "MICmnStreamStdout.h"
29 #include "MICmnThreadMgrStd.h"
31 #include "MIUtilDebug.h"
32 #include "MIUtilSingletonHelper.h"
36 const CMIUtilString CMIDriver::ms_constMIVersion =
37 MIRSRC(IDS_MI_VERSION_DESCRIPTION_DEBUG);
39 const CMIUtilString CMIDriver::ms_constMIVersion =
40 MIRSRC(IDS_MI_VERSION_DESCRIPTION); // Matches version in resources file
43 CMIDriver::ms_constAppNameShort(MIRSRC(IDS_MI_APPNAME_SHORT));
44 const CMIUtilString CMIDriver::ms_constAppNameLong(MIRSRC(IDS_MI_APPNAME_LONG));
47 //------------------------------------------------------------------------------------
48 // Details: CMIDriver constructor.
54 CMIDriver::CMIDriver()
55 : m_bFallThruToOtherDriverEnabled(false), m_bDriverIsExiting(false),
56 m_handleMainThread(0), m_rStdin(CMICmnStreamStdin::Instance()),
57 m_rLldbDebugger(CMICmnLLDBDebugger::Instance()),
58 m_rStdOut(CMICmnStreamStdout::Instance()),
59 m_eCurrentDriverState(eDriverState_NotRunning),
60 m_bHaveExecutableFileNamePathOnCmdLine(false),
61 m_bDriverDebuggingArgExecutable(false),
62 m_bHaveCommandFileNamePathOnCmdLine(false) {}
65 //------------------------------------------------------------------------------------
66 // Details: CMIDriver destructor.
72 CMIDriver::~CMIDriver() {}
75 //------------------------------------------------------------------------------------
76 // Details: Set whether *this driver (the parent) is enabled to pass a command
78 // fall through (child) driver to interpret the command and do work
80 // (if *this driver decides it can't handle the command).
82 // Args: vbYes - (R) True = yes fall through, false = do not pass on
84 // Return: MIstatus::success - Functional succeeded.
85 // MIstatus::failure - Functional failed.
88 bool CMIDriver::SetEnableFallThru(const bool vbYes) {
89 m_bFallThruToOtherDriverEnabled = vbYes;
90 return MIstatus::success;
94 //------------------------------------------------------------------------------------
95 // Details: Get whether *this driver (the parent) is enabled to pass a command
97 // fall through (child) driver to interpret the command and do work
99 // (if *this driver decides it can't handle the command).
102 // Return: bool - True = yes fall through, false = do not pass on command.
105 bool CMIDriver::GetEnableFallThru() const {
106 return m_bFallThruToOtherDriverEnabled;
110 //------------------------------------------------------------------------------------
111 // Details: Retrieve MI's application name of itself.
114 // Return: CMIUtilString & - Text description.
117 const CMIUtilString &CMIDriver::GetAppNameShort() const {
118 return ms_constAppNameShort;
122 //------------------------------------------------------------------------------------
123 // Details: Retrieve MI's application name of itself.
126 // Return: CMIUtilString & - Text description.
129 const CMIUtilString &CMIDriver::GetAppNameLong() const {
130 return ms_constAppNameLong;
134 //------------------------------------------------------------------------------------
135 // Details: Retrieve MI's version description of itself.
138 // Return: CMIUtilString & - Text description.
141 const CMIUtilString &CMIDriver::GetVersionDescription() const {
142 return ms_constMIVersion;
146 //------------------------------------------------------------------------------------
147 // Details: Initialize setup *this driver ready for use.
150 // Return: MIstatus::success - Functional succeeded.
151 // MIstatus::failure - Functional failed.
154 bool CMIDriver::Initialize() {
155 m_eCurrentDriverState = eDriverState_Initialising;
156 m_clientUsageRefCnt++;
158 ClrErrorDescription();
161 return MIstatus::success;
163 bool bOk = MIstatus::success;
164 CMIUtilString errMsg;
166 // Initialize all of the modules we depend on
167 MI::ModuleInit<CMICmnLog>(IDS_MI_INIT_ERR_LOG, bOk, errMsg);
168 MI::ModuleInit<CMICmnStreamStdout>(IDS_MI_INIT_ERR_STREAMSTDOUT, bOk, errMsg);
169 MI::ModuleInit<CMICmnStreamStderr>(IDS_MI_INIT_ERR_STREAMSTDERR, bOk, errMsg);
170 MI::ModuleInit<CMICmnResources>(IDS_MI_INIT_ERR_RESOURCES, bOk, errMsg);
171 MI::ModuleInit<CMICmnThreadMgrStd>(IDS_MI_INIT_ERR_THREADMANAGER, bOk,
173 MI::ModuleInit<CMICmnStreamStdin>(IDS_MI_INIT_ERR_STREAMSTDIN, bOk, errMsg);
174 MI::ModuleInit<CMICmdMgr>(IDS_MI_INIT_ERR_CMDMGR, bOk, errMsg);
175 bOk &= m_rLldbDebugger.SetDriver(*this);
176 MI::ModuleInit<CMICmnLLDBDebugger>(IDS_MI_INIT_ERR_LLDBDEBUGGER, bOk, errMsg);
180 m_bInitialized = bOk;
183 const CMIUtilString msg =
184 CMIUtilString::Format(MIRSRC(IDS_MI_INIT_ERR_DRIVER), errMsg.c_str());
185 SetErrorDescription(msg);
186 return MIstatus::failure;
189 m_eCurrentDriverState = eDriverState_RunningNotDebugging;
195 //------------------------------------------------------------------------------------
196 // Details: Unbind detach or release resources used by *this driver.
199 // Return: MIstatus::success - Functional succeeded.
200 // MIstatus::failure - Functional failed.
203 bool CMIDriver::Shutdown() {
204 if (--m_clientUsageRefCnt > 0)
205 return MIstatus::success;
208 return MIstatus::success;
210 m_eCurrentDriverState = eDriverState_ShuttingDown;
212 ClrErrorDescription();
214 bool bOk = MIstatus::success;
215 CMIUtilString errMsg;
217 // Shutdown all of the modules we depend on
218 MI::ModuleShutdown<CMICmnLLDBDebugger>(IDS_MI_INIT_ERR_LLDBDEBUGGER, bOk,
220 MI::ModuleShutdown<CMICmdMgr>(IDS_MI_INIT_ERR_CMDMGR, bOk, errMsg);
221 MI::ModuleShutdown<CMICmnStreamStdin>(IDS_MI_INIT_ERR_STREAMSTDIN, bOk,
223 MI::ModuleShutdown<CMICmnThreadMgrStd>(IDS_MI_INIT_ERR_THREADMANAGER, bOk,
225 MI::ModuleShutdown<CMICmnResources>(IDS_MI_INIT_ERR_RESOURCES, bOk, errMsg);
226 MI::ModuleShutdown<CMICmnStreamStderr>(IDS_MI_INIT_ERR_STREAMSTDERR, bOk,
228 MI::ModuleShutdown<CMICmnStreamStdout>(IDS_MI_INIT_ERR_STREAMSTDOUT, bOk,
230 MI::ModuleShutdown<CMICmnLog>(IDS_MI_INIT_ERR_LOG, bOk, errMsg);
233 SetErrorDescriptionn(MIRSRC(IDS_MI_SHUTDOWN_ERR), errMsg.c_str());
236 m_eCurrentDriverState = eDriverState_NotRunning;
242 //------------------------------------------------------------------------------------
243 // Details: Work function. Client (the driver's user) is able to append their
245 // in to the MI's Log trace file.
247 // Args: vMessage - (R) Client's text message.
248 // Return: MIstatus::success - Functional succeeded.
249 // MIstatus::failure - Functional failed.
252 bool CMIDriver::WriteMessageToLog(const CMIUtilString &vMessage) {
254 msg = CMIUtilString::Format(MIRSRC(IDS_MI_CLIENT_MSG), vMessage.c_str());
255 return m_pLog->Write(msg, CMICmnLog::eLogVerbosity_ClientMsg);
259 //------------------------------------------------------------------------------------
260 // Details: CDriverMgr calls *this driver initialize setup ready for use.
263 // Return: MIstatus::success - Functional succeeded.
264 // MIstatus::failure - Functional failed.
267 bool CMIDriver::DoInitialize() { return CMIDriver::Instance().Initialize(); }
270 //------------------------------------------------------------------------------------
271 // Details: CDriverMgr calls *this driver to unbind detach or release resources
276 // Return: MIstatus::success - Functional succeeded.
277 // MIstatus::failure - Functional failed.
280 bool CMIDriver::DoShutdown() { return CMIDriver::Instance().Shutdown(); }
283 //------------------------------------------------------------------------------------
284 // Details: Retrieve the name for *this driver.
287 // Return: CMIUtilString & - Driver name.
290 const CMIUtilString &CMIDriver::GetName() const {
291 const CMIUtilString &rName = GetAppNameLong();
292 const CMIUtilString &rVsn = GetVersionDescription();
293 static CMIUtilString strName =
294 CMIUtilString::Format("%s %s", rName.c_str(), rVsn.c_str());
300 //------------------------------------------------------------------------------------
301 // Details: Retrieve *this driver's last error condition.
304 // Return: CMIUtilString - Text description.
307 CMIUtilString CMIDriver::GetError() const { return GetErrorDescription(); }
310 //------------------------------------------------------------------------------------
311 // Details: Call *this driver to return it's debugger.
314 // Return: lldb::SBDebugger & - LLDB debugger object reference.
317 lldb::SBDebugger &CMIDriver::GetTheDebugger() {
318 return m_rLldbDebugger.GetTheDebugger();
322 //------------------------------------------------------------------------------------
323 // Details: Specify another driver *this driver can call should this driver not
325 // to handle the client data input. DoFallThruToAnotherDriver() makes
328 // Args: vrOtherDriver - (R) Reference to another driver object.
329 // Return: MIstatus::success - Functional succeeded.
330 // MIstatus::failure - Functional failed.
333 bool CMIDriver::SetDriverToFallThruTo(const CMIDriverBase &vrOtherDriver) {
334 m_pDriverFallThru = const_cast<CMIDriverBase *>(&vrOtherDriver);
336 return m_pDriverFallThru->SetDriverParent(*this);
340 //------------------------------------------------------------------------------------
341 // Details: Proxy function CMIDriverMgr IDriver interface implementation. *this
343 // implementation called from here to match the existing function name
345 // original LLDB driver class (the extra indirection is not necessarily
347 // Check the arguments that were passed to this program to make sure
349 // valid and to get their argument values (if any).
351 // Args: argc - (R) An integer that contains the count of arguments
353 // argv. The argc parameter is always greater than
355 // argv - (R) An array of null-terminated strings representing
357 // arguments entered by the user of the program. By
359 // argv[0] is the command with which the program is
361 // vpStdOut - (R) Pointer to a standard output stream.
362 // vwbExiting - (W) True = *this want to exit, Reasons: help,
364 // version information only.
365 // False = Continue to work, start debugger i.e.
368 // Return: lldb::SBError - LLDB current error status.
371 lldb::SBError CMIDriver::DoParseArgs(const int argc, const char *argv[],
372 FILE *vpStdOut, bool &vwbExiting) {
373 return ParseArgs(argc, argv, vpStdOut, vwbExiting);
377 //------------------------------------------------------------------------------------
378 // Details: Check the arguments that were passed to this program to make sure
380 // valid and to get their argument values (if any). The following are
382 // that are only handled by *this driver:
383 // --executable <file>
384 // --source <file> or -s <file>
386 // The application's options --interpreter and --executable in code act
388 // The --executable is necessary to differentiate whether the MI Driver
390 // used by a client (e.g. Eclipse) or from the command line. Eclipse
392 // --interpreter and also passes additional arguments which can be
394 // executable if called from the command line. Using --executable tells
396 // it is being called from the command line and to prepare to launch
398 // argument for a debug session. Using --interpreter on the command
400 // issue additional commands to initialise a debug session.
401 // Option --synchronous disables an asynchronous mode in the lldb-mi driver.
403 // Args: argc - (R) An integer that contains the count of arguments
405 // argv. The argc parameter is always greater than
407 // argv - (R) An array of null-terminated strings representing
409 // arguments entered by the user of the program. By
411 // argv[0] is the command with which the program is
413 // vpStdOut - (R) Pointer to a standard output stream.
414 // vwbExiting - (W) True = *this want to exit, Reasons: help,
416 // version information only.
417 // False = Continue to work, start debugger i.e.
420 // Return: lldb::SBError - LLDB current error status.
423 lldb::SBError CMIDriver::ParseArgs(const int argc, const char *argv[],
424 FILE *vpStdOut, bool &vwbExiting) {
425 lldb::SBError errStatus;
426 const bool bHaveArgs(argc >= 2);
428 // *** Add any args handled here to GetHelpOnCmdLineArgOptions() ***
430 // CODETAG_MIDRIVE_CMD_LINE_ARG_HANDLING
431 // Look for the command line options
432 bool bHaveExecutableFileNamePath = false;
433 bool bHaveExecutableLongOption = false;
436 // Search right to left to look for filenames
437 for (MIint i = argc - 1; i > 0; i--) {
438 const CMIUtilString strArg(argv[i]);
439 const CMICmdArgValFile argFile;
441 // Check for a filename
442 if (argFile.IsFilePath(strArg) ||
443 CMICmdArgValString(true, false, true).IsStringArg(strArg)) {
444 // Is this the command file for the '-s' or '--source' options?
445 const CMIUtilString strPrevArg(argv[i - 1]);
446 if (strPrevArg == "-s" || strPrevArg == "--source") {
447 m_strCmdLineArgCommandFileNamePath = strArg;
448 m_bHaveCommandFileNamePathOnCmdLine = true;
449 i--; // skip '-s' on the next loop
452 // Else, must be the executable
453 bHaveExecutableFileNamePath = true;
454 m_strCmdLineArgExecuteableFileNamePath = strArg;
455 m_bHaveExecutableFileNamePathOnCmdLine = true;
457 // Report error if no command file was specified for the '-s' or
458 // '--source' options
459 else if (strArg == "-s" || strArg == "--source") {
461 const CMIUtilString errMsg = CMIUtilString::Format(
462 MIRSRC(IDS_CMD_ARGS_ERR_VALIDATION_MISSING_INF), strArg.c_str());
463 errStatus.SetErrorString(errMsg.c_str());
466 // This argument is also checked for in CMIDriverMgr::ParseArgs()
467 else if (strArg == "--executable") // Used to specify that
468 // there is executable
469 // argument also on the
471 { // See fn description.
472 bHaveExecutableLongOption = true;
473 } else if (strArg == "--synchronous") {
474 CMICmnLLDBDebugSessionInfo::Instance().GetDebugger().SetAsync(false);
479 if (bHaveExecutableFileNamePath && bHaveExecutableLongOption) {
480 SetDriverDebuggingArgExecutable();
487 //------------------------------------------------------------------------------------
488 // Details: A client can ask if *this driver is GDB/MI compatible.
491 // Return: True - GBD/MI compatible LLDB front end.
492 // False - Not GBD/MI compatible LLDB front end.
495 bool CMIDriver::GetDriverIsGDBMICompatibleDriver() const { return true; }
498 //------------------------------------------------------------------------------------
499 // Details: Start worker threads for the driver.
502 // Return: MIstatus::success - Functional succeeded.
503 // MIstatus::failure - Functional failed.
506 bool CMIDriver::StartWorkerThreads() {
507 bool bOk = MIstatus::success;
509 // Grab the thread manager
510 CMICmnThreadMgrStd &rThreadMgr = CMICmnThreadMgrStd::Instance();
512 // Start the event polling thread
513 if (bOk && !rThreadMgr.ThreadStart<CMICmnLLDBDebugger>(m_rLldbDebugger)) {
514 const CMIUtilString errMsg = CMIUtilString::Format(
515 MIRSRC(IDS_THREADMGR_ERR_THREAD_FAIL_CREATE),
516 CMICmnThreadMgrStd::Instance().GetErrorDescription().c_str());
517 SetErrorDescription(errMsg);
518 return MIstatus::failure;
525 //------------------------------------------------------------------------------------
526 // Details: Stop worker threads for the driver.
529 // Return: MIstatus::success - Functional succeeded.
530 // MIstatus::failure - Functional failed.
533 bool CMIDriver::StopWorkerThreads() {
534 CMICmnThreadMgrStd &rThreadMgr = CMICmnThreadMgrStd::Instance();
535 return rThreadMgr.ThreadAllTerminate();
539 //------------------------------------------------------------------------------------
540 // Details: Call this function puts *this driver to work.
541 // This function is used by the application's main thread.
544 // Return: MIstatus::success - Functional succeeded.
545 // MIstatus::failure - Functional failed.
548 bool CMIDriver::DoMainLoop() {
549 if (!InitClientIDEToMIDriver()) // Init Eclipse IDE
551 SetErrorDescriptionn(MIRSRC(IDS_MI_INIT_ERR_CLIENT_USING_DRIVER));
552 return MIstatus::failure;
555 if (!StartWorkerThreads())
556 return MIstatus::failure;
558 bool bOk = MIstatus::success;
560 if (HaveExecutableFileNamePathOnCmdLine()) {
561 if (!LocalDebugSessionStartupExecuteCommands()) {
562 SetErrorDescription(MIRSRC(IDS_MI_INIT_ERR_LOCAL_DEBUG_SESSION));
563 bOk = MIstatus::failure;
567 // App is not quitting currently
570 // Handle source file
571 if (m_bHaveCommandFileNamePathOnCmdLine) {
572 const bool bAsyncMode = false;
573 ExecuteCommandFile(bAsyncMode);
576 // While the app is active
577 while (bOk && !m_bExitApp) {
578 CMIUtilString errorText;
579 const char *pCmd = m_rStdin.ReadLine(errorText);
580 if (pCmd != nullptr) {
581 CMIUtilString lineText(pCmd);
582 if (!lineText.empty()) {
583 // Check that the handler thread is alive (otherwise we stuck here)
584 assert(CMICmnLLDBDebugger::Instance().ThreadIsActive());
587 // Lock Mutex before processing commands so that we don't disturb an
590 CMIUtilThreadLock lock(
591 CMICmnLLDBDebugSessionInfo::Instance().GetSessionMutex());
592 bOk = InterpretCommand(lineText);
595 // Draw prompt if desired
596 bOk = bOk && CMICmnStreamStdout::WritePrompt();
598 // Wait while the handler thread handles incoming events
599 CMICmnLLDBDebugger::Instance().WaitForHandleEvent();
604 // Signal that the application is shutting down
607 // Close and wait for the workers to stop
610 return MIstatus::success;
614 //------------------------------------------------------------------------------------
615 // Details: Set things in motion, set state etc that brings *this driver (and
617 // application) to a tidy shutdown.
618 // This function is used by the application's main thread.
621 // Return: MIstatus::success - Functional succeeded.
622 // MIstatus::failure - Functional failed.
625 bool CMIDriver::DoAppQuit() {
626 bool bYesQuit = true;
628 // Shutdown stuff, ready app for exit
630 CMIUtilThreadLock lock(m_threadMutex);
631 m_bDriverIsExiting = true;
638 //------------------------------------------------------------------------------------
639 // Details: *this driver passes text commands to a fall through driver is it
641 // understand them (the LLDB driver).
642 // This function is used by the application's main thread.
644 // Args: vTextLine - (R) Text data representing a possible command.
645 // vwbCmdYesValid - (W) True = Command valid, false = command not
647 // Return: MIstatus::success - Functional succeeded.
648 // MIstatus::failure - Functional failed.
651 bool CMIDriver::InterpretCommandFallThruDriver(const CMIUtilString &vTextLine,
652 bool &vwbCmdYesValid) {
654 MIunused(vwbCmdYesValid);
656 // ToDo: Implement when less urgent work to be done or decide remove as not
658 // bool bOk = MIstatus::success;
659 // bool bCmdNotUnderstood = true;
660 // if( bCmdNotUnderstood && GetEnableFallThru() )
662 // CMIUtilString errMsg;
663 // bOk = DoFallThruToAnotherDriver( vStdInBuffer, errMsg );
666 // errMsg = errMsg.StripCREndOfLine();
667 // errMsg = errMsg.StripCRAll();
668 // const CMIDriverBase * pOtherDriver = GetDriverToFallThruTo();
669 // const char * pName = pOtherDriver->GetDriverName().c_str();
670 // const char * pId = pOtherDriver->GetDriverId().c_str();
671 // const CMIUtilString msg( CMIUtilString::Format( MIRSRC(
672 // IDS_DRIVER_ERR_FALLTHRU_DRIVER_ERR ), pName, pId, errMsg.c_str() )
674 // m_pLog->WriteMsg( msg );
678 // vwbCmdYesValid = bOk;
679 // CMIUtilString strNot;
680 // if( vwbCmdYesValid)
681 // strNot = CMIUtilString::Format( "%s ", MIRSRC( IDS_WORD_NOT ) );
682 // const CMIUtilString msg( CMIUtilString::Format( MIRSRC(
683 // IDS_FALLTHRU_DRIVER_CMD_RECEIVED ), vTextLine.c_str(), strNot.c_str() ) );
684 // m_pLog->WriteLog( msg );
686 return MIstatus::success;
690 //------------------------------------------------------------------------------------
691 // Details: Retrieve the name for *this driver.
694 // Return: CMIUtilString & - Driver name.
697 const CMIUtilString &CMIDriver::GetDriverName() const { return GetName(); }
700 //------------------------------------------------------------------------------------
701 // Details: Get the unique ID for *this driver.
704 // Return: CMIUtilString & - Text description.
707 const CMIUtilString &CMIDriver::GetDriverId() const { return GetId(); }
710 //------------------------------------------------------------------------------------
711 // Details: This function allows *this driver to call on another driver to
713 // should this driver not be able to handle the client data input.
714 // SetDriverToFallThruTo() specifies the fall through to driver.
715 // Check the error message if the function returns a failure.
717 // Args: vCmd - (R) Command instruction to interpret.
718 // vwErrMsg - (W) Status description on command failing.
719 // Return: MIstatus::success - Command succeeded.
720 // MIstatus::failure - Command failed.
723 bool CMIDriver::DoFallThruToAnotherDriver(const CMIUtilString &vCmd,
724 CMIUtilString &vwErrMsg) {
725 bool bOk = MIstatus::success;
727 CMIDriverBase *pOtherDriver = GetDriverToFallThruTo();
728 if (pOtherDriver == nullptr)
731 return pOtherDriver->DoFallThruToAnotherDriver(vCmd, vwErrMsg);
735 //------------------------------------------------------------------------------------
736 // Details: *this driver provides a file stream to other drivers on which *this
738 // write's out to and they read as expected input. *this driver is
740 // through commands to the (child) pass through assigned driver.
741 // Type: Overrdidden.
743 // Return: FILE * - Pointer to stream.
746 FILE *CMIDriver::GetStdin() const {
747 // Note this fn is called on CMIDriverMgr register driver so stream has to be
748 // available before *this driver has been initialized! Flaw?
750 // This very likely to change later to a stream that the pass thru driver
751 // will read and we write to give it 'input'
756 //------------------------------------------------------------------------------------
757 // Details: *this driver provides a file stream to other pass through assigned
759 // so they know what to write to.
762 // Return: FILE * - Pointer to stream.
765 FILE *CMIDriver::GetStdout() const {
766 // Note this fn is called on CMIDriverMgr register driver so stream has to be
767 // available before *this driver has been initialized! Flaw?
769 // Do not want to pass through driver to write to stdout
774 //------------------------------------------------------------------------------------
775 // Details: *this driver provides a error file stream to other pass through
777 // so they know what to write to.
780 // Return: FILE * - Pointer to stream.
783 FILE *CMIDriver::GetStderr() const {
784 // Note this fn is called on CMIDriverMgr register driver so stream has to be
785 // available before *this driver has been initialized! Flaw?
787 // This very likely to change later to a stream that the pass thru driver
788 // will write to and *this driver reads from to pass on the CMICmnLog object
793 //------------------------------------------------------------------------------------
794 // Details: Set a unique ID for *this driver. It cannot be empty.
796 // Args: vId - (R) Text description.
797 // Return: MIstatus::success - Functional succeeded.
798 // MIstatus::failure - Functional failed.
801 bool CMIDriver::SetId(const CMIUtilString &vId) {
803 SetErrorDescriptionn(MIRSRC(IDS_DRIVER_ERR_ID_INVALID), GetName().c_str(),
805 return MIstatus::failure;
809 return MIstatus::success;
813 //------------------------------------------------------------------------------------
814 // Details: Get the unique ID for *this driver.
817 // Return: CMIUtilString & - Text description.
820 const CMIUtilString &CMIDriver::GetId() const { return m_strDriverId; }
823 //------------------------------------------------------------------------------------
824 // Details: Interpret the text data and match against current commands to see if
826 // is a match. If a match then the command is issued and actioned on.
828 // text data if not understood by *this driver is past on to the Fall
831 // This function is used by the application's main thread.
833 // Args: vTextLine - (R) Text data representing a possible command.
834 // Return: MIstatus::success - Functional succeeded.
835 // MIstatus::failure - Functional failed.
838 bool CMIDriver::InterpretCommand(const CMIUtilString &vTextLine) {
839 const bool bNeedToRebroadcastStopEvent =
840 m_rLldbDebugger.CheckIfNeedToRebroadcastStopEvent();
841 bool bCmdYesValid = false;
842 bool bOk = InterpretCommandThisDriver(vTextLine, bCmdYesValid);
843 if (bOk && !bCmdYesValid)
844 bOk = InterpretCommandFallThruDriver(vTextLine, bCmdYesValid);
846 if (bNeedToRebroadcastStopEvent)
847 m_rLldbDebugger.RebroadcastStopEvent();
853 //------------------------------------------------------------------------------------
854 // Details: Helper function for CMIDriver::InterpretCommandThisDriver.
855 // Convert a CLI command to MI command (just wrap any CLI command
856 // into "<tokens>-interpreter-exec command \"<CLI command>\"").
858 // Args: vTextLine - (R) Text data representing a possible command.
859 // Return: CMIUtilString - The original MI command or converted CLI command.
860 // MIstatus::failure - Functional failed.
864 CMIDriver::WrapCLICommandIntoMICommand(const CMIUtilString &vTextLine) const {
865 // Tokens contain following digits
866 static const CMIUtilString digits("0123456789");
868 // Consider an algorithm on the following example:
869 // 001-file-exec-and-symbols "/path/to/file"
871 // 1. Skip a command token
873 // 001-file-exec-and-symbols "/path/to/file"
874 // 001target create "/path/to/file"
875 // ^ -- command starts here (in both cases)
876 // Also possible case when command not found:
878 // ^ -- i.e. only tokens are present (or empty string at all)
879 const size_t nCommandOffset = vTextLine.find_first_not_of(digits);
881 // 2. Check if command is empty
883 // 001-file-exec-and-symbols "/path/to/file"
884 // 001target create "/path/to/file"
885 // ^ -- command not empty (in both cases)
888 // ^ -- command wasn't found
889 const bool bIsEmptyCommand = (nCommandOffset == CMIUtilString::npos);
891 // 3. Check and exit if it isn't a CLI command
893 // 001-file-exec-and-symbols "/path/to/file"
895 // ^ -- it isn't CLI command (in both cases)
897 // 001target create "/path/to/file"
898 // ^ -- it's CLI command
899 const bool bIsCliCommand =
900 !bIsEmptyCommand && (vTextLine.at(nCommandOffset) != '-');
904 // 4. Wrap CLI command to make it MI-compatible
906 // 001target create "/path/to/file"
908 const std::string vToken(vTextLine.begin(),
909 vTextLine.begin() + nCommandOffset);
910 // 001target create "/path/to/file"
911 // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -- CLI command
912 const CMIUtilString vCliCommand(std::string(vTextLine, nCommandOffset));
914 // 5. Escape special characters and embed the command in a string
915 // Result: it looks like -- target create \"/path/to/file\".
916 const std::string vShieldedCliCommand(vCliCommand.AddSlashes());
918 // 6. Turn the CLI command into an MI command, as in:
919 // 001-interpreter-exec command "target create \"/path/to/file\""
921 // ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ -- wrapper
922 // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -- shielded
924 return CMIUtilString::Format("%s-interpreter-exec command \"%s\"",
925 vToken.c_str(), vShieldedCliCommand.c_str());
929 //------------------------------------------------------------------------------------
930 // Details: Interpret the text data and match against current commands to see if
932 // is a match. If a match then the command is issued and actioned on.
934 // command cannot be found to match then vwbCmdYesValid is set to false
936 // nothing else is done here.
937 // This function is used by the application's main thread.
939 // Args: vTextLine - (R) Text data representing a possible command.
940 // vwbCmdYesValid - (W) True = Command valid, false = command not
942 // Return: MIstatus::success - Functional succeeded.
943 // MIstatus::failure - Functional failed.
946 bool CMIDriver::InterpretCommandThisDriver(const CMIUtilString &vTextLine,
947 bool &vwbCmdYesValid) {
948 // Convert any CLI commands into MI commands
949 const CMIUtilString vMITextLine(WrapCLICommandIntoMICommand(vTextLine));
951 vwbCmdYesValid = false;
952 bool bCmdNotInCmdFactor = false;
954 CMICmdMgr &rCmdMgr = CMICmdMgr::Instance();
955 if (!rCmdMgr.CmdInterpret(vMITextLine, vwbCmdYesValid, bCmdNotInCmdFactor,
957 return MIstatus::failure;
959 if (vwbCmdYesValid) {
960 // For debugging only
961 // m_pLog->WriteLog( cmdData.strMiCmdAll.c_str() );
963 return ExecuteCommand(cmdData);
966 // Check for escape character, may be cursor control characters
967 // This code is not necessary for application operation, just want to keep
969 // has been given to the driver to try and interpret.
970 if (vMITextLine.at(0) == 27) {
971 CMIUtilString logInput(MIRSRC(IDS_STDIN_INPUT_CTRL_CHARS));
972 for (MIuint i = 0; i < vMITextLine.length(); i++) {
973 logInput += CMIUtilString::Format("%d ", vMITextLine.at(i));
975 m_pLog->WriteLog(logInput);
976 return MIstatus::success;
979 // Write to the Log that a 'command' was not valid.
980 // Report back to the MI client via MI result record.
981 CMIUtilString strNotInCmdFactory;
982 if (bCmdNotInCmdFactor)
983 strNotInCmdFactory = CMIUtilString::Format(
984 MIRSRC(IDS_DRIVER_CMD_NOT_IN_FACTORY), cmdData.strMiCmd.c_str());
985 const CMIUtilString strNot(
986 CMIUtilString::Format("%s ", MIRSRC(IDS_WORD_NOT)));
987 const CMIUtilString msg(CMIUtilString::Format(
988 MIRSRC(IDS_DRIVER_CMD_RECEIVED), vMITextLine.c_str(), strNot.c_str(),
989 strNotInCmdFactory.c_str()));
990 const CMICmnMIValueConst vconst = CMICmnMIValueConst(msg);
991 const CMICmnMIValueResult valueResult("msg", vconst);
992 const CMICmnMIResultRecord miResultRecord(
993 cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Error,
995 const bool bOk = m_rStdOut.WriteMIResponse(miResultRecord.GetString());
997 // Proceed to wait for or execute next command
1002 //------------------------------------------------------------------------------------
1003 // Details: Having previously had the potential command validated and found
1005 // get the command executed.
1006 // This function is used by the application's main thread.
1008 // Args: vCmdData - (RW) Command meta data.
1009 // Return: MIstatus::success - Functional succeeded.
1010 // MIstatus::failure - Functional failed.
1013 bool CMIDriver::ExecuteCommand(const SMICmdData &vCmdData) {
1014 CMICmdMgr &rCmdMgr = CMICmdMgr::Instance();
1015 return rCmdMgr.CmdExecute(vCmdData);
1019 //------------------------------------------------------------------------------------
1020 // Details: Set the MI Driver's exit application flag. The application checks
1022 // after every stdin line is read so the exit may not be instantaneous.
1023 // If vbForceExit is false the MI Driver queries its state and
1025 // should exit or continue operating depending on that running state.
1026 // This is related to the running state of the MI driver.
1027 // Type: Overridden.
1032 void CMIDriver::SetExitApplicationFlag(const bool vbForceExit) {
1034 CMIUtilThreadLock lock(m_threadMutex);
1039 // CODETAG_DEBUG_SESSION_RUNNING_PROG_RECEIVED_SIGINT_PAUSE_PROGRAM
1040 // Did we receive a SIGINT from the client during a running debug program, if
1041 // so then SIGINT is not to be taken as meaning kill the MI driver application
1042 // but halt the inferior program being debugged instead
1043 if (m_eCurrentDriverState == eDriverState_RunningDebugging) {
1044 InterpretCommand("-exec-interrupt");
1052 //------------------------------------------------------------------------------------
1053 // Details: Get the MI Driver's exit exit application flag.
1054 // This is related to the running state of the MI driver.
1057 // Return: bool - True = MI Driver is shutting down, false = MI driver is
1061 bool CMIDriver::GetExitApplicationFlag() const { return m_bExitApp; }
1064 //------------------------------------------------------------------------------------
1065 // Details: Get the current running state of the MI Driver.
1068 // Return: DriverState_e - The current running state of the application.
1071 CMIDriver::DriverState_e CMIDriver::GetCurrentDriverState() const {
1072 return m_eCurrentDriverState;
1076 //------------------------------------------------------------------------------------
1077 // Details: Set the current running state of the MI Driver to running and
1081 // Return: MIstatus::success - Functionality succeeded.
1082 // MIstatus::failure - Functionality failed.
1083 // Return: DriverState_e - The current running state of the application.
1086 bool CMIDriver::SetDriverStateRunningNotDebugging() {
1087 // CODETAG_DEBUG_SESSION_RUNNING_PROG_RECEIVED_SIGINT_PAUSE_PROGRAM
1089 if (m_eCurrentDriverState == eDriverState_RunningNotDebugging)
1090 return MIstatus::success;
1092 // Driver cannot be in the following states to set
1093 // eDriverState_RunningNotDebugging
1094 switch (m_eCurrentDriverState) {
1095 case eDriverState_NotRunning:
1096 case eDriverState_Initialising:
1097 case eDriverState_ShuttingDown: {
1098 SetErrorDescription(MIRSRC(IDS_DRIVER_ERR_DRIVER_STATE_ERROR));
1099 return MIstatus::failure;
1101 case eDriverState_RunningDebugging:
1102 case eDriverState_RunningNotDebugging:
1104 case eDriverState_count:
1105 SetErrorDescription(
1106 CMIUtilString::Format(MIRSRC(IDS_CODE_ERR_INVALID_ENUMERATION_VALUE),
1107 "SetDriverStateRunningNotDebugging()"));
1108 return MIstatus::failure;
1111 // Driver must be in this state to set eDriverState_RunningNotDebugging
1112 if (m_eCurrentDriverState != eDriverState_RunningDebugging) {
1113 SetErrorDescription(MIRSRC(IDS_DRIVER_ERR_DRIVER_STATE_ERROR));
1114 return MIstatus::failure;
1117 m_eCurrentDriverState = eDriverState_RunningNotDebugging;
1119 return MIstatus::success;
1123 //------------------------------------------------------------------------------------
1124 // Details: Set the current running state of the MI Driver to running and
1126 // a debug session. The driver's state must in the state running and in
1128 // debug session to set this new state.
1130 // Return: MIstatus::success - Functionality succeeded.
1131 // MIstatus::failure - Functionality failed.
1132 // Return: DriverState_e - The current running state of the application.
1135 bool CMIDriver::SetDriverStateRunningDebugging() {
1136 // CODETAG_DEBUG_SESSION_RUNNING_PROG_RECEIVED_SIGINT_PAUSE_PROGRAM
1138 if (m_eCurrentDriverState == eDriverState_RunningDebugging)
1139 return MIstatus::success;
1141 // Driver cannot be in the following states to set
1142 // eDriverState_RunningDebugging
1143 switch (m_eCurrentDriverState) {
1144 case eDriverState_NotRunning:
1145 case eDriverState_Initialising:
1146 case eDriverState_ShuttingDown: {
1147 SetErrorDescription(MIRSRC(IDS_DRIVER_ERR_DRIVER_STATE_ERROR));
1148 return MIstatus::failure;
1150 case eDriverState_RunningDebugging:
1151 case eDriverState_RunningNotDebugging:
1153 case eDriverState_count:
1154 SetErrorDescription(
1155 CMIUtilString::Format(MIRSRC(IDS_CODE_ERR_INVALID_ENUMERATION_VALUE),
1156 "SetDriverStateRunningDebugging()"));
1157 return MIstatus::failure;
1160 // Driver must be in this state to set eDriverState_RunningDebugging
1161 if (m_eCurrentDriverState != eDriverState_RunningNotDebugging) {
1162 SetErrorDescription(MIRSRC(IDS_DRIVER_ERR_DRIVER_STATE_ERROR));
1163 return MIstatus::failure;
1166 m_eCurrentDriverState = eDriverState_RunningDebugging;
1168 return MIstatus::success;
1172 //------------------------------------------------------------------------------------
1173 // Details: Prepare the client IDE so it will start working/communicating with
1178 // Return: MIstatus::success - Functionality succeeded.
1179 // MIstatus::failure - Functionality failed.
1182 bool CMIDriver::InitClientIDEToMIDriver() const {
1183 // Put other IDE init functions here
1184 return InitClientIDEEclipse();
1188 //------------------------------------------------------------------------------------
1189 // Details: The IDE Eclipse when debugging locally expects "(gdb)\n" character
1190 // sequence otherwise it refuses to communicate and times out. This
1192 // sent to Eclipse before anything else.
1195 // Return: MIstatus::success - Functionality succeeded.
1196 // MIstatus::failure - Functionality failed.
1199 bool CMIDriver::InitClientIDEEclipse() const {
1200 return CMICmnStreamStdout::WritePrompt();
1204 //------------------------------------------------------------------------------------
1205 // Details: Ask *this driver whether it found an executable in the MI Driver's
1207 // arguments which to open and debug. If so instigate commands to set
1209 // session for that executable.
1212 // Return: bool - True = True = Yes executable given as one of the parameters
1215 // False = not found.
1218 bool CMIDriver::HaveExecutableFileNamePathOnCmdLine() const {
1219 return m_bHaveExecutableFileNamePathOnCmdLine;
1223 //------------------------------------------------------------------------------------
1224 // Details: Retrieve from *this driver executable file name path to start a
1226 // with (if present see HaveExecutableFileNamePathOnCmdLine()).
1229 // Return: CMIUtilString & - Executeable file name path or empty string.
1232 const CMIUtilString &CMIDriver::GetExecutableFileNamePathOnCmdLine() const {
1233 return m_strCmdLineArgExecuteableFileNamePath;
1237 //------------------------------------------------------------------------------------
1238 // Details: Execute commands (by injecting them into the stdin line queue
1240 // other code to set up the MI Driver such that is can take the
1242 // argument passed on the command and create a debug session for it.
1245 // Return: MIstatus::success - Functionality succeeded.
1246 // MIstatus::failure - Functionality failed.
1249 bool CMIDriver::LocalDebugSessionStartupExecuteCommands() {
1250 const CMIUtilString strCmd(CMIUtilString::Format(
1251 "-file-exec-and-symbols \"%s\"",
1252 m_strCmdLineArgExecuteableFileNamePath.AddSlashes().c_str()));
1253 bool bOk = CMICmnStreamStdout::TextToStdout(strCmd);
1254 bOk = bOk && InterpretCommand(strCmd);
1255 bOk = bOk && CMICmnStreamStdout::WritePrompt();
1260 //------------------------------------------------------------------------------------
1261 // Details: Set the MI Driver into "its debugging an executable passed as an
1263 // mode as against running via a client like Eclipse.
1269 void CMIDriver::SetDriverDebuggingArgExecutable() {
1270 m_bDriverDebuggingArgExecutable = true;
1274 //------------------------------------------------------------------------------------
1275 // Details: Retrieve the MI Driver state indicating if it is operating in "its
1277 // an executable passed as an argument" mode as against running via a
1285 bool CMIDriver::IsDriverDebuggingArgExecutable() const {
1286 return m_bDriverDebuggingArgExecutable;
1290 //------------------------------------------------------------------------------------
1291 // Details: Execute commands from command source file in specified mode, and
1292 // set exit-flag if needed.
1294 // Args: vbAsyncMode - (R) True = execute commands in asynchronous
1295 // mode, false = otherwise.
1296 // Return: MIstatus::success - Function succeeded.
1297 // MIstatus::failure - Function failed.
1300 bool CMIDriver::ExecuteCommandFile(const bool vbAsyncMode) {
1301 std::ifstream ifsStartScript(m_strCmdLineArgCommandFileNamePath.c_str());
1302 if (!ifsStartScript.is_open()) {
1303 const CMIUtilString errMsg(
1304 CMIUtilString::Format(MIRSRC(IDS_UTIL_FILE_ERR_OPENING_FILE_UNKNOWN),
1305 m_strCmdLineArgCommandFileNamePath.c_str()));
1306 SetErrorDescription(errMsg.c_str());
1307 const bool bForceExit = true;
1308 SetExitApplicationFlag(bForceExit);
1309 return MIstatus::failure;
1312 // Switch lldb to synchronous mode
1313 CMICmnLLDBDebugSessionInfo &rSessionInfo(
1314 CMICmnLLDBDebugSessionInfo::Instance());
1315 const bool bAsyncSetting = rSessionInfo.GetDebugger().GetAsync();
1316 rSessionInfo.GetDebugger().SetAsync(vbAsyncMode);
1318 // Execute commands from file
1319 bool bOk = MIstatus::success;
1320 CMIUtilString strCommand;
1321 while (!m_bExitApp && std::getline(ifsStartScript, strCommand)) {
1323 bOk = CMICmnStreamStdout::TextToStdout(strCommand);
1325 // Skip if it's a comment or empty line
1326 if (strCommand.empty() || strCommand[0] == '#')
1329 // Execute if no error
1331 CMIUtilThreadLock lock(rSessionInfo.GetSessionMutex());
1332 bOk = InterpretCommand(strCommand);
1335 // Draw the prompt after command will be executed (if enabled)
1336 bOk = bOk && CMICmnStreamStdout::WritePrompt();
1338 // Exit if there is an error
1340 const bool bForceExit = true;
1341 SetExitApplicationFlag(bForceExit);
1345 // Wait while the handler thread handles incoming events
1346 CMICmnLLDBDebugger::Instance().WaitForHandleEvent();
1349 // Switch lldb back to initial mode
1350 rSessionInfo.GetDebugger().SetAsync(bAsyncSetting);
1356 //------------------------------------------------------------------------------------
1357 // Details: Gets called when lldb-mi gets a signal. Stops the process if it was
1361 // Args: signal that was delivered
1365 void CMIDriver::DeliverSignal(int signal) {
1366 if (signal == SIGINT &&
1367 (m_eCurrentDriverState == eDriverState_RunningDebugging))
1368 InterpretCommand("-exec-interrupt");