use super::{Address, Opcode, Operation, Stack, Symbol, Val};
use crate::error;
use crate::lang::{Column, Error, LineNumber, MaxValue};
use std::collections::{BTreeMap, HashMap};
use std::convert::TryFrom;
use std::rc::Rc;
type Result<T> = std::result::Result<T, Error>;
#[derive(Debug)]
pub struct Link {
current_symbol: Symbol,
ops: Stack<Opcode>,
data: Stack<Val>,
data_pos: Address,
direct_set: bool,
symbols: BTreeMap<Symbol, (Address, Address)>,
unlinked: HashMap<Address, (Column, Symbol)>,
}
impl Default for Link {
fn default() -> Self {
Link {
current_symbol: 0,
ops: Stack::new("PROGRAM SIZE LIMIT EXCEEDED"),
data: Stack::new("DATA SIZE LIMIT EXCEEDED"),
data_pos: 0,
direct_set: false,
symbols: BTreeMap::default(),
unlinked: HashMap::default(),
}
}
}
impl Link {
pub fn append(&mut self, mut link: Link) -> Result<()> {
if self.direct_set && !link.data.is_empty() {
return Err(error!(IllegalDirect));
}
let ops_addr_offset = self.ops.len();
let data_addr_offset = self.data.len();
let sym_offset = self.current_symbol;
for (symbol, (ops_addr, data_addr)) in link.symbols.iter() {
let mut symbol = *symbol;
if symbol < 0 {
symbol += sym_offset
}
self.symbols.insert(
symbol,
(*ops_addr + ops_addr_offset, *data_addr + data_addr_offset),
);
}
for (address, (col, symbol)) in link.unlinked.iter() {
let mut symbol = *symbol;
if symbol < 0 {
symbol += sym_offset
}
self.unlinked
.insert(*address + ops_addr_offset, (col.clone(), symbol));
}
self.current_symbol += link.current_symbol;
self.ops.append(&mut link.ops)?;
self.data.append(&mut link.data)
}
pub fn push(&mut self, op: Opcode) -> Result<()> {
self.ops.push(op)
}
pub fn transform_to_data(&mut self, col: &Column) -> Result<()> {
if self.ops.len() == 1 {
if let Some(Opcode::Literal(val)) = self.ops.drain(..).next() {
self.data.push(val)?;
return Ok(());
}
} else if self.ops.len() == 2 {
let mut expr_link = self.ops.drain(..);
if let Some(Opcode::Literal(val)) = expr_link.next() {
if let Some(Opcode::Neg) = expr_link.next() {
self.data.push(Operation::negate(val)?)?;
return Ok(());
}
}
}
Err(error!(SyntaxError, ..col; "EXPECTED LITERAL"))
}
pub fn read_data(&mut self) -> Result<Val> {
if let Some(val) = self.data.get(self.data_pos) {
self.data_pos += 1;
Ok(val.clone())
} else {
Err(error!(OutOfData))
}
}
pub fn restore_data(&mut self, addr: Address) {
self.data_pos = addr;
}
pub fn get(&self, addr: Address) -> Option<&Opcode> {
self.ops.get(addr)
}
pub fn last(&self) -> Option<&Opcode> {
self.ops.last()
}
pub fn drain<R>(&mut self, range: R) -> std::vec::Drain<'_, Opcode>
where
R: std::ops::RangeBounds<usize>,
{
self.ops.drain(range)
}
pub fn is_empty(&self) -> bool {
self.ops.is_empty()
}
pub fn len(&self) -> usize {
self.ops.len()
}
pub fn clear(&mut self) {
self.current_symbol = 0;
self.direct_set = false;
self.ops.clear();
self.data.clear();
self.symbols.clear();
self.unlinked.clear();
}
pub fn next_symbol(&mut self) -> Symbol {
self.current_symbol -= 1;
self.current_symbol
}
fn symbol_for_line_number(&mut self, line_number: LineNumber) -> Result<Symbol> {
match line_number {
Some(number) => Ok(number as Symbol),
None => Err(error!(InternalError; "NO SYMBOL FOR LINE NUMBER")),
}
}
pub fn push_def_fn(
&mut self,
col: Column,
ident: Rc<str>,
vars: Vec<Rc<str>>,
expr_ops: Link,
) -> Result<()> {
let len = Val::try_from(vars.len())?;
self.push(Opcode::Literal(len))?;
self.push(Opcode::Def(ident))?;
let skip = self.next_symbol();
self.push_jump(col, skip)?;
for var in vars {
self.push(Opcode::Pop(var))?;
}
self.append(expr_ops)?;
self.push(Opcode::Return)?;
self.push_symbol(skip);
Ok(())
}
pub fn push_for(&mut self, col: Column) -> Result<()> {
let next = self.next_symbol();
self.unlinked.insert(self.ops.len(), (col, next));
self.ops.push(Opcode::Literal(Val::Next(0)))?;
self.push_symbol(next);
Ok(())
}
pub fn push_gosub(&mut self, col: Column, line_number: LineNumber) -> Result<()> {
let ret_sym = self.next_symbol();
self.push_return_val(col.clone(), ret_sym)?;
let line_number_sym = self.symbol_for_line_number(line_number)?;
self.unlinked.insert(self.ops.len(), (col, line_number_sym));
self.ops.push(Opcode::Jump(0))?;
self.push_symbol(ret_sym);
Ok(())
}
pub fn push_return_val(&mut self, col: Column, symbol: Symbol) -> Result<()> {
self.unlinked.insert(self.ops.len(), (col, symbol));
self.ops.push(Opcode::Literal(Val::Return(0)))
}
pub fn push_goto(&mut self, col: Column, line_number: LineNumber) -> Result<()> {
let sym = self.symbol_for_line_number(line_number)?;
self.unlinked.insert(self.ops.len(), (col, sym));
self.ops.push(Opcode::Jump(0))
}
pub fn push_ifnot(&mut self, col: Column, sym: Symbol) -> Result<()> {
self.unlinked.insert(self.ops.len(), (col, sym));
self.push(Opcode::IfNot(0))
}
pub fn push_jump(&mut self, col: Column, sym: Symbol) -> Result<()> {
self.unlinked.insert(self.ops.len(), (col, sym));
self.push(Opcode::Jump(0))
}
pub fn push_restore(&mut self, col: Column, line_number: LineNumber) -> Result<()> {
if line_number.is_some() {
let sym = self.symbol_for_line_number(line_number)?;
self.unlinked.insert(self.ops.len(), (col, sym));
}
self.ops.push(Opcode::Restore(0))
}
pub fn push_run(&mut self, col: Column, line_number: LineNumber) -> Result<()> {
self.ops.push(Opcode::Clear)?;
if line_number.is_some() {
let sym = self.symbol_for_line_number(line_number)?;
self.unlinked.insert(self.ops.len(), (col, sym));
}
self.ops.push(Opcode::Jump(0))
}
pub fn push_symbol(&mut self, sym: Symbol) {
if self
.symbols
.insert(sym, (self.ops.len(), self.data.len()))
.is_some()
{
debug_assert!(false, "Symbol already exists.");
}
}
pub fn set_start_of_direct(&mut self, op_addr: Address) {
self.direct_set = true;
self.symbols.insert(
LineNumber::max_value() as isize + 1 as Symbol,
(op_addr, self.data.len()),
);
}
pub fn line_number_for(&self, op_addr: Address) -> LineNumber {
for (line_number, (symbol_addr, _)) in self.symbols.range(0..).rev() {
if op_addr >= *symbol_addr {
if *line_number <= LineNumber::max_value() as isize {
return Some(*line_number as u16);
} else {
return None;
}
}
}
None
}
pub fn link(&mut self) -> Vec<Error> {
let mut errors: Vec<Error> = vec![];
for (op_addr, (col, symbol)) in std::mem::take(&mut self.unlinked) {
match self.symbols.get(&symbol) {
None => {
if symbol >= 0 {
let error = error!(UndefinedLine, self.line_number_for(op_addr), ..&col);
errors.push(error);
continue;
}
}
Some((op_dest, data_dest)) => {
if let Some(op) = self.ops.get_mut(op_addr) {
if let Some(new_op) = match op {
Opcode::IfNot(_) => Some(Opcode::IfNot(*op_dest)),
Opcode::Jump(_) => Some(Opcode::Jump(*op_dest)),
Opcode::Literal(Val::Return(_)) => {
Some(Opcode::Literal(Val::Return(*op_dest)))
}
Opcode::Literal(Val::Next(_)) => {
Some(Opcode::Literal(Val::Next(*op_dest)))
}
Opcode::Restore(_) => Some(Opcode::Restore(*data_dest)),
_ => None,
} {
*op = new_op;
continue;
}
}
}
}
let line_number = self.line_number_for(op_addr);
errors.push(error!(InternalError, line_number, ..&col; "LINK FAILURE"));
}
self.symbols = self.symbols.split_off(&0);
self.current_symbol = 0;
errors
}
}
impl TryFrom<Link> for LineNumber {
type Error = Error;
fn try_from(mut prog: Link) -> std::result::Result<Self, Self::Error> {
if prog.ops.len() == 1 {
match prog.ops.pop() {
Ok(Opcode::Literal(val)) => return Ok(LineNumber::try_from(val)?),
Err(e) => return Err(e),
_ => {}
}
}
Err(error!(UndefinedLine; "INVALID LINE NUMBER"))
}
}