scratch @ 4eff1ebb0d1633167671e5370c2bd4e803d72c83

import gbf/internal/lexer

import gbf/internal/parser.{type AST, type Block, type Command}

import gbf/internal/token

import gbf/internal/vm.{type VirtualMachine}

import gleam/int

import gleam/list

import gleam/result

pub type Error {

  /// An unexpected command was encountered at the given position.

  UnexpectedCommand(pos: lexer.Position)

  /// An error occurred in the virtual machine

  VmError(reason: vm.Error, pos: lexer.Position)

}

/// Evaluates an AST node against the virtual machine.

///

pub fn eval(vm: VirtualMachine, node: AST) -> Result(VirtualMachine, Error) {

  case node {

    parser.Leaf(command) -> eval_command(vm, command)

    parser.Node(block) -> eval_block(vm, block)

  }

}

fn eval_command(

  vm: VirtualMachine,

  command: Command,

) -> Result(VirtualMachine, Error) {

  case command {

    #(token.Comment(_), _) -> Ok(vm)

    #(token.IncrementPointer, p) ->

      vm.set_pointer(vm, vm.pointer + 1) |> wrap_vm_error(p)

    #(token.DecrementPointer, p) ->

      vm.set_pointer(vm, vm.pointer - 1) |> wrap_vm_error(p)

    #(token.IncrementByte, p) -> mut_byte(vm, int.add) |> wrap_vm_error(p)

    #(token.DecrementByte, p) -> mut_byte(vm, int.subtract) |> wrap_vm_error(p)

    #(token.InputByte, p) -> vm.input_byte(vm) |> wrap_vm_error(p)

    #(token.OutputByte, p) -> vm.output_byte(vm) |> wrap_vm_error(p)

    #(token.StartBlock, p) -> Error(UnexpectedCommand(p))

    #(token.EndBlock, p) -> Error(UnexpectedCommand(p))

    #(_, p) -> Error(UnexpectedCommand(p))

  }

}

fn eval_block(vm: VirtualMachine, block: Block) -> Result(VirtualMachine, Error) {

  use acc_vm, child <- list.fold(block.children, Ok(vm))

  case child {

    parser.Leaf(command) -> result.try(acc_vm, eval_command(_, command))

    parser.Node(child_block) ->

      result.try(acc_vm, eval_child_block(_, child_block))

  }

}

fn eval_child_block(vm: VirtualMachine, child_block: Block) {

  use cell_value <- result.try(

    vm.get_cell(vm, vm.pointer)

    |> result.map_error(VmError(_, pos: child_block.position)),

  )

  case cell_value > 0 {

    False -> Ok(vm)

    True -> {

      let acc = eval_block(vm, child_block)

      result.try(acc, eval_child_block(_, child_block))

    }

  }

}

fn mut_byte(vm: VirtualMachine, op: fn(Int, Int) -> Int) {

  use cell <- result.try(vm.get_cell(vm, vm.pointer))

  let cell = op(cell, 1)

  vm.set_cell(vm, vm.pointer, cell)

}

fn wrap_vm_error(

  r: Result(VirtualMachine, vm.Error),

  pos: lexer.Position,

) -> Result(VirtualMachine, Error) {

  result.map_error(r, VmError(_, pos))

}