#ifndef EMULATOR_H_
#define EMULATOR_H_

#include <queue>
#include <vector>

#include "value.h"

class program_loader;

class emulator {
public:
	emulator(
		program_loader * loader,
		int num_temp_regs,
		int num_const_regs,
		int num_out_regs,
		int num_input_regs);


	bool run();
	void set_constants(float value);
	value * get_value(register_address addr);
	value * get_output_value(unsigned int index);
	void queue_write(
		register_address addr,
		value * val);
	void dump_regs();

private:
	class write {
	public:
		write(register_address addr, value * val);
		register_address m_addr;
		value * m_val;
	};

	value * get_const_value(
		std::vector<float_value *> & registers,
		unsigned int index,
		register_address addr);
	void set_value(
		register_address addr,
		value * val);
	void set_value(
		std::vector<value *> & vector,
		unsigned int index,
		value * val);
	void dump_regs(
		std::vector<value *> & registers,
		enum register_type type);

	void dump_regs(
		std::vector<float_value *> & registers,
		enum register_type type);
	void print_reg(
		enum register_type type,
		unsigned int index,
		value * val);

	program_loader * m_loader;
	std::vector<value *> m_temp_regs;
	std::vector<float_value *> m_const_regs;
	std::vector<value *> m_out_regs;
	std::vector<value *> m_private_regs;
	std::vector<float_value*> m_immediate_regs;
	std::vector<float_value*> m_input_regs;
	std::queue<write> m_write_queue;
};

#endif //EMULATOR_H