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

#include <vector>

#include <stdlib.h>
#include <string.h>

#include <Referenceable.h>

#include "Types.h"


enum value_piece_location_type {
	VALUE_PIECE_LOCATION_INVALID,	// structure is invalid
	VALUE_PIECE_LOCATION_UNKNOWN,	// location unknown, but size is valid
	VALUE_PIECE_LOCATION_MEMORY,	// piece is in memory
	VALUE_PIECE_LOCATION_REGISTER,	// piece is in a register
	VALUE_PIECE_LOCATION_IMPLICIT	// value isn't stored anywhere in memory but is known
};


struct ValuePieceLocation {
	union {
		target_addr_t			address;	// memory address
		uint32					reg;		// register number
	};
	target_size_t				size;		// size in bytes (including
											// incomplete ones)
	uint64						bitSize;	// total size in bits
	uint64						bitOffset;	// bit offset (to the most
											// significant bit)
	value_piece_location_type	type;
	void*						value;		// used for storing implicit values
	bool						writable;	// indicates if the piece is in a
											// location in the target team
											// where it can be modified


	ValuePieceLocation()
		:
		type(VALUE_PIECE_LOCATION_INVALID),
		value(NULL),
		writable(false)
	{
	}

	ValuePieceLocation(const ValuePieceLocation& other)
	{
		if (!Copy(other))
			throw std::bad_alloc();
	}

	~ValuePieceLocation()
	{
		if (value != NULL)
			free(value);
	}

	ValuePieceLocation& operator=(const ValuePieceLocation& other)
	{
		if (!Copy(other))
			throw std::bad_alloc();

		return *this;
	}

	bool Copy(const ValuePieceLocation& other)
	{
		memcpy((void*)this, (void*)&other, sizeof(ValuePieceLocation));
		if (type == VALUE_PIECE_LOCATION_IMPLICIT) {
			void* tempValue = malloc(size);
			if (tempValue == NULL) {
				type = VALUE_PIECE_LOCATION_INVALID;
				return false;
			}

			memcpy(tempValue, value, other.size);
			value = tempValue;
		}

		return true;
	}

	bool IsValid() const
	{
		return type != VALUE_PIECE_LOCATION_INVALID;
	}

	void SetToUnknown()
	{
		type = VALUE_PIECE_LOCATION_UNKNOWN;
	}

	void SetToMemory(target_addr_t address)
	{
		type = VALUE_PIECE_LOCATION_MEMORY;
		this->address = address;
		this->writable = true;
	}

	void SetToRegister(uint32 reg)
	{
		type = VALUE_PIECE_LOCATION_REGISTER;
		this->reg = reg;
		this->writable = true;
	}

	void SetSize(target_size_t size)
	{
		this->size = size;
		this->bitSize = size * 8;
		this->bitOffset = 0;
	}

	void SetSize(uint64 bitSize, uint64 bitOffset)
	{
		this->size = (bitOffset + bitSize + 7) / 8;
		this->bitSize = bitSize;
		this->bitOffset = bitOffset;
	}

	bool SetToValue(const void* data, target_size_t size)
	{
		char* valueData = (char*)malloc(size);
		if (valueData == NULL)
			return false;
		memcpy(valueData, data, size);
		SetSize(size);
		type = VALUE_PIECE_LOCATION_IMPLICIT;
		value = valueData;
		writable = false;
		return true;
	}

	ValuePieceLocation& Normalize(bool bigEndian);
};


class ValueLocation : public BReferenceable {
public:
								ValueLocation();
								ValueLocation(bool bigEndian);
								ValueLocation(bool bigEndian,
									const ValuePieceLocation& piece);

								ValueLocation(const ValueLocation& other);

			bool				SetToByteOffset(const ValueLocation& other,
									uint64 byteffset, uint64 Size);

			bool				SetTo(const ValueLocation& other,
									uint64 bitOffset, uint64 bitSize);

			void				Clear();

			bool				IsBigEndian() const	{ return fBigEndian; }
			bool				IsWritable() const { return fWritable; }

			bool				AddPiece(const ValuePieceLocation& piece);

			int32				CountPieces() const;
			ValuePieceLocation	PieceAt(int32 index) const;
			bool				SetPieceAt(int32 index,
									const ValuePieceLocation& piece);
			ValueLocation&		operator=(const ValueLocation& other);

			void				Dump() const;

private:
	typedef std::vector<ValuePieceLocation> PieceVector;

private:
			PieceVector			fPieces;
			bool				fBigEndian;
			bool				fWritable;
};


#endif	// VALUE_LOCATION_H