haiku.git

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


#include "Team.h"

#include <new>

#include <AutoLocker.h>

#include "Breakpoint.h"
#include "DisassembledCode.h"
#include "FileSourceCode.h"
#include "Function.h"
#include "ImageDebugInfo.h"
#include "SignalDispositionTypes.h"
#include "SourceCode.h"
#include "SpecificImageDebugInfo.h"
#include "Statement.h"
#include "TeamDebugInfo.h"
#include "Tracing.h"
#include "Value.h"
#include "Watchpoint.h"


// #pragma mark - BreakpointByAddressPredicate


struct Team::BreakpointByAddressPredicate
	: UnaryPredicate<Breakpoint> {
	BreakpointByAddressPredicate(target_addr_t address)
		:
		fAddress(address)
	{
	}

	virtual int operator()(const Breakpoint* breakpoint) const
	{
		return -Breakpoint::CompareAddressBreakpoint(&fAddress, breakpoint);
	}

private:
	target_addr_t	fAddress;
};


// #pragma mark - WatchpointByAddressPredicate


struct Team::WatchpointByAddressPredicate
	: UnaryPredicate<Watchpoint> {
	WatchpointByAddressPredicate(target_addr_t address)
		:
		fAddress(address)
	{
	}

	virtual int operator()(const Watchpoint* watchpoint) const
	{
		return -Watchpoint::CompareAddressWatchpoint(&fAddress, watchpoint);
	}

private:
	target_addr_t	fAddress;
};


// #pragma mark - Team


Team::Team(team_id teamID, TeamMemory* teamMemory, Architecture* architecture,
	TeamDebugInfo* debugInfo, TeamTypeInformation* typeInformation)
	:
	fLock("team lock"),
	fID(teamID),
	fTeamMemory(teamMemory),
	fTypeInformation(typeInformation),
	fArchitecture(architecture),
	fDebugInfo(debugInfo),
	fStopOnImageLoad(false),
	fStopImageNameListEnabled(false),
	fDefaultSignalDisposition(SIGNAL_DISPOSITION_IGNORE)
{
	fDebugInfo->AcquireReference();
}


Team::~Team()
{
	while (UserBreakpoint* userBreakpoint = fUserBreakpoints.RemoveHead())
		userBreakpoint->ReleaseReference();

	for (int32 i = 0; Breakpoint* breakpoint = fBreakpoints.ItemAt(i); i++)
		breakpoint->ReleaseReference();

	for (int32 i = 0; Watchpoint* watchpoint = fWatchpoints.ItemAt(i); i++)
		watchpoint->ReleaseReference();

	while (Image* image = fImages.RemoveHead())
		image->ReleaseReference();

	while (Thread* thread = fThreads.RemoveHead())
		thread->ReleaseReference();

	fDebugInfo->ReleaseReference();
}


status_t
Team::Init()
{
	return fLock.InitCheck();
}


void
Team::SetName(const BString& name)
{
	fName = name;
	_NotifyTeamRenamed();
}


void
Team::AddThread(Thread* thread)
{
	fThreads.Add(thread);
	_NotifyThreadAdded(thread);
}



status_t
Team::AddThread(const ThreadInfo& threadInfo, Thread** _thread)
{
	Thread* thread = new(std::nothrow) Thread(this, threadInfo.ThreadID());
	if (thread == NULL)
		return B_NO_MEMORY;

	status_t error = thread->Init();
	if (error != B_OK) {
		delete thread;
		return error;
	}

	thread->SetName(threadInfo.Name());
	AddThread(thread);

	if (_thread != NULL)
		*_thread = thread;

	return B_OK;
}


void
Team::RemoveThread(Thread* thread)
{
	fThreads.Remove(thread);
	_NotifyThreadRemoved(thread);
}


bool
Team::RemoveThread(thread_id threadID)
{
	Thread* thread = ThreadByID(threadID);
	if (thread == NULL)
		return false;

	RemoveThread(thread);
	thread->ReleaseReference();
	return true;
}


Thread*
Team::ThreadByID(thread_id threadID) const
{
	for (ThreadList::ConstIterator it = fThreads.GetIterator();
			Thread* thread = it.Next();) {
		if (thread->ID() == threadID)
			return thread;
	}

	return NULL;
}


const ThreadList&
Team::Threads() const
{
	return fThreads;
}


status_t
Team::AddImage(const ImageInfo& imageInfo, LocatableFile* imageFile,
	Image** _image)
{
	Image* image = new(std::nothrow) Image(this, imageInfo, imageFile);
	if (image == NULL)
		return B_NO_MEMORY;

	status_t error = image->Init();
	if (error != B_OK) {
		delete image;
		return error;
	}

	if (image->Type() == B_APP_IMAGE)
		SetName(image->Name());

	fImages.Add(image);
	_NotifyImageAdded(image);

	if (_image != NULL)
		*_image = image;

	return B_OK;
}


void
Team::RemoveImage(Image* image)
{
	fImages.Remove(image);
	_NotifyImageRemoved(image);
}


bool
Team::RemoveImage(image_id imageID)
{
	Image* image = ImageByID(imageID);
	if (image == NULL)
		return false;

	RemoveImage(image);
	image->ReleaseReference();
	return true;
}


Image*
Team::ImageByID(image_id imageID) const
{
	for (ImageList::ConstIterator it = fImages.GetIterator();
			Image* image = it.Next();) {
		if (image->ID() == imageID)
			return image;
	}

	return NULL;
}


Image*
Team::ImageByAddress(target_addr_t address) const
{
	for (ImageList::ConstIterator it = fImages.GetIterator();
			Image* image = it.Next();) {
		if (image->ContainsAddress(address))
			return image;
	}

	return NULL;
}


const ImageList&
Team::Images() const
{
	return fImages;
}


void
Team::ClearImages()
{
	while (!fImages.IsEmpty())
		RemoveImage(fImages.First());
}


bool
Team::AddStopImageName(const BString& name)
{
	if (!fStopImageNames.Add(name))
		return false;

	fStopImageNames.Sort();

	NotifyStopImageNameAdded(name);
	return true;
}


void
Team::RemoveStopImageName(const BString& name)
{
	fStopImageNames.Remove(name);
	NotifyStopImageNameRemoved(name);
}


void
Team::SetStopOnImageLoad(bool enabled, bool useImageNameList)
{
	fStopOnImageLoad = enabled;
	fStopImageNameListEnabled = useImageNameList;
	NotifyStopOnImageLoadChanged(enabled, useImageNameList);
}


const BStringList&
Team::StopImageNames() const
{
	return fStopImageNames;
}


void
Team::SetDefaultSignalDisposition(int32 disposition)
{
	if (disposition != fDefaultSignalDisposition) {
		fDefaultSignalDisposition = disposition;
		NotifyDefaultSignalDispositionChanged(disposition);
	}
}


bool
Team::SetCustomSignalDisposition(int32 signal, int32 disposition)
{
	SignalDispositionMappings::iterator it = fCustomSignalDispositions.find(
		signal);
	if (it != fCustomSignalDispositions.end() && it->second == disposition)
		return true;

	try {
		fCustomSignalDispositions[signal] = disposition;
	} catch (...) {
		return false;
	}

	NotifyCustomSignalDispositionChanged(signal, disposition);

	return true;
}


void
Team::RemoveCustomSignalDisposition(int32 signal)
{
	SignalDispositionMappings::iterator it = fCustomSignalDispositions.find(
		signal);
	if (it == fCustomSignalDispositions.end())
		return;

	fCustomSignalDispositions.erase(it);

	NotifyCustomSignalDispositionRemoved(signal);
}


int32
Team::SignalDispositionFor(int32 signal) const
{
	SignalDispositionMappings::const_iterator it
		= fCustomSignalDispositions.find(signal);
	if (it != fCustomSignalDispositions.end())
		return it->second;

	return fDefaultSignalDisposition;
}


const SignalDispositionMappings&
Team::GetSignalDispositionMappings() const
{
	return fCustomSignalDispositions;
}


void
Team::ClearSignalDispositionMappings()
{
	fCustomSignalDispositions.clear();
}


bool
Team::AddBreakpoint(Breakpoint* breakpoint)
{
	if (fBreakpoints.BinaryInsert(breakpoint, &Breakpoint::CompareBreakpoints))
		return true;

	breakpoint->ReleaseReference();
	return false;
}


void
Team::RemoveBreakpoint(Breakpoint* breakpoint)
{
	int32 index = fBreakpoints.BinarySearchIndex(*breakpoint,
		&Breakpoint::CompareBreakpoints);
	if (index < 0)
		return;

	fBreakpoints.RemoveItemAt(index);
	breakpoint->ReleaseReference();
}


int32
Team::CountBreakpoints() const
{
	return fBreakpoints.CountItems();
}


Breakpoint*
Team::BreakpointAt(int32 index) const
{
	return fBreakpoints.ItemAt(index);
}


Breakpoint*
Team::BreakpointAtAddress(target_addr_t address) const
{
	return fBreakpoints.BinarySearchByKey(address,
		&Breakpoint::CompareAddressBreakpoint);
}


void
Team::GetBreakpointsInAddressRange(TargetAddressRange range,
	BObjectList<UserBreakpoint>& breakpoints) const
{
	int32 index = fBreakpoints.FindBinaryInsertionIndex(
		BreakpointByAddressPredicate(range.Start()));
	for (; Breakpoint* breakpoint = fBreakpoints.ItemAt(index); index++) {
		if (breakpoint->Address() > range.End())
			break;

		for (UserBreakpointInstanceList::ConstIterator it
				= breakpoint->UserBreakpoints().GetIterator();
			UserBreakpointInstance* instance = it.Next();) {
			breakpoints.AddItem(instance->GetUserBreakpoint());
		}
	}

	// TODO: Avoid duplicates!
}


void
Team::GetBreakpointsForSourceCode(SourceCode* sourceCode,
	BObjectList<UserBreakpoint>& breakpoints) const
{
	if (DisassembledCode* disassembledCode
			= dynamic_cast<DisassembledCode*>(sourceCode)) {
		GetBreakpointsInAddressRange(disassembledCode->StatementAddressRange(),
			breakpoints);
		return;
	}

	LocatableFile* sourceFile = sourceCode->GetSourceFile();
	if (sourceFile == NULL)
		return;

	// TODO: This can probably be optimized. Maybe by registering the user
	// breakpoints with the team and sorting them by source code.
	for (int32 i = 0; Breakpoint* breakpoint = fBreakpoints.ItemAt(i); i++) {
		UserBreakpointInstance* userBreakpointInstance
			= breakpoint->FirstUserBreakpoint();
		if (userBreakpointInstance == NULL)
			continue;

		UserBreakpoint* userBreakpoint
			= userBreakpointInstance->GetUserBreakpoint();
		if (userBreakpoint->Location().SourceFile() == sourceFile)
			breakpoints.AddItem(userBreakpoint);
	}
}


void
Team::AddUserBreakpoint(UserBreakpoint* userBreakpoint)
{
	fUserBreakpoints.Add(userBreakpoint);
	userBreakpoint->AcquireReference();
}


void
Team::RemoveUserBreakpoint(UserBreakpoint* userBreakpoint)
{
	fUserBreakpoints.Remove(userBreakpoint);
	userBreakpoint->ReleaseReference();
}


bool
Team::AddWatchpoint(Watchpoint* watchpoint)
{
	if (fWatchpoints.BinaryInsert(watchpoint, &Watchpoint::CompareWatchpoints))
		return true;

	watchpoint->ReleaseReference();
	return false;
}


void
Team::RemoveWatchpoint(Watchpoint* watchpoint)
{
	int32 index = fWatchpoints.BinarySearchIndex(*watchpoint,
		&Watchpoint::CompareWatchpoints);
	if (index < 0)
		return;

	fWatchpoints.RemoveItemAt(index);
	watchpoint->ReleaseReference();
}


int32
Team::CountWatchpoints() const
{
	return fWatchpoints.CountItems();
}


Watchpoint*
Team::WatchpointAt(int32 index) const
{
	return fWatchpoints.ItemAt(index);
}


Watchpoint*
Team::WatchpointAtAddress(target_addr_t address) const
{
	return fWatchpoints.BinarySearchByKey(address,
		&Watchpoint::CompareAddressWatchpoint);
}


void
Team::GetWatchpointsInAddressRange(TargetAddressRange range,
	BObjectList<Watchpoint>& watchpoints) const
{
	int32 index = fWatchpoints.FindBinaryInsertionIndex(
		WatchpointByAddressPredicate(range.Start()));
	for (; Watchpoint* watchpoint = fWatchpoints.ItemAt(index); index++) {
		if (watchpoint->Address() > range.End())
			break;

		watchpoints.AddItem(watchpoint);
	}
}


status_t
Team::GetStatementAtAddress(target_addr_t address, FunctionInstance*& _function,
	Statement*& _statement)
{
	TRACE_CODE("Team::GetStatementAtAddress(%#" B_PRIx64 ")\n", address);

	// get the image at the address
	Image* image = ImageByAddress(address);
	if (image == NULL) {
		TRACE_CODE("  -> no image\n");
		return B_ENTRY_NOT_FOUND;
	}

	ImageDebugInfo* imageDebugInfo = image->GetImageDebugInfo();
	if (imageDebugInfo == NULL) {
		TRACE_CODE("  -> no image debug info\n");
		return B_ENTRY_NOT_FOUND;
	}

	// get the function
	FunctionInstance* functionInstance
		= imageDebugInfo->FunctionAtAddress(address);
	if (functionInstance == NULL) {
		TRACE_CODE("  -> no function instance\n");
		return B_ENTRY_NOT_FOUND;
	}

	// If the function instance has disassembled code attached, we can get the
	// statement directly.
	if (DisassembledCode* code = functionInstance->GetSourceCode()) {
		Statement* statement = code->StatementAtAddress(address);
		if (statement == NULL)
			return B_ENTRY_NOT_FOUND;

		statement->AcquireReference();
		_statement = statement;
		_function = functionInstance;
		return B_OK;
	}

	// get the statement from the image debug info
	FunctionDebugInfo* functionDebugInfo
		= functionInstance->GetFunctionDebugInfo();
	status_t error = functionDebugInfo->GetSpecificImageDebugInfo()
		->GetStatement(functionDebugInfo, address, _statement);
	if (error != B_OK) {
		TRACE_CODE("  -> no statement from the specific image debug info\n");
		return error;
	}

	_function = functionInstance;
	return B_OK;
}


status_t
Team::GetStatementAtSourceLocation(SourceCode* sourceCode,
	const SourceLocation& location, Statement*& _statement)
{
	TRACE_CODE("Team::GetStatementAtSourceLocation(%p, (%" B_PRId32 ", %"
		B_PRId32 "))\n", sourceCode, location.Line(), location.Column());

	// If we're lucky the source code can provide us with a statement.
	if (DisassembledCode* code = dynamic_cast<DisassembledCode*>(sourceCode)) {
		Statement* statement = code->StatementAtLocation(location);
		if (statement == NULL)
			return B_ENTRY_NOT_FOUND;

		statement->AcquireReference();
		_statement = statement;
		return B_OK;
	}

	// Go the long and stony way over the source file and the team debug info.
	// get the source file for the source code
	LocatableFile* sourceFile = sourceCode->GetSourceFile();
	if (sourceFile == NULL)
		return B_ENTRY_NOT_FOUND;

	// get the function at the source location
	Function* function = fDebugInfo->FunctionAtSourceLocation(sourceFile,
		location);
	if (function == NULL)
		return B_ENTRY_NOT_FOUND;

	// Get some function instance and ask its image debug info to provide us
	// with a statement.
	FunctionInstance* functionInstance = function->FirstInstance();
	if (functionInstance == NULL)
		return B_ENTRY_NOT_FOUND;

	FunctionDebugInfo* functionDebugInfo
		= functionInstance->GetFunctionDebugInfo();
	return functionDebugInfo->GetSpecificImageDebugInfo()
		->GetStatementAtSourceLocation(functionDebugInfo, location, _statement);
}


Function*
Team::FunctionByID(FunctionID* functionID) const
{
	return fDebugInfo->FunctionByID(functionID);
}


void
Team::AddListener(Listener* listener)
{
	AutoLocker<Team> locker(this);
	fListeners.Add(listener);
}


void
Team::RemoveListener(Listener* listener)
{
	AutoLocker<Team> locker(this);
	fListeners.Remove(listener);
}


void
Team::NotifyThreadStateChanged(Thread* thread)
{
	for (ListenerList::Iterator it = fListeners.GetIterator();
			Listener* listener = it.Next();) {
		listener->ThreadStateChanged(
			ThreadEvent(TEAM_EVENT_THREAD_STATE_CHANGED, thread));
	}
}


void
Team::NotifyThreadCpuStateChanged(Thread* thread)
{
	for (ListenerList::Iterator it = fListeners.GetIterator();
			Listener* listener = it.Next();) {
		listener->ThreadCpuStateChanged(
			ThreadEvent(TEAM_EVENT_THREAD_CPU_STATE_CHANGED, thread));
	}
}


void
Team::NotifyThreadStackTraceChanged(Thread* thread)
{
	for (ListenerList::Iterator it = fListeners.GetIterator();
			Listener* listener = it.Next();) {
		listener->ThreadStackTraceChanged(
			ThreadEvent(TEAM_EVENT_THREAD_STACK_TRACE_CHANGED, thread));
	}
}


void
Team::NotifyImageDebugInfoChanged(Image* image)
{
	for (ListenerList::Iterator it = fListeners.GetIterator();
			Listener* listener = it.Next();) {
		listener->ImageDebugInfoChanged(
			ImageEvent(TEAM_EVENT_IMAGE_DEBUG_INFO_CHANGED, image));
	}
}


void
Team::NotifyStopOnImageLoadChanged(bool enabled, bool useImageNameList)
{
	for (ListenerList::Iterator it = fListeners.GetIterator();
			Listener* listener = it.Next();) {
		listener->StopOnImageLoadSettingsChanged(
			ImageLoadEvent(TEAM_EVENT_IMAGE_LOAD_SETTINGS_CHANGED, this,
				enabled, useImageNameList));
	}
}


void
Team::NotifyStopImageNameAdded(const BString& name)
{
	for (ListenerList::Iterator it = fListeners.GetIterator();
			Listener* listener = it.Next();) {
		listener->StopOnImageLoadNameAdded(
			ImageLoadNameEvent(TEAM_EVENT_IMAGE_LOAD_NAME_ADDED, this, name));
	}
}


void
Team::NotifyStopImageNameRemoved(const BString& name)
{
	for (ListenerList::Iterator it = fListeners.GetIterator();
			Listener* listener = it.Next();) {
		listener->StopOnImageLoadNameRemoved(
			ImageLoadNameEvent(TEAM_EVENT_IMAGE_LOAD_NAME_REMOVED, this,
				name));
	}
}


void
Team::NotifyDefaultSignalDispositionChanged(int32 disposition)
{
	for (ListenerList::Iterator it = fListeners.GetIterator();
			Listener* listener = it.Next();) {
		listener->DefaultSignalDispositionChanged(
			DefaultSignalDispositionEvent(
				TEAM_EVENT_DEFAULT_SIGNAL_DISPOSITION_CHANGED, this,
				disposition));
	}
}


void
Team::NotifyCustomSignalDispositionChanged(int32 signal, int32 disposition)
{
	for (ListenerList::Iterator it = fListeners.GetIterator();
			Listener* listener = it.Next();) {
		listener->CustomSignalDispositionChanged(
			CustomSignalDispositionEvent(
				TEAM_EVENT_CUSTOM_SIGNAL_DISPOSITION_CHANGED, this,
				signal, disposition));
	}
}


void
Team::NotifyCustomSignalDispositionRemoved(int32 signal)
{
	for (ListenerList::Iterator it = fListeners.GetIterator();
			Listener* listener = it.Next();) {
		listener->CustomSignalDispositionRemoved(
			CustomSignalDispositionEvent(
				TEAM_EVENT_CUSTOM_SIGNAL_DISPOSITION_REMOVED, this,
				signal, SIGNAL_DISPOSITION_IGNORE));
	}
}


void
Team::NotifyConsoleOutputReceived(int32 fd, const BString& output)
{
	for (ListenerList::Iterator it = fListeners.GetIterator();
			Listener* listener = it.Next();) {
		listener->ConsoleOutputReceived(
			ConsoleOutputEvent(TEAM_EVENT_CONSOLE_OUTPUT_RECEIVED, this,
				fd, output));
	}
}


void
Team::NotifyUserBreakpointChanged(UserBreakpoint* breakpoint)
{
	for (ListenerList::Iterator it = fListeners.GetIterator();
			Listener* listener = it.Next();) {
		listener->UserBreakpointChanged(UserBreakpointEvent(
			TEAM_EVENT_USER_BREAKPOINT_CHANGED, this, breakpoint));
	}
}


void
Team::NotifyWatchpointChanged(Watchpoint* watchpoint)
{
	for (ListenerList::Iterator it = fListeners.GetIterator();
			Listener* listener = it.Next();) {
		listener->WatchpointChanged(WatchpointEvent(
			TEAM_EVENT_WATCHPOINT_CHANGED, this, watchpoint));
	}
}


void
Team::NotifyDebugReportChanged(const char* reportPath, status_t result)
{
	for (ListenerList::Iterator it = fListeners.GetIterator();
			Listener* listener = it.Next();) {
		listener->DebugReportChanged(DebugReportEvent(
			TEAM_EVENT_DEBUG_REPORT_CHANGED, this, reportPath, result));
	}
}


void
Team::NotifyCoreFileChanged(const char* targetPath)
{
	for (ListenerList::Iterator it = fListeners.GetIterator();
			Listener* listener = it.Next();) {
		listener->CoreFileChanged(CoreFileChangedEvent(
			TEAM_EVENT_CORE_FILE_CHANGED, this, targetPath));
	}
}


void
Team::NotifyMemoryChanged(target_addr_t address, target_size_t size)
{
	for (ListenerList::Iterator it = fListeners.GetIterator();
			Listener* listener = it.Next();) {
		listener->MemoryChanged(MemoryChangedEvent(
			TEAM_EVENT_MEMORY_CHANGED, this, address, size));
	}
}


void
Team::_NotifyTeamRenamed()
{
	for (ListenerList::Iterator it = fListeners.GetIterator();
			Listener* listener = it.Next();) {
		listener->TeamRenamed(Event(TEAM_EVENT_TEAM_RENAMED, this));
	}
}


void
Team::_NotifyThreadAdded(Thread* thread)
{
	for (ListenerList::Iterator it = fListeners.GetIterator();
			Listener* listener = it.Next();) {
		listener->ThreadAdded(ThreadEvent(TEAM_EVENT_THREAD_ADDED, thread));
	}
}


void
Team::_NotifyThreadRemoved(Thread* thread)
{
	for (ListenerList::Iterator it = fListeners.GetIterator();
			Listener* listener = it.Next();) {
		listener->ThreadRemoved(ThreadEvent(TEAM_EVENT_THREAD_REMOVED, thread));
	}
}


void
Team::_NotifyImageAdded(Image* image)
{
	for (ListenerList::Iterator it = fListeners.GetIterator();
			Listener* listener = it.Next();) {
		listener->ImageAdded(ImageEvent(TEAM_EVENT_IMAGE_ADDED, image));
	}
}


void
Team::_NotifyImageRemoved(Image* image)
{
	for (ListenerList::Iterator it = fListeners.GetIterator();
			Listener* listener = it.Next();) {
		listener->ImageRemoved(ImageEvent(TEAM_EVENT_IMAGE_REMOVED, image));
	}
}


// #pragma mark - Event


Team::Event::Event(uint32 type, Team* team)
	:
	fEventType(type),
	fTeam(team)
{
}


// #pragma mark - ThreadEvent


Team::ThreadEvent::ThreadEvent(uint32 type, Thread* thread)
	:
	Event(type, thread->GetTeam()),
	fThread(thread)
{
}


// #pragma mark - ImageEvent


Team::ImageEvent::ImageEvent(uint32 type, Image* image)
	:
	Event(type, image->GetTeam()),
	fImage(image)
{
}


// #pragma mark - ImageLoadEvent


Team::ImageLoadEvent::ImageLoadEvent(uint32 type, Team* team,
	bool stopOnImageLoad, bool stopImageNameListEnabled)
	:
	Event(type, team),
	fStopOnImageLoad(stopOnImageLoad),
	fStopImageNameListEnabled(stopImageNameListEnabled)
{
}


// #pragma mark - ImageLoadNameEvent


Team::ImageLoadNameEvent::ImageLoadNameEvent(uint32 type, Team* team,
	const BString& name)
	:
	Event(type, team),
	fImageName(name)
{
}


// #pragma mark - DefaultSignalDispositionEvent


Team::DefaultSignalDispositionEvent::DefaultSignalDispositionEvent(uint32 type,
	Team* team, int32 disposition)
	:
	Event(type, team),
	fDefaultDisposition(disposition)
{
}


// #pragma mark - CustomSignalDispositionEvent


Team::CustomSignalDispositionEvent::CustomSignalDispositionEvent(uint32 type,
	Team* team, int32 signal, int32 disposition)
	:
	Event(type, team),
	fSignal(signal),
	fDisposition(disposition)
{
}


// #pragma mark - BreakpointEvent


Team::BreakpointEvent::BreakpointEvent(uint32 type, Team* team,
	Breakpoint* breakpoint)
	:
	Event(type, team),
	fBreakpoint(breakpoint)
{
}


// #pragma mark - ConsoleOutputEvent


Team::ConsoleOutputEvent::ConsoleOutputEvent(uint32 type, Team* team,
	int32 fd, const BString& output)
	:
	Event(type, team),
	fDescriptor(fd),
	fOutput(output)
{
}


// #pragma mark - DebugReportEvent


Team::DebugReportEvent::DebugReportEvent(uint32 type, Team* team,
	const char* reportPath, status_t finalStatus)
	:
	Event(type, team),
	fReportPath(reportPath),
	fFinalStatus(finalStatus)
{
}


// #pragma mark - CoreFileChangedEvent


Team::CoreFileChangedEvent::CoreFileChangedEvent(uint32 type, Team* team,
	const char* targetPath)
	:
	Event(type, team),
	fTargetPath(targetPath)
{
}


// #pragma mark - MemoryChangedEvent


Team::MemoryChangedEvent::MemoryChangedEvent(uint32 type, Team* team,
	target_addr_t address, target_size_t size)
	:
	Event(type, team),
	fTargetAddress(address),
	fSize(size)
{
}


// #pragma mark - WatchpointEvent


Team::WatchpointEvent::WatchpointEvent(uint32 type, Team* team,
	Watchpoint* watchpoint)
	:
	Event(type, team),
	fWatchpoint(watchpoint)
{
}


// #pragma mark - UserBreakpointEvent


Team::UserBreakpointEvent::UserBreakpointEvent(uint32 type, Team* team,
	UserBreakpoint* breakpoint)
	:
	Event(type, team),
	fBreakpoint(breakpoint)
{
}


// #pragma mark - Listener


Team::Listener::~Listener()
{
}


void
Team::Listener::TeamRenamed(const Team::Event& event)
{
}


void
Team::Listener::ThreadAdded(const Team::ThreadEvent& event)
{
}


void
Team::Listener::ThreadRemoved(const Team::ThreadEvent& event)
{
}


void
Team::Listener::ImageAdded(const Team::ImageEvent& event)
{
}


void
Team::Listener::ImageRemoved(const Team::ImageEvent& event)
{
}


void
Team::Listener::ThreadStateChanged(const Team::ThreadEvent& event)
{
}


void
Team::Listener::ThreadCpuStateChanged(const Team::ThreadEvent& event)
{
}


void
Team::Listener::ThreadStackTraceChanged(const Team::ThreadEvent& event)
{
}


void
Team::Listener::ImageDebugInfoChanged(const Team::ImageEvent& event)
{
}


void
Team::Listener::StopOnImageLoadSettingsChanged(
	const Team::ImageLoadEvent& event)
{
}


void
Team::Listener::StopOnImageLoadNameAdded(const Team::ImageLoadNameEvent& event)
{
}


void
Team::Listener::StopOnImageLoadNameRemoved(
	const Team::ImageLoadNameEvent& event)
{
}


void
Team::Listener::DefaultSignalDispositionChanged(
	const Team::DefaultSignalDispositionEvent& event)
{
}


void
Team::Listener::CustomSignalDispositionChanged(
	const Team::CustomSignalDispositionEvent& event)
{
}


void
Team::Listener::CustomSignalDispositionRemoved(
	const Team::CustomSignalDispositionEvent& event)
{
}


void
Team::Listener::ConsoleOutputReceived(const Team::ConsoleOutputEvent& event)
{
}


void
Team::Listener::BreakpointAdded(const Team::BreakpointEvent& event)
{
}


void
Team::Listener::BreakpointRemoved(const Team::BreakpointEvent& event)
{
}


void
Team::Listener::UserBreakpointChanged(const Team::UserBreakpointEvent& event)
{
}


void
Team::Listener::WatchpointAdded(const Team::WatchpointEvent& event)
{
}


void
Team::Listener::WatchpointRemoved(const Team::WatchpointEvent& event)
{
}


void
Team::Listener::WatchpointChanged(const Team::WatchpointEvent& event)
{
}


void
Team::Listener::DebugReportChanged(const Team::DebugReportEvent& event)
{
}


void
Team::Listener::CoreFileChanged(const Team::CoreFileChangedEvent& event)
{
}


void
Team::Listener::MemoryChanged(const Team::MemoryChangedEvent& event)
{
}