mirror of
https://github.com/autc04/Retro68.git
synced 2024-10-14 10:24:00 +00:00
234 lines
4.7 KiB
C++
234 lines
4.7 KiB
C++
#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);
|
|
if(!instream)
|
|
{
|
|
ctx->problem(Diagnostic(Diagnostic::Severity::error, "could not $$read file " + filename, location));
|
|
}
|
|
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);
|
|
}
|