/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */

#include "DebugEvent.h"

#include "CpuState.h"


// #pragma mark - DebugEvent


DebugEvent::DebugEvent(int32 eventType, team_id team,
	thread_id thread)
	:
	fEventType(eventType),
	fTeam(team),
	fThread(thread),
	fThreadStopped(false)
{
}


DebugEvent::~DebugEvent()
{
}


void
DebugEvent::SetThreadStopped(bool stopped)
{
	fThreadStopped = stopped;
}


// #pragma mark - CpuStateEvent


CpuStateEvent::CpuStateEvent(debug_debugger_message eventType, team_id team,
	thread_id thread, CpuState* state)
	:
	DebugEvent(eventType, team, thread),
	fCpuState(state)
{
	if (fCpuState != NULL)
		fCpuState->AcquireReference();
}


CpuStateEvent::~CpuStateEvent()
{
	if (fCpuState != NULL)
		fCpuState->ReleaseReference();
}


// #pragma mark - ThreadDebuggedEvent


ThreadDebuggedEvent::ThreadDebuggedEvent(team_id team, thread_id thread)
	:
	DebugEvent(B_DEBUGGER_MESSAGE_THREAD_DEBUGGED, team, thread)
{
}


// #pragma mark - DebuggerCallEvent


DebuggerCallEvent::DebuggerCallEvent(team_id team, thread_id thread,
	target_addr_t message)
	:
	DebugEvent(B_DEBUGGER_MESSAGE_DEBUGGER_CALL, team, thread),
	fMessage(message)
{
}


// #pragma mark - BreakpointHitEvent


BreakpointHitEvent::BreakpointHitEvent(team_id team, thread_id thread,
	CpuState* state)
	:
	CpuStateEvent(B_DEBUGGER_MESSAGE_BREAKPOINT_HIT, team, thread, state)
{
}


// #pragma mark - WatchpointHitEvent


WatchpointHitEvent::WatchpointHitEvent(team_id team, thread_id thread,
	CpuState* state)
	:
	CpuStateEvent(B_DEBUGGER_MESSAGE_WATCHPOINT_HIT, team, thread, state)
{
}



// #pragma mark - SingleStepEvent


SingleStepEvent::SingleStepEvent(team_id team, thread_id thread,
	CpuState* state)
	:
	CpuStateEvent(B_DEBUGGER_MESSAGE_SINGLE_STEP, team, thread, state)
{
}


// #pragma mark - ExceptionOccurredEvent


ExceptionOccurredEvent::ExceptionOccurredEvent(team_id team, thread_id thread,
	debug_exception_type exception)
	:
	DebugEvent(B_DEBUGGER_MESSAGE_EXCEPTION_OCCURRED, team, thread),
	fException(exception)
{
}


// #pragma mark - TeamDeletedEvent


TeamDeletedEvent::TeamDeletedEvent(team_id team, thread_id thread)
	:
	DebugEvent(B_DEBUGGER_MESSAGE_TEAM_DELETED, team, thread)
{
}


// #pragma mark - TeamExecEvent


TeamExecEvent::TeamExecEvent(team_id team, thread_id thread)
	:
	DebugEvent(B_DEBUGGER_MESSAGE_TEAM_EXEC, team, thread)
{
}


// #pragma mark - ThreadCreatedEvent


ThreadCreatedEvent::ThreadCreatedEvent(team_id team, thread_id thread,
	thread_id newThread)
	:
	DebugEvent(B_DEBUGGER_MESSAGE_THREAD_CREATED, team, thread),
	fNewThread(newThread)
{
}


// #pragma mark - ThreadRenamedEvent


ThreadRenamedEvent::ThreadRenamedEvent(team_id team, thread_id thread,
	thread_id renamedThread, const char* newName)
	:
	DebugEvent(DEBUGGER_MESSAGE_THREAD_RENAMED, team, thread),
	fRenamedThread(renamedThread)
{
	strlcpy(fName, newName, sizeof(fName));
}


// #pragma mark - ThreadPriorityChangedEvent


ThreadPriorityChangedEvent::ThreadPriorityChangedEvent(team_id team,
	thread_id thread, thread_id changedThread, int32 newPriority)
	:
	DebugEvent(DEBUGGER_MESSAGE_THREAD_PRIORITY_CHANGED, team, thread),
	fChangedThread(changedThread),
	fNewPriority(newPriority)
{
}


// #pragma mark - ThreadDeletedEvent


ThreadDeletedEvent::ThreadDeletedEvent(team_id team, thread_id thread)
	:
	DebugEvent(B_DEBUGGER_MESSAGE_THREAD_DELETED, team, thread)
{
}


// #pragma mark - ImageCreatedEvent


ImageCreatedEvent::ImageCreatedEvent(team_id team, thread_id thread,
	const ImageInfo& info)
	:
	DebugEvent(B_DEBUGGER_MESSAGE_IMAGE_CREATED, team, thread),
	fInfo(info)
{
}


// #pragma mark - ImageDeletedEvent


ImageDeletedEvent::ImageDeletedEvent(team_id team, thread_id thread,
	const ImageInfo& info)
	:
	DebugEvent(B_DEBUGGER_MESSAGE_IMAGE_DELETED, team, thread),
	fInfo(info)
{
}


// #pragma mark - PostSyscallEvent


PostSyscallEvent::PostSyscallEvent(team_id team, thread_id thread,
	const SyscallInfo& info)
	:
	DebugEvent(B_DEBUGGER_MESSAGE_POST_SYSCALL, team, thread),
	fInfo(info)
{
}


// #pragma mark - HandedOverEvent


HandedOverEvent::HandedOverEvent(team_id team, thread_id thread,
	thread_id causingThread)
	:
	DebugEvent(B_DEBUGGER_MESSAGE_HANDED_OVER, team, thread),
	fCausingThread(causingThread)
{
}


// #pragma mark - SignalReceivedEvent


SignalReceivedEvent::SignalReceivedEvent(team_id team, thread_id thread,
	const SignalInfo& info)
	:
	DebugEvent(B_DEBUGGER_MESSAGE_SIGNAL_RECEIVED, team, thread),
	fInfo(info)
{
}