haiku.git

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


#include "BreakpointSetting.h"

#include <Message.h>

#include "ArchivingUtils.h"
#include "FunctionID.h"
#include "LocatableFile.h"
#include "UserBreakpoint.h"


BreakpointSetting::BreakpointSetting()
	:
	fFunctionID(NULL),
	fSourceFile(),
	fSourceLocation(),
	fRelativeAddress(0),
	fEnabled(false),
	fHidden(false),
	fConditionExpression()
{
}


BreakpointSetting::BreakpointSetting(const BreakpointSetting& other)
	:
	fFunctionID(other.fFunctionID),
	fSourceFile(other.fSourceFile),
	fSourceLocation(other.fSourceLocation),
	fRelativeAddress(other.fRelativeAddress),
	fEnabled(other.fEnabled),
	fHidden(other.fHidden),
	fConditionExpression(other.fConditionExpression)
{
	if (fFunctionID != NULL)
		fFunctionID->AcquireReference();
}


BreakpointSetting::~BreakpointSetting()
{
	_Unset();
}


status_t
BreakpointSetting::SetTo(const UserBreakpointLocation& location, bool enabled,
	bool hidden, const BString& conditionExpression)
{
	_Unset();

	fFunctionID = location.GetFunctionID();
	if (fFunctionID != NULL)
		fFunctionID->AcquireReference();

	if (LocatableFile* file = location.SourceFile())
		file->GetPath(fSourceFile);

	fSourceLocation = location.GetSourceLocation();
	fRelativeAddress = location.RelativeAddress();
	fEnabled = enabled;
	fHidden = hidden;
	fConditionExpression = conditionExpression;

	return B_OK;
}


status_t
BreakpointSetting::SetTo(const BMessage& archive)
{
	_Unset();

	fFunctionID = ArchivingUtils::UnarchiveChild<FunctionID>(archive,
		"function");
	if (fFunctionID == NULL)
		return B_BAD_VALUE;

	archive.FindString("sourceFile", &fSourceFile);

	int32 line;
	if (archive.FindInt32("line", &line) != B_OK)
		line = -1;

	int32 column;
	if (archive.FindInt32("column", &column) != B_OK)
		column = -1;

	fSourceLocation = SourceLocation(line, column);

	if (archive.FindUInt64("relativeAddress", &fRelativeAddress) != B_OK)
		fRelativeAddress = 0;

	if (archive.FindBool("enabled", &fEnabled) != B_OK)
		fEnabled = false;

	if (archive.FindBool("hidden", &fHidden) != B_OK)
		fHidden = false;

	if (archive.FindString("condition", &fConditionExpression) != B_OK)
		fConditionExpression.Truncate(0);

	return B_OK;
}


status_t
BreakpointSetting::WriteTo(BMessage& archive) const
{
	if (fFunctionID == NULL)
		return B_BAD_VALUE;

	archive.MakeEmpty();

	status_t error;
	if ((error = ArchivingUtils::ArchiveChild(fFunctionID, archive, "function"))
			!= B_OK
		|| (error = archive.AddString("sourceFile", fSourceFile)) != B_OK
		|| (error = archive.AddInt32("line", fSourceLocation.Line())) != B_OK
		|| (error = archive.AddInt32("column", fSourceLocation.Column()))
			!= B_OK
		|| (error = archive.AddUInt64("relativeAddress", fRelativeAddress))
			!= B_OK
		|| (error = archive.AddBool("enabled", fEnabled)) != B_OK
		|| (error = archive.AddBool("hidden", fHidden)) != B_OK
		|| (error = archive.AddString("condition", fConditionExpression))
			!= B_OK) {
		return error;
	}

	return B_OK;
}


BreakpointSetting&
BreakpointSetting::operator=(const BreakpointSetting& other)
{
	if (this == &other)
		return *this;

	_Unset();

	fFunctionID = other.fFunctionID;
	if (fFunctionID != NULL)
		fFunctionID->AcquireReference();

	fSourceFile = other.fSourceFile;
	fSourceLocation = other.fSourceLocation;
	fRelativeAddress = other.fRelativeAddress;
	fEnabled = other.fEnabled;
	fHidden = other.fHidden;
	fConditionExpression = other.fConditionExpression;

	return *this;
}


void
BreakpointSetting::_Unset()
{
	if (fFunctionID != NULL) {
		fFunctionID->ReleaseReference();
		fFunctionID = NULL;
	}

	fSourceFile.Truncate(0);
	fSourceLocation = SourceLocation();
	fRelativeAddress = 0;
	fEnabled = false;
	fConditionExpression.Truncate(0);
}