Retro68/Rez/Expression.cc

#include "Expression.h"
#include "ResourceCompiler.h"
#include <cassert>
#include <iostream>
#include <fstream>
#include "Diagnostic.h"

int Expression::evaluateInt(ResourceCompiler *ctx)
{
	error(ctx, "Expected an integer or integer expression here.");
	return 0;
}

std::string Expression::evaluateString(ResourceCompiler *ctx)
{
	error(ctx, "Expected a string or string expression here.");
	return "";
}

Expression::~Expression()
{
}

void Expression::error(ResourceCompiler *ctx, std::string err)
{
	ctx->problem(Diagnostic(Diagnostic::Severity::error, err, location));
}


StringExpr::~StringExpr()
{
}

std::string StringExpr::evaluateString(ResourceCompiler *ctx)
{
	return str;
}


IntExpr::~IntExpr()
{
}

int IntExpr::evaluateInt(ResourceCompiler *ctx)
{
	return val;
}


void CompoundExpr::addItem(ExprPtr item)
{
	items.push_back(item);
}

CompoundExpr::~CompoundExpr()
{
}


BinaryExpr::~BinaryExpr()
{
}

int BinaryExpr::evaluateInt(ResourceCompiler *ctx)
{
	switch(op)
	{
		case BinaryOp::XOR:
			return a->evaluateInt(ctx) ^ b->evaluateInt(ctx);
		case BinaryOp::OR:
			return a->evaluateInt(ctx) | b->evaluateInt(ctx);
		case BinaryOp::AND:
			return a->evaluateInt(ctx) & b->evaluateInt(ctx);
		case BinaryOp::SHIFTLEFT:
			return a->evaluateInt(ctx) << b->evaluateInt(ctx);
		case BinaryOp::SHIFTRIGHT:
			return a->evaluateInt(ctx) >> b->evaluateInt(ctx);
		case BinaryOp::EQUAL:
			return a->evaluateInt(ctx) == b->evaluateInt(ctx);
		case BinaryOp::NOTEQUAL:
			return a->evaluateInt(ctx) != b->evaluateInt(ctx);
		case BinaryOp::PLUS:
			return a->evaluateInt(ctx) + b->evaluateInt(ctx);
		case BinaryOp::MINUS:
			return a->evaluateInt(ctx) - b->evaluateInt(ctx);
		case BinaryOp::MULTIPLY:
			return a->evaluateInt(ctx) * b->evaluateInt(ctx);
		case BinaryOp::DIVIDE:
			return a->evaluateInt(ctx) / b->evaluateInt(ctx);
		default:
			error(ctx, "Expected an integer or integer expression here.");
			return 0;
	}
}

std::string BinaryExpr::evaluateString(ResourceCompiler *ctx)
{
	switch(op)
	{
		case BinaryOp::CONCAT:
			return a->evaluateString(ctx) + b->evaluateString(ctx);
		default:
			error(ctx, "Expected a string or string expression here.");
			return "";
	}
}


UnaryExpr::~UnaryExpr()
{
}

int UnaryExpr::evaluateInt(ResourceCompiler *ctx)
{
	switch(op)
	{
		case UnaryOp::MINUS:
			return -a->evaluateInt(ctx);
		case UnaryOp::COMPLEMENT:
			return ~a->evaluateInt(ctx);
		default:
			error(ctx, "Expected an integer or integer expression here.");
			return 0;
	}
}


IdentifierExpr::IdentifierExpr(std::string id, yy::location loc)
	: Expression(loc), id(id)
{
}

void IdentifierExpr::addArgument(ExprPtr e)
{
	arguments.push_back(e);
}

ExprPtr IdentifierExpr::lookup(ResourceCompiler *ctx)
{
	Subscripts sub;
	for(auto arg : arguments)
		sub.addSubscript(arg->evaluateInt(ctx));
	ExprPtr val = ctx->lookupIdentifier(id, sub);
	if(!val)
		error(ctx, "Identifier \"" + id + "\" is not defined.");
	return val;
}

int IdentifierExpr::evaluateInt(ResourceCompiler *ctx)
{
	if(ctx->isPrePass())
		return 0;
	if(ExprPtr e = lookup(ctx))
		return e->evaluateInt(ctx);
	else
		return 0;
}

std::string IdentifierExpr::evaluateString(ResourceCompiler *ctx)
{
	if(ExprPtr e = lookup(ctx))
		return e->evaluateString(ctx);
	else
		return "";
}


CaseExpr::CaseExpr(const std::string &tag, CompoundExprPtr expr, yy::location loc)
	: Expression(loc), tag(tag), expr(expr)
{
}


int CountOfExpr::evaluateInt(ResourceCompiler *ctx)
{
	assert(arg->arguments.size() == 0);
	return ctx->getArrayCount(arg->id);
}


int ArrayIndexExpr::evaluateInt(ResourceCompiler *ctx)
{
	assert(arg->arguments.size() == 0);
	return ctx->getArrayIndex(arg->id);
}


std::string ReadExpr::evaluateString(ResourceCompiler *ctx)
{
	std::string filename = arg->evaluateString(ctx);
	std::ifstream instream(filename);
	// ### TODO: check error
	return std::string(std::istreambuf_iterator<char>(instream.rdbuf()),
					   std::istreambuf_iterator<char>());
}


int UnimplementedExpr::evaluateInt(ResourceCompiler *ctx)
{
	std::cerr << msg << std::endl;
	return 0;
}

std::string UnimplementedExpr::evaluateString(ResourceCompiler *ctx)
{
	std::cerr << msg << std::endl;
	return "";
}


PeekExpr::PeekExpr(ExprPtr addr, ExprPtr offset, ExprPtr size, yy::location loc)
	: Expression(loc), addr(addr), offset(offset), size(size)
{
}

PeekExpr::PeekExpr(ExprPtr addr, int size, yy::location loc)
	: Expression(loc),
	  addr(addr),
	  offset(std::make_shared<IntExpr>(0,loc)),
	  size(std::make_shared<IntExpr>(size,loc))
{
}

int PeekExpr::evaluateInt(ResourceCompiler *ctx)
{
	int p = addr->evaluateInt(ctx) + offset->evaluateInt(ctx);
	int s = size->evaluateInt(ctx);

	return ctx->peek(p, s);
}