vm.cpp

#include "vm.h"

VM::InterpretResult VM::interpret(std::istream& input) {
	Compiler compiler;
	if (!compiler.compile(input, &this->bytecode))
		return VM::InterpretResult::COMPILE_ERROR;
	return run();
}

Value& VM::peek(int distance) {
	return st.at(st.size() - 1 - distance);
}

Value VM::pop() {
	Value val = peek(0);
	st.pop_back();
	return val;
}

uint8_t VM::readByte() {
	return bytecode.codeAt(ip++);
}
	
Value VM::readConstant() {
	size_t add = readByte();
	return bytecode.valueAt(add);
}

void VM::runtimeError(std::string message, uint8_t idx) {
//	resetStack();
	std::cerr << message << " at line " << std::to_string(bytecode.lineAt(idx));
}
bool VM::isFalsey(Value& val) {
	switch (val.getType()) {
	case Value::NUL:
		return true;
	case Value::BOOL:
		return !std::get<bool>(val.getVal());
	/*case Value::STRING:
		return std::get<std::string>(val.getVal()) == "";*/
	case Value::NUM:
		return std::get<double>(val.getVal()) == 0;
	default:
		runtimeError("Expected a boolean expression", ip);
		std::exit(InterpretResult::COMPILE_ERROR);
	}
}

VM::InterpretResult VM::binaryOp(uint8_t op) {
	if (peek(0).getType() != Value::NUM) {
		runtimeError("Expected a number after '-'", op);
		return RUNTIME_ERROR;
	}
	double num1 = std::get<double>(pop().getVal());
	if (peek(0).getType() != Value::NUM) {
		runtimeError("Expected a number after '-'", op);
		return RUNTIME_ERROR;
	}
	double num2 = std::get<double>(pop().getVal());
	switch (op) {
	case Opcode::ADD:
		st.push_back(Value(num2 + num1));
		break;
	case Opcode::SUBTRACT:
		st.push_back(Value(num2 - num1));
		break;
	case Opcode::MULTIPLY:
		st.push_back(Value(num2 * num1));
		break;
	case Opcode::DIVIDE:
		st.push_back(Value(num2 / num1));
		break;
	case Opcode::GREATER:
		st.push_back(Value(num2 > num1));
		break;
	case Opcode::LESSER:
		st.push_back(Value(num2 < num1));
		break;
	}
	return VM::OK;
}

VM::InterpretResult VM::run() {
	while (true) {
#ifdef DEBUG_TRACE_EXECUTION
		std::cout << "stack => ";
		for (auto it = st.begin(); it != st.end(); it++)
			std::cout << *it << " ";
		std::cout << std::endl;
		bytecode.disassembleInstruction(ip);
#endif
		switch (uint8_t instruction = readByte()) {
		case Opcode::RETURN:
			std::cout << pop() << std::endl;
			return InterpretResult::OK;
		case Opcode::OP_CONSTANT: st.push_back(readConstant()); break;
		case Opcode::TRUE: st.push_back(Value(true)); break;
		case Opcode::FALSE: st.push_back(Value(false)); break;
		case Opcode::NUL: st.push_back(Value()); break;
		case Opcode::NEGATE:
		{
			if (peek(0).getType() != Value::NUM) {
				runtimeError("Expected a number after '-'", instruction);
				return RUNTIME_ERROR;
			}
			st.push_back(Value(-std::get<double>(pop().getVal())));
			break;
		}
		case Opcode::ADD:
		if (peek(1).getType() == Value::STRING && 
			peek(0).getType() == Value::STRING) {
			std::string s1 = std::get<std::string>(pop().getVal());
			std::string s2 = std::get<std::string>(pop().getVal());
			st.push_back(Value(s2 + s1));
		}
		else if (peek(1).getType() == Value::NUM &&
				 peek(0).getType() == Value::NUM) {
			double n1 = std::get<double>(pop().getVal());
			double n2 = std::get<double>(pop().getVal());
			st.push_back(Value(n1 + n2));
		}
		else {
			runtimeError("Operands must be value of string", instruction);
			return RUNTIME_ERROR;
		}
		break;
		case Opcode::SUBTRACT:
		case Opcode::MULTIPLY:
		case Opcode::DIVIDE:
		case Opcode::GREATER:
		case Opcode::LESSER:
			if (binaryOp(instruction) == RUNTIME_ERROR)
				return RUNTIME_ERROR;
			break;
		case Opcode::NOT:
		{
			Value val = pop();
			st.push_back(Value(isFalsey(val)));
			break;
		}
		case Opcode::EQUAL:
		{
			Value v1 = pop();
			Value v2 = pop();
			st.push_back(Value(v1.getVal() == v2.getVal()));
			break;
		}
		}
	}
}