haiku.git

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


#include "StackFrameValueInfos.h"

#include <new>

#include "FunctionID.h"
#include "Type.h"
#include "TypeComponentPath.h"
#include "ValueLocation.h"


struct StackFrameValueInfos::Key {
	ObjectID*			variable;
	TypeComponentPath*	path;

	Key(ObjectID* variable, TypeComponentPath* path)
		:
		variable(variable),
		path(path)
	{
	}

	uint32 HashValue() const
	{
		return variable->HashValue() ^ path->HashValue();
	}

	bool operator==(const Key& other) const
	{
		return *variable == *other.variable && *path == *other.path;
	}
};


struct StackFrameValueInfos::InfoEntry : Key {
	Type*				type;
	ValueLocation*		location;
	InfoEntry*			next;

	InfoEntry(ObjectID* variable, TypeComponentPath* path)
		:
		Key(variable, path),
		type(NULL),
		location(NULL)
	{
		variable->AcquireReference();
		path->AcquireReference();
	}

	~InfoEntry()
	{
		SetInfo(NULL, NULL);
		variable->ReleaseReference();
		path->ReleaseReference();
	}


	void SetInfo(Type* type, ValueLocation* location)
	{
		if (type != NULL)
			type->AcquireReference();
		if (location != NULL)
			location->AcquireReference();

		if (this->type != NULL)
			this->type->ReleaseReference();
		if (this->location != NULL)
			this->location->ReleaseReference();

		this->type = type;
		this->location = location;
	}
};


struct StackFrameValueInfos::InfoEntryHashDefinition {
	typedef Key			KeyType;
	typedef	InfoEntry	ValueType;

	size_t HashKey(const Key& key) const
	{
		return key.HashValue();
	}

	size_t Hash(const InfoEntry* value) const
	{
		return value->HashValue();
	}

	bool Compare(const Key& key, const InfoEntry* value) const
	{
		return key == *value;
	}

	InfoEntry*& GetLink(InfoEntry* value) const
	{
		return value->next;
	}
};


StackFrameValueInfos::StackFrameValueInfos()
	:
	fValues(NULL)
{
}


StackFrameValueInfos::~StackFrameValueInfos()
{
	_Cleanup();
}


status_t
StackFrameValueInfos::Init()
{
	fValues = new(std::nothrow) ValueTable;
	if (fValues == NULL)
		return B_NO_MEMORY;

	return fValues->Init();
}


bool
StackFrameValueInfos::GetInfo(ObjectID* variable,
	const TypeComponentPath* path, Type** _type,
	ValueLocation** _location) const
{
	InfoEntry* entry = fValues->Lookup(
		Key(variable, (TypeComponentPath*)path));
	if (entry == NULL)
		return false;

	if (_type != NULL) {
		entry->type->AcquireReference();
		*_type = entry->type;
	}

	if (_location != NULL) {
		entry->location->AcquireReference();
		*_location = entry->location;
	}

	return true;
}


bool
StackFrameValueInfos::HasInfo(ObjectID* variable,
	const TypeComponentPath* path) const
{
	return fValues->Lookup(Key(variable, (TypeComponentPath*)path)) != NULL;
}


status_t
StackFrameValueInfos::SetInfo(ObjectID* variable, TypeComponentPath* path,
	Type* type, ValueLocation* location)
{
	InfoEntry* entry = fValues->Lookup(Key(variable, path));
	if (entry == NULL) {
		entry = new(std::nothrow) InfoEntry(variable, path);
		if (entry == NULL)
			return B_NO_MEMORY;
		fValues->Insert(entry);
	}

	entry->SetInfo(type, location);
	return B_OK;
}


void
StackFrameValueInfos::_Cleanup()
{
	if (fValues != NULL) {
		InfoEntry* entry = fValues->Clear(true);

		while (entry != NULL) {
			InfoEntry* next = entry->next;
			delete entry;
			entry = next;
		}

		delete fValues;
		fValues = NULL;
	}
}