interpreter.cc

#include "ast.hh"
#include <strings.h> 
#include <stdio.h> 

using namespace AST;

namespace Interpreter {
struct State
{
  int16_t a[10] = {0};
  int16_t g[10] = {0};
  int16_t v = 0;
  int16_t width = 0;
  int16_t height = 0;
  int16_t x = 0;
  int16_t y = 0;
  int16_t *grid = 0;
};
void runOneStep(int16_t *oldgrid,
                int16_t *newgrid,
                int16_t width,
                int16_t height,
                AST::StatementList *ast)
{
    Interpreter::State state;
    state.grid = oldgrid;
    state.width = width;
    state.height = height;
    int i=0;
    for (int x=0 ; x<width ; x++)
    {
        for (int y=0 ; y<height ; y++,i++)
        {
            state.v = oldgrid[i];
            state.x = x;
            state.y = y;
            bzero(state.a, sizeof(state.a));
            ast->interpret(state);
            newgrid[i] = state.v;
        }
    }
}

}

uint16_t Literal::interpret(Interpreter::State &s)
{
    return value;
}
uint16_t LocalRegister::interpret(Interpreter::State &s)
{
    assert(registerNumber >= 0 && registerNumber < 10);
    return s.a[registerNumber];
}
void LocalRegister::assign(Interpreter::State &s, uint16_t val)
{
    assert(registerNumber >= 0 && registerNumber < 10);
    s.a[registerNumber] = val;
}
uint16_t GlobalRegister::interpret(Interpreter::State &s)
{
    return s.g[registerNumber];
}
void GlobalRegister::assign(Interpreter::State &s, uint16_t val)
{
    s.g[registerNumber] = val;
}
uint16_t VRegister::interpret(Interpreter::State &s)
{
    return s.v;
}
void VRegister::assign(Interpreter::State &s, uint16_t val)
{
    s.v = val;
}

uint16_t Arithmetic::interpret(Interpreter::State &s)
{
    uint16_t v = value->interpret(s);
    uint16_t o = target->interpret(s);
    uint16_t result;
    switch (op->op)
    {
        case Op::Add:
            result = o+v;
            break;
        case Op::Assign:
            result = v;
            break;
        case Op::Sub:
            result = o-v;
            break;
        case Op::Mul:
            result = o*v;
            break;
        case Op::Div:
            result = o/v;
            break;
        case Op::Min:
            result = std::min(o,v);
            break;
        case Op::Max:
            result = std::max(o,v);
            break;
    }
    target->assign(s, result);
    return 0;
}

uint16_t RangeExpr::interpret(Interpreter::State &s)
{
    uint16_t input = value->interpret(s);
    for (auto &range : ranges.objects())
    {
        uint16_t end = range->end->value;
        if (range->start.get())
        {
            uint16_t start = range->start->value;
            if ((input >= start) && (input <= end))
            {
                return range->value->interpret(s);
            }
        }
        else if (input == end)
        {
            return range->value->interpret(s);
        }
    }
    return 0;
}

uint16_t Neighbours::interpret(Interpreter::State &state)
{
    // For each of the (valid) neighbours
    for (int x = state.x - 1 ; x <= state.x + 1 ; x++)
    {
        if (x < 0 || x >= state.width) continue;
        for (int y = state.y - 1 ; y <= state.y + 1 ; y++)
        {
            if (y < 0 || y >= state.height) continue;
            if (x == state.x && y == state.y) continue;
            // a0 contains the value for the currently visited neighbour
            state.a[0] = state.grid[x*state.height + y];
            // Run all of the statements
            statements->interpret(state);
        }
    }
    return 0;
}

uint16_t StatementList::interpret(Interpreter::State& state)
{
    for (auto &s: statements.objects())
    {
        s->interpret(state);
    }
    return 0;
}