haiku.git

/*
 * Copyright 2012-2016, Rene Gollent, rene@gollent.com.
 * Copyright 2012, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include "CliContext.h"

#include <AutoDeleter.h>
#include <AutoLocker.h>

#include "StackTrace.h"
#include "UserInterface.h"
#include "Value.h"
#include "ValueNodeManager.h"
#include "Variable.h"


// NOTE: This is a simple work-around for EditLine not having any kind of user
// data field. Hence in _GetPrompt() we don't have access to the context object.
// ATM only one CLI is possible in Debugger, so a static variable works well
// enough. Should that ever change, we would need a thread-safe
// EditLine* -> CliContext* map.
static CliContext* sCurrentContext;


// #pragma mark - Event


struct CliContext::Event : DoublyLinkedListLinkImpl<CliContext::Event> {
	Event(int type, ::Thread* thread = NULL, TeamMemoryBlock* block = NULL,
		ExpressionInfo* info = NULL, status_t expressionResult = B_OK,
		ExpressionResult* expressionValue = NULL)
		:
		fType(type),
		fThreadReference(thread),
		fMemoryBlockReference(block),
		fExpressionInfo(info),
		fExpressionResult(expressionResult),
		fExpressionValue(expressionValue)
	{
	}

	int Type() const
	{
		return fType;
	}

	::Thread* GetThread() const
	{
		return fThreadReference.Get();
	}

	TeamMemoryBlock* GetMemoryBlock() const
	{
		return fMemoryBlockReference.Get();
	}

	ExpressionInfo* GetExpressionInfo() const
	{
		return fExpressionInfo;
	}

	status_t GetExpressionResult() const
	{
		return fExpressionResult;
	}

	ExpressionResult* GetExpressionValue() const
	{
		return fExpressionValue.Get();
	}


private:
	int					fType;
	BReference< ::Thread>	fThreadReference;
	BReference<TeamMemoryBlock> fMemoryBlockReference;
	BReference<ExpressionInfo> fExpressionInfo;
	status_t			fExpressionResult;
	BReference<ExpressionResult> fExpressionValue;
};


// #pragma mark - CliContext


CliContext::CliContext()
	:
	BLooper("CliContext"),
	fLock("CliContext"),
	fTeam(NULL),
	fListener(NULL),
	fNodeManager(NULL),
	fEditLine(NULL),
	fHistory(NULL),
	fPrompt(NULL),
	fWaitForEventSemaphore(-1),
	fEventOccurred(0),
	fTerminating(false),
	fStoppedThread(NULL),
	fCurrentThread(NULL),
	fCurrentStackTrace(NULL),
	fCurrentStackFrameIndex(-1),
	fCurrentBlock(NULL),
	fExpressionInfo(NULL),
	fExpressionResult(B_OK),
	fExpressionValue(NULL)
{
	sCurrentContext = this;
}


CliContext::~CliContext()
{
	Cleanup();
	sCurrentContext = NULL;

	if (fWaitForEventSemaphore >= 0)
		delete_sem(fWaitForEventSemaphore);
}


status_t
CliContext::Init(::Team* team, UserInterfaceListener* listener)
{
	AutoLocker<BLocker> locker(fLock);

	fTeam = team;
	fListener = listener;

	fTeam->AddListener(this);

	status_t error = fLock.InitCheck();
	if (error != B_OK)
		return error;

	fWaitForEventSemaphore = create_sem(0, "CliContext wait for event");
	if (fWaitForEventSemaphore < 0)
		return fWaitForEventSemaphore;

	fEditLine = el_init("Debugger", stdin, stdout, stderr);
	if (fEditLine == NULL)
		return B_ERROR;

	fHistory = history_init();
	if (fHistory == NULL)
		return B_ERROR;

	HistEvent historyEvent;
	history(fHistory, &historyEvent, H_SETSIZE, 100);

	el_set(fEditLine, EL_HIST, &history, fHistory);
	el_set(fEditLine, EL_EDITOR, "emacs");
	el_set(fEditLine, EL_PROMPT, &_GetPrompt);

	fNodeManager = new(std::nothrow) ValueNodeManager();
	if (fNodeManager == NULL)
		return B_NO_MEMORY;
	fNodeManager->AddListener(this);

	fExpressionInfo = new(std::nothrow) ExpressionInfo();
	if (fExpressionInfo == NULL)
		return B_NO_MEMORY;
	fExpressionInfo->AddListener(this);

	return B_OK;
}


void
CliContext::Cleanup()
{
	AutoLocker<BLocker> locker(fLock);
	Terminating();

	if (fEditLine != NULL) {
		el_end(fEditLine);
		fEditLine = NULL;
	}

	if (fHistory != NULL) {
		history_end(fHistory);
		fHistory = NULL;
	}

	if (fTeam != NULL) {
		fTeam->RemoveListener(this);
		fTeam = NULL;
	}

	if (fNodeManager != NULL) {
		fNodeManager->ReleaseReference();
		fNodeManager = NULL;
	}

	if (fCurrentBlock != NULL) {
		fCurrentBlock->ReleaseReference();
		fCurrentBlock = NULL;
	}

	if (fExpressionInfo != NULL) {
		fExpressionInfo->ReleaseReference();
		fExpressionInfo = NULL;
	}
}


// TODO: Use the lifecycle methods of BLooper instead
void
CliContext::Terminating()
{
	AutoLocker<BLocker> locker(fLock);

	fTerminating = true;

	BMessage message(MSG_QUIT);
	PostMessage(&message);

	// TODO: Signal the input loop, should it be in PromptUser()!
}


thread_id
CliContext::CurrentThreadID() const
{
	AutoLocker<BLocker> locker(fLock);
	return fCurrentThread != NULL ? fCurrentThread->ID() : -1;
}


void
CliContext::SetCurrentThread(::Thread* thread)
{
	AutoLocker<BLocker> locker(fLock);

	if (fCurrentThread != NULL)
		fCurrentThread->ReleaseReference();

	fCurrentThread = thread;

	if (fCurrentStackTrace != NULL) {
		fCurrentStackTrace->ReleaseReference();
		fCurrentStackTrace = NULL;
		fCurrentStackFrameIndex = -1;
		fNodeManager->SetStackFrame(NULL, NULL);
	}

	if (fCurrentThread != NULL) {
		fCurrentThread->AcquireReference();
		StackTrace* stackTrace = fCurrentThread->GetStackTrace();
		// if the thread's stack trace has already been loaded,
		// set it, otherwise we'll set it when we process the thread's
		// stack trace changed event.
		if (stackTrace != NULL) {
			fCurrentStackTrace = stackTrace;
			fCurrentStackTrace->AcquireReference();
			SetCurrentStackFrameIndex(0);
		}
	}
}


void
CliContext::PrintCurrentThread()
{
	AutoLocker<BLocker> locker(fLock);
	AutoLocker< ::Team> teamLocker(fTeam);

	if (fCurrentThread != NULL) {
		printf("current thread: %" B_PRId32 " \"%s\"\n", fCurrentThread->ID(),
			fCurrentThread->Name());
	} else
		printf("no current thread\n");
}


void
CliContext::SetCurrentStackFrameIndex(int32 index)
{
	AutoLocker<BLocker> locker(fLock);

	if (fCurrentStackTrace == NULL)
		return;
	else if (index < 0 || index >= fCurrentStackTrace->CountFrames())
		return;

	fCurrentStackFrameIndex = index;

	StackFrame* frame = fCurrentStackTrace->FrameAt(index);
	if (frame != NULL)
		fNodeManager->SetStackFrame(fCurrentThread, frame);
}


status_t
CliContext::EvaluateExpression(const char* expression,
		SourceLanguage* language, target_addr_t& address)
{
	AutoLocker<BLocker> locker(fLock);
	fExpressionInfo->SetTo(expression);

	fListener->ExpressionEvaluationRequested(
		language, fExpressionInfo);
	_WaitForEvent(MSG_EXPRESSION_EVALUATED);
	if (fTerminating)
		return B_INTERRUPTED;

	BString errorMessage;
	if (fExpressionValue != NULL) {
		if (fExpressionValue->Kind() == EXPRESSION_RESULT_KIND_PRIMITIVE) {
			Value* value = fExpressionValue->PrimitiveValue();
			BVariant variantValue;
			value->ToVariant(variantValue);
			if (variantValue.Type() == B_STRING_TYPE)
				errorMessage.SetTo(variantValue.ToString());
			else
				address = variantValue.ToUInt64();
		}
	} else
		errorMessage = strerror(fExpressionResult);

	if (!errorMessage.IsEmpty()) {
		printf("Unable to evaluate expression: %s\n",
			errorMessage.String());
		return B_ERROR;
	}

	return B_OK;
}


status_t
CliContext::GetMemoryBlock(target_addr_t address, TeamMemoryBlock*& block)
{
	AutoLocker<BLocker> locker(fLock);
	if (fCurrentBlock == NULL || !fCurrentBlock->Contains(address)) {
		GetUserInterfaceListener()->InspectRequested(address, this);
		_WaitForEvent(MSG_TEAM_MEMORY_BLOCK_RETRIEVED);
		if (fTerminating)
			return B_INTERRUPTED;
	}

	block = fCurrentBlock;
	return B_OK;
}


const char*
CliContext::PromptUser(const char* prompt)
{
	fPrompt = prompt;

	int count;
	const char* line = el_gets(fEditLine, &count);

	fPrompt = NULL;

	return line;
}


void
CliContext::AddLineToInputHistory(const char* line)
{
	HistEvent historyEvent;
	history(fHistory, &historyEvent, H_ENTER, line);
}


void
CliContext::QuitSession(bool killTeam)
{
	fListener->UserInterfaceQuitRequested(
		killTeam
			? UserInterfaceListener::QUIT_OPTION_ASK_KILL_TEAM
			: UserInterfaceListener::QUIT_OPTION_ASK_RESUME_TEAM);

	WaitForEvent(MSG_QUIT);
}


void
CliContext::WaitForEvent(uint32 event)
{
	AutoLocker<BLocker> locker(fLock);
	_WaitForEvent(event);
}


void
CliContext::MessageReceived(BMessage* message)
{
	fLock.Lock();

	int32 threadID;
	message->FindInt32("thread", &threadID);

	const char* threadName;
	message->FindString("threadName", &threadName);

	switch (message->what) {
		case MSG_THREAD_ADDED:
			printf("[new thread: %" B_PRId32 " \"%s\"]\n", threadID,
				threadName);
			break;
		case MSG_THREAD_REMOVED:
			printf("[thread terminated: %" B_PRId32 " \"%s\"]\n",
				threadID, threadName);
			break;
		case MSG_THREAD_STATE_CHANGED:
		{
			AutoLocker< ::Team> locker(fTeam);
			::Thread* thread = fTeam->ThreadByID(threadID);

			if (thread->State() == THREAD_STATE_STOPPED) {
				printf("[thread stopped: %" B_PRId32 " \"%s\"]\n",
					threadID, threadName);
				fStoppedThread.SetTo(thread);
			} else {
				fStoppedThread = NULL;
			}
			break;
		}
		case MSG_THREAD_STACK_TRACE_CHANGED:
			if (fCurrentThread != NULL && threadID == fCurrentThread->ID()) {
				AutoLocker< ::Team> locker(fTeam);
				::Thread* thread = fTeam->ThreadByID(threadID);

				fCurrentStackTrace = thread->GetStackTrace();
				fCurrentStackTrace->AcquireReference();
				SetCurrentStackFrameIndex(0);
			}
			break;
		case MSG_TEAM_MEMORY_BLOCK_RETRIEVED:
		{
			TeamMemoryBlock* block = NULL;
			if (message->FindPointer("block",
					reinterpret_cast<void **>(&block)) != B_OK) {
				break;
			}

			if (fCurrentBlock != NULL) {
				fCurrentBlock->ReleaseReference();
			}

			// reference acquired in MemoryBlockRetrieved
			fCurrentBlock = block;
			break;
		}
		case MSG_EXPRESSION_EVALUATED:
		{
			status_t result;
			if (message->FindInt32("result", &result) != B_OK) {
				break;
			}

			fExpressionResult = result;

			ExpressionResult* value = NULL;
			message->FindPointer("value", reinterpret_cast<void**>(&value));

			if (fExpressionValue != NULL) {
				fExpressionValue->ReleaseReference();
			}

			// reference acquired in ExpressionEvaluated
			fExpressionValue = value;
			break;
		}
		default:
			BLooper::MessageReceived(message);
			break;
	}

	fEventOccurred = message->what;

	fLock.Unlock();

	release_sem(fWaitForEventSemaphore);
	// all of the code that was waiting on the semaphore runs
	acquire_sem(fWaitForEventSemaphore);

	fLock.Lock();
	fEventOccurred = 0;
	fLock.Unlock();
}


void
CliContext::ThreadAdded(const Team::ThreadEvent& threadEvent)
{
	BMessage message(MSG_THREAD_ADDED);
	message.AddInt32("thread", threadEvent.GetThread()->ID());
	message.AddString("threadName", threadEvent.GetThread()->Name());
	PostMessage(&message);
}


void
CliContext::ThreadRemoved(const Team::ThreadEvent& threadEvent)
{
	BMessage message(MSG_THREAD_REMOVED);
	message.AddInt32("thread", threadEvent.GetThread()->ID());
	message.AddString("threadName", threadEvent.GetThread()->Name());
	PostMessage(&message);
}


void
CliContext::ThreadStateChanged(const Team::ThreadEvent& threadEvent)
{
	BMessage message(MSG_THREAD_STATE_CHANGED);
	message.AddInt32("thread", threadEvent.GetThread()->ID());
	message.AddString("threadName", threadEvent.GetThread()->Name());
	PostMessage(&message);
}


void
CliContext::ThreadStackTraceChanged(const Team::ThreadEvent& threadEvent)
{
	if (threadEvent.GetThread()->State() != THREAD_STATE_STOPPED)
		return;

	BMessage message(MSG_THREAD_STACK_TRACE_CHANGED);
	message.AddInt32("thread", threadEvent.GetThread()->ID());
	message.AddString("threadName", threadEvent.GetThread()->Name());
	PostMessage(&message);
}


void
CliContext::ExpressionEvaluated(ExpressionInfo* info, status_t result,
	ExpressionResult* value)
{
	BMessage message(MSG_EXPRESSION_EVALUATED);
	message.AddInt32("result", result);

	if (value != NULL) {
		value->AcquireReference();
		message.AddPointer("value", value);
	}

	PostMessage(&message);
}


void
CliContext::DebugReportChanged(const Team::DebugReportEvent& event)
{
	if (event.GetFinalStatus() == B_OK) {
		printf("Successfully saved debug report to %s\n",
			event.GetReportPath());
	} else {
		fprintf(stderr, "Failed to write debug report: %s\n", strerror(
				event.GetFinalStatus()));
	}
}


void
CliContext::CoreFileChanged(const Team::CoreFileChangedEvent& event)
{
	printf("Successfully saved core file to %s\n",
		event.GetTargetPath());
}


void
CliContext::MemoryBlockRetrieved(TeamMemoryBlock* block)
{
	if (block != NULL)
		block->AcquireReference();

	BMessage message(MSG_TEAM_MEMORY_BLOCK_RETRIEVED);
	message.AddPointer("block", block);
	PostMessage(&message);
}


void
CliContext::ValueNodeChanged(ValueNodeChild* nodeChild, ValueNode* oldNode,
	ValueNode* newNode)
{
	BMessage message(MSG_VALUE_NODE_CHANGED);
	PostMessage(&message);
}


void
CliContext::ValueNodeChildrenCreated(ValueNode* node)
{
	BMessage message(MSG_VALUE_NODE_CHANGED);
	PostMessage(&message);
}


void
CliContext::ValueNodeChildrenDeleted(ValueNode* node)
{
	BMessage message(MSG_VALUE_NODE_CHANGED);
	PostMessage(&message);
}


void
CliContext::ValueNodeValueChanged(ValueNode* oldNode)
{
	BMessage message(MSG_VALUE_NODE_CHANGED);
	PostMessage(&message);
}


/*static*/ const char*
CliContext::_GetPrompt(EditLine* editLine)
{
	return sCurrentContext != NULL ? sCurrentContext->fPrompt : NULL;
}


void
CliContext::_WaitForEvent(uint32 event) {
	if (fTerminating)
		return;

	do {
		fLock.Unlock();
		while (acquire_sem(fWaitForEventSemaphore) == B_INTERRUPTED) {
		}
		fLock.Lock();
		release_sem(fWaitForEventSemaphore);
	} while (fEventOccurred != event && !fTerminating);
}