#include <iostream>
#include <sstream>

#include "register_address.h"

register_address::register_address(
	register_type type,
	unsigned int index,
	enum swizzle swizzle)
	:
	m_type(type),
	m_index(index),
	m_swizzle(swizzle)
	{ }

register_address::register_address() :
	m_type(REGISTER_TYPE_NONE),
	m_index(0),
	m_swizzle(SWIZZLE_EMPTY)
	{ }

register_address::register_address(
	register_type type,
	unsigned int int_val)
	:
	m_type(type)
{
	unsigned int swz_val = int_val % 4;
	switch (swz_val) {
	case 0: m_swizzle = SWIZZLE_X; break;
	case 1: m_swizzle = SWIZZLE_Y; break;
	case 2: m_swizzle = SWIZZLE_Z; break;
	case 3: m_swizzle = SWIZZLE_W; break;
	}
	m_index = int_val / 4;
}

std::string
register_address::to_string()
{
	std::ostringstream s;

	s << register_address::register_type_to_string(m_type) << "[" <<  m_index << "]." <<
	swizzle_to_string(m_swizzle);

	return s.str();
}

std::string
register_address::register_type_to_string(enum register_type type)
{
	switch(type) {
		case REGISTER_TYPE_TEMP: return "TEMP";
		case REGISTER_TYPE_CONST: return "CONST";
		case REGISTER_TYPE_IN: return "IN";
		case REGISTER_TYPE_OUT: return "OUT";
		case REGISTER_TYPE_IMMEDIATE: return "IMM";
		case REGISTER_TYPE_PRIVATE: return "PRIV";
		default: return "NONE";
	}
}

std::string
register_address::swizzle_to_string(enum swizzle swz)
{
	switch(swz) {
		case SWIZZLE_EMPTY: return "_";
		case SWIZZLE_X: return "x";
		case SWIZZLE_Y: return "y";
		case SWIZZLE_Z: return "z";
		case SWIZZLE_W: return "w";
		default: return  "?";
	}
}

unsigned int
register_address::to_int()
{
	unsigned int swz_val;
	switch(m_swizzle) {
	case SWIZZLE_X: swz_val = 0; break;
	case SWIZZLE_Y: swz_val = 1; break;
	case SWIZZLE_Z: swz_val = 2; break;
	case SWIZZLE_W: swz_val = 3; break;
	case SWIZZLE_EMPTY:
		if (m_type == REGISTER_TYPE_NONE) {
			return 0;
		}
		/* Fall through */
	default:
		std::cerr << __FUNCTION__ << ": unhandled swizzle: " <<
					m_swizzle << "\n";
		return 0;
	}
	return (m_index * 4) + swz_val;
}