xod 1.0.1

A tiny REPL for bitwise arithmetic and expression evaluation.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

pub mod ast;
pub mod bitops;
pub mod compare;
pub mod exprs;
pub mod funcs;
pub mod general;
pub mod loops;
pub mod numbers;
pub mod utils;

use self::exprs::NumOrList;
use crate::repl::help::{EW, NE, NS, SE};
use color_print::{cformat, cwriteln};
use nom_locate::LocatedSpan;
use std::collections::BTreeMap;
use std::fmt;
use std::sync::Mutex;

pub static VARIABLES: Mutex<BTreeMap<String, NumOrList>> = Mutex::new(BTreeMap::new());

pub type Span<'a> = LocatedSpan<&'a str>;

pub enum XodErr<I> {
    Parse(I, nom::error::ErrorKind),
    Incomplete(I, nom::Needed),
}

#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
pub enum ExprError<'a> {
    #[error("{0}")]
    Partial(PartialEvalError<'a>),
    #[error("Exiting...")]
    Quit,
    #[error("Help requested.")]
    Help,
    #[error("Printing history...")]
    History,
    #[error("Clearing screen...")]
    Clear,
}

impl<'a> From<PartialEvalError<'a>> for ExprError<'a> {
    fn from(value: PartialEvalError<'a>) -> Self {
        Self::Partial(value)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
#[error("Error parsing {loc:#?}. {msg} {fix}")]
pub struct PartialEvalError<'a> {
    pub loc: Span<'a>,
    pub msg: String,
    pub fix: String,
}

impl<'a> From<(PartialEvalError<'a>, Span<'a>)> for EvalError<'a> {
    fn from(value: (PartialEvalError<'a>, Span<'a>)) -> Self {
        Self {
            msg: value.0.msg,
            loc: value.0.loc,
            body: value.1,
            fix: value.0.fix,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
pub struct EvalError<'a> {
    pub msg: String,
    pub loc: Span<'a>,
    pub body: Span<'a>,
    pub fix: String,
}

impl fmt::Display for EvalError<'_> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        cwriteln!(f, "<s><r!>error</>: {}</>", self.msg)?;
        let start = self.loc.naive_get_utf8_column();
        let end = self.loc.fragment().len();
        let line = self.loc.location_line() as usize - 1;
        cwriteln!(
            f,
            "   <s><b!>{SE}{EW}></> line {line}, cols {start}-{}</>",
            start + end,
        )?;
        let sep_line = cformat!("<s><b!>{NS}</></>");
        writeln!(f, "   {sep_line}")?;
        let space = vec![' '; start - 1].into_iter().collect::<String>();
        let underline = cformat!("<s><c!>{}</></>", vec!['^'; end].iter().collect::<String>());
        let arrow1 = cformat!("<s><c!>{NS}</></>");
        for (i, b) in self.body.split('\n').enumerate() {
            cwriteln!(f, "<s><b!>{i: >2}</> {sep_line}\t{b}")?;
            if i == line {
                writeln!(f, "   {sep_line}\t{space}{underline}")?;
                writeln!(f, "   {sep_line}\t{space}{arrow1}")?;
                cwriteln!(
                    f,
                    "   {sep_line}\t{space}<s><c!>{NE}{EW}</> Suggested fix:</> <g!>{}</>",
                    self.fix
                )?;
            }
        }
        Ok(())
    }
}

pub trait Expression<'a, 'b, T>
where
    'a: 'b,
    T: 'a,
{
    fn eval(&'b mut self) -> Result<T, ExprError<'a>>;
}

pub trait RefSpan<'a> {
    fn get_span<'b>(&self) -> Span<'b>
    where
        'a: 'b;
}

impl<'a> RefSpan<'a> for Span<'a> {
    fn get_span<'b>(&self) -> Span<'b>
    where
        'a: 'b,
    {
        *self
    }
}