hence/henceforth/src/lib/compiler/instruction.rs

use anyhow::{bail, Result};

use crate::compiler;

#[derive(Debug, Clone, PartialEq)]
pub enum Instruction {
    Nop,
    Debug,
    Quit,
    Push(u16),
    Drop,
    Depth,
    Pick,
    Dup,
    Swap,
    Over,
    Rot,
    Nip,
    I,
    J,
    Tuck,
    Fetch,
    FetchPrint,
    Store,
    PlusStore,
    MinusStore,
    Cells,
    Allot,
    Dot,
    Emit,
    Space,
    Spaces,
    Cr,
    DotQuote(usize),
    Count,
    Not,
    And,
    Nand,
    Or,
    Nor,
    Xor,
    Xnor,
    Lsh,
    Rsh,
    Compare,
    Eq,
    Neq,
    Lt,
    Leq,
    Gt,
    Geq,
    Min,
    Max,
    Boolean,
    Invert,
    Plus,
    OnePlus,
    TwoPlus,
    Minus,
    OneMinus,
    TwoMinus,
    Times,
    Divide,
    Mod,
    Call(String),
}

impl Instruction {
    pub fn from_word(word: &str) -> Option<Self> {
        match word.to_lowercase().as_str() {
            "nop" => Some(Instruction::Nop),
            "debug" => Some(Instruction::Debug),
            "quit" => Some(Instruction::Quit),
            "drop" => Some(Instruction::Drop),
            "depth" => Some(Instruction::Depth),
            "pick" => Some(Instruction::Pick),
            "dup" => Some(Instruction::Dup),
            "swap" => Some(Instruction::Swap),
            "over" => Some(Instruction::Over),
            "rot" => Some(Instruction::Rot),
            "nip" => Some(Instruction::Nip),
            "i" => Some(Instruction::I),
            "j" => Some(Instruction::J),
            "tuck" => Some(Instruction::Tuck),
            "@" => Some(Instruction::Fetch),
            "?" => Some(Instruction::FetchPrint),
            "!" => Some(Instruction::Store),
            "+!" => Some(Instruction::PlusStore),
            "-!" => Some(Instruction::MinusStore),
            "cells" => Some(Instruction::Cells),
            "allot" => Some(Instruction::Allot),
            "." => Some(Instruction::Dot),
            "emit" => Some(Instruction::Emit),
            "space" => Some(Instruction::Space),
            "spaces" => Some(Instruction::Spaces),
            "cr" => Some(Instruction::Cr),
            "count" => Some(Instruction::Count),
            "not" => Some(Instruction::Not),
            "and" => Some(Instruction::And),
            "nand" => Some(Instruction::Nand),
            "or" => Some(Instruction::Or),
            "nor" => Some(Instruction::Nor),
            "xor" => Some(Instruction::Xor),
            "xnor" => Some(Instruction::Xnor),
            "lshift" => Some(Instruction::Lsh),
            "rshift" => Some(Instruction::Rsh),
            "compare" => Some(Instruction::Compare),
            "=" => Some(Instruction::Eq),
            "!=" => Some(Instruction::Neq),
            "<" => Some(Instruction::Lt),
            "<=" => Some(Instruction::Leq),
            ">" => Some(Instruction::Gt),
            ">=" => Some(Instruction::Geq),
            "min" => Some(Instruction::Min),
            "max" => Some(Instruction::Max),
            "boolean" => Some(Instruction::Boolean),
            "invert" => Some(Instruction::Invert),
            "+" => Some(Instruction::Plus),
            "1+" => Some(Instruction::OnePlus),
            "2+" => Some(Instruction::TwoPlus),
            "-" => Some(Instruction::Minus),
            "1-" => Some(Instruction::OneMinus),
            "2-" => Some(Instruction::TwoMinus),
            "*" => Some(Instruction::Times),
            "/" => Some(Instruction::Divide),
            "mod" => Some(Instruction::Mod),
            _ => None,
        }
    }
}

impl compiler::Compilable<compiler::Data, hence::parser::ast::Body> for Instruction {
    fn compile(&self, data: &compiler::Data) -> Result<hence::parser::ast::Body> {
        match self {
            Instruction::Nop => Ok(vec![hence::parser::ast::Node::Call {
                name: "nop".to_string(),
                arg: None,
            }]),
            Instruction::Debug => Ok(vec![hence::parser::ast::Node::Call {
                name: "dbg".to_string(),
                arg: None,
            }]),
            Instruction::Quit => Ok(vec![hence::parser::ast::Node::MacroCall {
                name: "std_stop".to_string(),
                args: vec![],
            }]),
            Instruction::Push(x) => Ok(vec![hence::parser::ast::Node::Call {
                name: "push".to_string(),
                arg: Some(hence::arg::Arg::Number(*x)),
            }]),
            Instruction::Drop => Ok(vec![hence::parser::ast::Node::Call {
                name: "pop".to_string(),
                arg: None,
            }]),
            Instruction::Depth => Ok(vec![
                hence::parser::ast::Node::Call {
                    name: "tsr".to_string(),
                    arg: Some(hence::arg::Arg::Variable("CORE_REG_SP".to_string())),
                },
                hence::parser::ast::Node::Call {
                    name: "tls".to_string(),
                    arg: None,
                },
            ]),
            Instruction::Pick => Ok(vec![]),
            Instruction::Dup => Ok(vec![
                hence::parser::ast::Node::Call {
                    name: "tss".to_string(),
                    arg: None,
                },
                hence::parser::ast::Node::Call {
                    name: "tls".to_string(),
                    arg: None,
                },
            ]),
            Instruction::Swap => Ok(vec![
                hence::parser::ast::Node::MacroCall {
                    name: "std_ld".to_string(),
                    args: vec![],
                },
                hence::parser::ast::Node::Call {
                    name: "tlr".to_string(),
                    arg: Some(hence::arg::Arg::Variable("CORE_REG_A".to_string())),
                },
                hence::parser::ast::Node::MacroCall {
                    name: "std_ld".to_string(),
                    args: vec![],
                },
                hence::parser::ast::Node::Call {
                    name: "tlr".to_string(),
                    arg: Some(hence::arg::Arg::Variable("CORE_REG_B".to_string())),
                },
                hence::parser::ast::Node::Call {
                    name: "tsr".to_string(),
                    arg: Some(hence::arg::Arg::Variable("CORE_REG_A".to_string())),
                },
                hence::parser::ast::Node::Call {
                    name: "tls".to_string(),
                    arg: None,
                },
                hence::parser::ast::Node::Call {
                    name: "tsr".to_string(),
                    arg: Some(hence::arg::Arg::Variable("CORE_REG_B".to_string())),
                },
                hence::parser::ast::Node::Call {
                    name: "tls".to_string(),
                    arg: None,
                },
            ]),
            Instruction::Over => Ok(vec![
                hence::parser::ast::Node::MacroCall {
                    name: "std_ld".to_string(),
                    args: vec![],
                },
                hence::parser::ast::Node::Call {
                    name: "tlr".to_string(),
                    arg: Some(hence::arg::Arg::Variable("CORE_REG_A".to_string())),
                },
                hence::parser::ast::Node::Call {
                    name: "tss".to_string(),
                    arg: None,
                },
                hence::parser::ast::Node::Call {
                    name: "tlr".to_string(),
                    arg: Some(hence::arg::Arg::Variable("CORE_REG_B".to_string())),
                },
                hence::parser::ast::Node::Call {
                    name: "tsr".to_string(),
                    arg: Some(hence::arg::Arg::Variable("CORE_REG_A".to_string())),
                },
                hence::parser::ast::Node::Call {
                    name: "tls".to_string(),
                    arg: None,
                },
                hence::parser::ast::Node::Call {
                    name: "tsr".to_string(),
                    arg: Some(hence::arg::Arg::Variable("CORE_REG_B".to_string())),
                },
                hence::parser::ast::Node::Call {
                    name: "tls".to_string(),
                    arg: None,
                },
            ]),
            Instruction::Rot => Ok(vec![]),
            Instruction::Nip => Ok(vec![]),
            Instruction::I => Ok(vec![]),
            Instruction::J => Ok(vec![]),
            Instruction::Tuck => Ok(vec![]),
            Instruction::Fetch => Ok(vec![]),
            Instruction::FetchPrint => Ok(vec![]),
            Instruction::Store => Ok(vec![]),
            Instruction::PlusStore => Ok(vec![]),
            Instruction::MinusStore => Ok(vec![]),
            Instruction::Cells => Ok(vec![]),
            Instruction::Allot => Ok(vec![]),
            Instruction::Dot => Ok(vec![
                hence::parser::ast::Node::MacroCall {
                    name: "std_ld".to_string(),
                    args: vec![],
                },
                hence::parser::ast::Node::Call {
                    name: "tlr".to_string(),
                    arg: Some(hence::arg::Arg::Variable("CORE_REG_A".to_string())),
                },
                hence::parser::ast::Node::MacroCall {
                    name: "std_set".to_string(),
                    args: vec![hence::arg::Arg::Variable("CORE_MEM_OUT".to_string())],
                },
            ]),
            Instruction::Emit => Ok(vec![
                hence::parser::ast::Node::MacroCall {
                    name: "std_ld".to_string(),
                    args: vec![],
                },
                hence::parser::ast::Node::Call {
                    name: "tlr".to_string(),
                    arg: Some(hence::arg::Arg::Variable("CORE_REG_A".to_string())),
                },
                hence::parser::ast::Node::MacroCall {
                    name: "std_set".to_string(),
                    args: vec![hence::arg::Arg::Variable("CORE_MEM_CHR".to_string())],
                },
            ]),
            Instruction::Space => Ok(vec![]),
            Instruction::Spaces => Ok(vec![]),
            Instruction::Cr => Ok(vec![
                hence::parser::ast::Node::MacroCall {
                    name: "std_rset".to_string(),
                    args: vec![
                        hence::arg::Arg::Variable("CORE_REG_A".to_string()),
                        hence::arg::Arg::Number(0x0a),
                    ],
                },
                hence::parser::ast::Node::MacroCall {
                    name: "std_set".to_string(),
                    args: vec![hence::arg::Arg::Variable("CORE_MEM_CHR".to_string())],
                },
            ]),
            Instruction::DotQuote(x) => {
                let loop_label = format!("loop_strings_{}", x);
                let data_label = format!("data_strings_{}", x);
                let data_end_label = format!("data_strings_end_{}", x);

                Ok(vec![
                    hence::parser::ast::Node::MacroCall {
                        name: "std_rset".to_string(),
                        args: vec![
                            hence::arg::Arg::Variable("CORE_REG_B".to_string()),
                            hence::arg::Arg::Variable(data_label),
                        ],
                    },
                    hence::parser::ast::Node::Label(loop_label.clone()),
                    hence::parser::ast::Node::Call {
                        name: "tsr".to_string(),
                        arg: Some(hence::arg::Arg::Variable("CORE_REG_B".to_string())),
                    },
                    hence::parser::ast::Node::Call {
                        name: "get".to_string(),
                        arg: None,
                    },
                    hence::parser::ast::Node::Call {
                        name: "tlr".to_string(),
                        arg: Some(hence::arg::Arg::Variable("CORE_REG_A".to_string())),
                    },
                    hence::parser::ast::Node::MacroCall {
                        name: "std_set".to_string(),
                        args: vec![hence::arg::Arg::Variable("CORE_MEM_CHR".to_string())],
                    },
                    hence::parser::ast::Node::MacroCall {
                        name: "std_rset".to_string(),
                        args: vec![
                            hence::arg::Arg::Variable("CORE_REG_A".to_string()),
                            hence::arg::Arg::Number(1),
                        ],
                    },
                    hence::parser::ast::Node::MacroCall {
                        name: "std_alu".to_string(),
                        args: vec![hence::arg::Arg::Variable("CORE_ALU_ADD".to_string())],
                    },
                    hence::parser::ast::Node::Call {
                        name: "tlr".to_string(),
                        arg: Some(hence::arg::Arg::Variable("CORE_REG_B".to_string())),
                    },
                    hence::parser::ast::Node::MacroCall {
                        name: "std_rset".to_string(),
                        args: vec![
                            hence::arg::Arg::Variable("CORE_REG_A".to_string()),
                            hence::arg::Arg::Variable(data_end_label),
                        ],
                    },
                    hence::parser::ast::Node::MacroCall {
                        name: "std_alu".to_string(),
                        args: vec![hence::arg::Arg::Variable("CORE_ALU_GT".to_string())],
                    },
                    hence::parser::ast::Node::Call {
                        name: "tlr".to_string(),
                        arg: Some(hence::arg::Arg::Variable("CORE_REG_A".to_string())),
                    },
                    hence::parser::ast::Node::MacroCall {
                        name: "std_cond_jump".to_string(),
                        args: vec![hence::arg::Arg::Variable(loop_label)],
                    },
                ])
            }
            Instruction::Count => Ok(vec![]),
            Instruction::Not => Ok(vec![]),
            Instruction::And => Ok(vec![]),
            Instruction::Nand => Ok(vec![]),
            Instruction::Or => Ok(vec![]),
            Instruction::Nor => Ok(vec![]),
            Instruction::Xor => Ok(vec![]),
            Instruction::Xnor => Ok(vec![]),
            Instruction::Lsh => Ok(vec![]),
            Instruction::Rsh => Ok(vec![]),
            Instruction::Compare => Ok(vec![]),
            Instruction::Eq => Ok(vec![]),
            Instruction::Neq => Ok(vec![]),
            Instruction::Lt => Ok(vec![]),
            Instruction::Leq => Ok(vec![]),
            Instruction::Gt => Ok(vec![]),
            Instruction::Geq => Ok(vec![]),
            Instruction::Min => Ok(vec![]),
            Instruction::Max => Ok(vec![]),
            Instruction::Boolean => Ok(vec![]),
            Instruction::Invert => Ok(vec![]),
            Instruction::Plus => Ok(vec![
                hence::parser::ast::Node::MacroCall {
                    name: "stack_transfer_alu".to_string(),
                    args: vec![],
                },
                hence::parser::ast::Node::MacroCall {
                    name: "std_alu".to_string(),
                    args: vec![hence::arg::Arg::Variable("CORE_ALU_ADD".to_string())],
                },
                hence::parser::ast::Node::Call {
                    name: "tls".to_string(),
                    arg: None,
                },
            ]),
            Instruction::OnePlus => Ok(vec![
                hence::parser::ast::Node::MacroCall {
                    name: "std_ld".to_string(),
                    args: vec![],
                },
                hence::parser::ast::Node::Call {
                    name: "tlr".to_string(),
                    arg: Some(hence::arg::Arg::Variable("CORE_REG_A".to_string())),
                },
                hence::parser::ast::Node::MacroCall {
                    name: "std_rset".to_string(),
                    args: vec![
                        hence::arg::Arg::Variable("CORE_REG_B".to_string()),
                        hence::arg::Arg::Number(1),
                    ],
                },
                hence::parser::ast::Node::MacroCall {
                    name: "std_alu".to_string(),
                    args: vec![hence::arg::Arg::Variable("CORE_ALU_ADD".to_string())],
                },
                hence::parser::ast::Node::Call {
                    name: "tls".to_string(),
                    arg: None,
                },
            ]),
            Instruction::TwoPlus => Ok(vec![
                hence::parser::ast::Node::MacroCall {
                    name: "std_ld".to_string(),
                    args: vec![],
                },
                hence::parser::ast::Node::Call {
                    name: "tlr".to_string(),
                    arg: Some(hence::arg::Arg::Variable("CORE_REG_A".to_string())),
                },
                hence::parser::ast::Node::MacroCall {
                    name: "std_rset".to_string(),
                    args: vec![
                        hence::arg::Arg::Variable("CORE_REG_B".to_string()),
                        hence::arg::Arg::Number(2),
                    ],
                },
                hence::parser::ast::Node::MacroCall {
                    name: "std_alu".to_string(),
                    args: vec![hence::arg::Arg::Variable("CORE_ALU_ADD".to_string())],
                },
                hence::parser::ast::Node::Call {
                    name: "tls".to_string(),
                    arg: None,
                },
            ]),
            Instruction::Minus => Ok(vec![
                hence::parser::ast::Node::MacroCall {
                    name: "stack_transfer_alu".to_string(),
                    args: vec![],
                },
                hence::parser::ast::Node::MacroCall {
                    name: "std_alu".to_string(),
                    args: vec![hence::arg::Arg::Variable("CORE_ALU_SUB".to_string())],
                },
                hence::parser::ast::Node::Call {
                    name: "tls".to_string(),
                    arg: None,
                },
            ]),
            Instruction::OneMinus => Ok(vec![
                hence::parser::ast::Node::MacroCall {
                    name: "std_ld".to_string(),
                    args: vec![],
                },
                hence::parser::ast::Node::Call {
                    name: "tlr".to_string(),
                    arg: Some(hence::arg::Arg::Variable("CORE_REG_A".to_string())),
                },
                hence::parser::ast::Node::MacroCall {
                    name: "std_rset".to_string(),
                    args: vec![
                        hence::arg::Arg::Variable("CORE_REG_B".to_string()),
                        hence::arg::Arg::Number(1),
                    ],
                },
                hence::parser::ast::Node::MacroCall {
                    name: "std_alu".to_string(),
                    args: vec![hence::arg::Arg::Variable("CORE_ALU_SUB".to_string())],
                },
                hence::parser::ast::Node::Call {
                    name: "tls".to_string(),
                    arg: None,
                },
            ]),
            Instruction::TwoMinus => Ok(vec![
                hence::parser::ast::Node::MacroCall {
                    name: "std_ld".to_string(),
                    args: vec![],
                },
                hence::parser::ast::Node::Call {
                    name: "tlr".to_string(),
                    arg: Some(hence::arg::Arg::Variable("CORE_REG_A".to_string())),
                },
                hence::parser::ast::Node::MacroCall {
                    name: "std_rset".to_string(),
                    args: vec![
                        hence::arg::Arg::Variable("CORE_REG_B".to_string()),
                        hence::arg::Arg::Number(2),
                    ],
                },
                hence::parser::ast::Node::MacroCall {
                    name: "std_alu".to_string(),
                    args: vec![hence::arg::Arg::Variable("CORE_ALU_SUB".to_string())],
                },
                hence::parser::ast::Node::Call {
                    name: "tls".to_string(),
                    arg: None,
                },
            ]),
            Instruction::Times => Ok(vec![
                hence::parser::ast::Node::MacroCall {
                    name: "stack_transfer_alu".to_string(),
                    args: vec![],
                },
                hence::parser::ast::Node::MacroCall {
                    name: "std_alu".to_string(),
                    args: vec![hence::arg::Arg::Variable("CORE_ALU_MUL".to_string())],
                },
                hence::parser::ast::Node::Call {
                    name: "tls".to_string(),
                    arg: None,
                },
            ]),
            Instruction::Divide => Ok(vec![
                hence::parser::ast::Node::MacroCall {
                    name: "stack_transfer_alu".to_string(),
                    args: vec![],
                },
                hence::parser::ast::Node::MacroCall {
                    name: "std_alu".to_string(),
                    args: vec![hence::arg::Arg::Variable("CORE_ALU_DIV".to_string())],
                },
                hence::parser::ast::Node::Call {
                    name: "tls".to_string(),
                    arg: None,
                },
            ]),
            Instruction::Mod => Ok(vec![]),
            Instruction::Call(x) => match data.words.get(x) {
                Some(w) => {
                    if w.times_used > 1 {
                        Ok(vec![hence::parser::ast::Node::MacroCall {
                            name: "call_word".to_string(),
                            args: vec![hence::arg::Arg::Variable(format!("words_{}", w.id))],
                        }])
                    } else {
                        Ok(w.instructions
                            .iter()
                            .map(|ins| ins.compile(data))
                            .collect::<Result<Vec<hence::parser::ast::Body>>>()?
                            .into_iter()
                            .flatten()
                            .collect())
                    }
                }
                None => bail!("Unknown word: {}", x),
            },
        }
    }
}