bytecode.cpp

#include "bytecode.h"

int Bytecode::simpleInstruction(std::string opcode, int idx) {
	std::cout << "offset " << idx << ", line " << lines[idx] << ": " << opcode << std::endl;
	return 1;
}

uint8_t Bytecode::codeAt(size_t idx) {
	return code[idx];
}

Value Bytecode::valueAt(size_t idx) {
	return constants[idx];
}

int Bytecode::lineAt(size_t idx) {
	return lines[idx];
}
	
void Bytecode::writeByte(uint8_t byte, int line) {
	code.push_back(byte);
	lines.push_back(line);
}
	
void Bytecode::writeConstant(Value val, int line) {
	constants.push_back(val);
	writeByte(Opcode::OP_CONSTANT, line);
	writeByte(constants.size() - 1, line);
}
	
size_t Bytecode::disassembleInstruction(size_t idx) {
	switch (code[idx]) {
	case Opcode::RETURN: return simpleInstruction("RETURN", idx);
	case Opcode::NEGATE: return simpleInstruction("NEGATE", idx);
	case Opcode::ADD: return simpleInstruction("ADD", idx);
	case Opcode::SUBTRACT: return simpleInstruction("SUBTRACT", idx);
	case Opcode::MULTIPLY: return simpleInstruction("MULTIPLY", idx);
	case Opcode::DIVIDE: return simpleInstruction("DIVIDE", idx);
	case Opcode::TRUE: return simpleInstruction("TRUE", idx);
	case Opcode::FALSE: return simpleInstruction("FALSE", idx);
	case Opcode::NUL: return simpleInstruction("NUL", idx);
	case Opcode::NOT: return simpleInstruction("NOT", idx);
	case Opcode::EQUAL: return simpleInstruction("EQUAL", idx);
	case Opcode::GREATER: return simpleInstruction("GREATER", idx);
	case Opcode::LESSER: return simpleInstruction("LESSER", idx);
	case Opcode::OP_CONSTANT:
		std::cout << "offset " << idx << ", line " << lines[idx] << ": OP_CONSTANT \'" << constants[code[idx + 1]] << "\'" << std::endl;
		return 2;
	default:
		std::cerr << "offset " << idx << ", line " << lines[idx] << ": Unkown instruction: " << code[idx] << std::endl;
		return 1;
	}
}

void Bytecode::disassembleCode() {
	for (size_t i{ 0 }; i < code.size(); )
		i += disassembleInstruction(i);
}