excel_lib/lexer/
token.rs

1use nom::*; 
2use std::iter::Enumerate;
3use std::ops::{Range, RangeFrom, RangeFull, RangeTo};
4use std::fmt; 
5
6#[derive(Debug, Clone)]
7pub enum Token {
8    //Literal
9    Integer(i64),
10    Float(f64),
11    Boolean(bool), 
12    Text(String), 
13    // Error
14    Null, 
15    Div, 
16    Value, 
17    Ref, 
18    Name, 
19    Num, 
20    NA, 
21    GettingData, 
22    // References
23    MultiSheet(String), 
24    Sheet(String), 
25    Range(String), 
26    Cell(String), 
27    VRange(String), 
28    HRange(String), 
29    // Symbols
30    Plus,
31    Minus,
32    Divide,
33    Multiply,
34    Exponent, 
35    Ampersand, 
36    Equal,
37	Exclamation, 
38    Comma,
39    Period, 
40    Colon,
41    SemiColon,
42    LAngle,
43    RAngle, 
44    LParen,
45    RParen,
46    LBrace,
47    RBrace,
48    LBracket,
49    RBracket,
50    Ident(String), 
51    EOF
52}
53
54impl PartialEq for Token {
55    fn eq(&self, other: &Self) -> bool {
56        self.to_string() == other.to_string()
57    }
58}
59
60impl Eq for Token { }
61
62impl fmt::Display for Token {
63    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
64        match self {
65            Token::Integer(i) => write!(f, "{}", i), 
66            Token::Float(x) => write!(f, "{}", x), 
67            Token::Boolean(b) => {
68                if *b {
69                    write!(f, "TRUE")
70                } else {
71                    write!(f, "FALSE")
72                }
73            }, 
74            Token::Text(s) => write!(f, "{}", s), 
75            Token::MultiSheet(s) => write!(f, "{}", s), 
76            Token::Sheet(s) => write!(f, "{}", s), 
77            Token::Range(s) => write!(f, "{}", s), 
78            Token::Cell(s) => write!(f, "{}", s), 
79            Token::VRange(s) => write!(f, "{}", s), 
80            Token::HRange(s) => write!(f, "{}", s), 
81            Token::Ident(s) => write!(f, "{}", s), 
82            Token::Null => write!(f, "#NULL!"), 
83            Token::Div => write!(f, "#DIV/0!"), 
84            Token::Value => write!(f, "#VALUE!"),
85            Token::Ref => write!(f, "#REF!"), 
86            Token::Name => write!(f, "#NAME!"), 
87            Token::Num => write!(f, "#NUM!"), 
88            Token::NA => write!(f, "#N/A!"), 
89            Token::GettingData => write!(f, "#GETTING_DATA"), 
90            Token::Plus => write!(f, "+"), 
91            Token::Minus => write!(f, "-"), 
92            Token::Divide => write!(f, "/"), 
93            Token::Multiply => write!(f, "*"), 
94            Token::Exponent => write!(f, "^"), 
95            Token::Ampersand => write!(f, "&"), 
96            Token::Equal => write!(f, "="), 
97            Token::Exclamation => write!(f, "!"), 
98            Token::Comma => write!(f, ","), 
99            Token::Period => write!(f, "."), 
100            Token::Colon => write!(f, ":"), 
101            Token::SemiColon => write!(f, ";"), 
102            Token::LAngle => write!(f, "<"), 
103            Token::RAngle => write!(f, ">"), 
104            Token::LParen => write!(f, "("), 
105            Token::RParen => write!(f, ")"), 
106            Token::LBrace => write!(f, "{{"), 
107            Token::RBrace => write!(f, "}}"), 
108            Token::LBracket => write!(f, "["), 
109            Token::RBracket => write!(f, "]"), 
110            Token::EOF => write!(f, ""), 
111        }
112    }
113}
114
115#[derive(Clone, Copy, PartialEq, Eq, Debug)]
116pub struct Tokens<'a> {
117    pub tok: &'a [Token], 
118    pub start: usize, 
119    pub end: usize, 
120}
121
122impl<'a> Tokens<'a> {
123    pub fn new(vec: &'a [Token]) -> Self {
124        Tokens {
125            tok: vec,
126            start: 0,
127            end: vec.len(),
128        }
129    }
130}
131
132impl<'a> InputLength for Tokens<'a> {
133    fn input_len(&self) -> usize {
134        self.tok.len()
135    }
136}
137
138impl<'a> InputTake for Tokens<'a> {
139    fn take(&self, count: usize) -> Self {
140        Tokens {
141            tok: &self.tok[0..count],
142            start: 0,
143            end: count,
144        }
145    }
146
147    fn take_split(&self, count: usize) -> (Self, Self) {
148        let (prefix, suffix) = self.tok.split_at(count);
149        let first = Tokens {
150            tok: prefix,
151            start: 0,
152            end: prefix.len(),
153        };
154        let second = Tokens {
155            tok: suffix,
156            start: 0,
157            end: suffix.len(),
158        };
159        (second, first)
160    }
161}
162
163impl InputLength for Token {
164    fn input_len(&self) -> usize {
165        1
166    }
167}
168
169impl<'a> Slice<Range<usize>> for Tokens<'a> {
170    fn slice(&self, range: Range<usize>) -> Self {
171        Tokens {
172            tok: self.tok.slice(range.clone()),
173            start: self.start + range.start,
174            end: self.start + range.end,
175        }
176    }
177}
178
179impl<'a> Slice<RangeTo<usize>> for Tokens<'a> {
180    fn slice(&self, range: RangeTo<usize>) -> Self {
181        self.slice(0..range.end)
182    }
183}
184
185impl<'a> Slice<RangeFrom<usize>> for Tokens<'a> {
186    #[inline]
187    fn slice(&self, range: RangeFrom<usize>) -> Self {
188        self.slice(range.start..self.end - self.start)
189    }
190}
191
192impl<'a> Slice<RangeFull> for Tokens<'a> {
193    #[inline]
194    fn slice(&self, _: RangeFull) -> Self {
195        Tokens {
196            tok: self.tok,
197            start: self.start,
198            end: self.end,
199        }
200    }
201}
202
203impl<'a> InputIter for Tokens<'a> {
204    type Item = &'a Token;
205    type Iter = Enumerate<::std::slice::Iter<'a, Token>>;
206    type IterElem = ::std::slice::Iter<'a, Token>;
207
208    #[inline]
209    fn iter_indices(&self) -> Enumerate<::std::slice::Iter<'a, Token>> {
210        self.tok.iter().enumerate()
211    }
212    #[inline]
213    fn iter_elements(&self) -> ::std::slice::Iter<'a, Token> {
214        self.tok.iter()
215    }
216    #[inline]
217    fn position<P>(&self, predicate: P) -> Option<usize>
218    where
219        P: Fn(Self::Item) -> bool,
220    {
221        self.tok.iter().position(predicate)
222    }
223    #[inline]
224    fn slice_index(&self, count: usize) -> Result<usize, Needed> {
225        if self.tok.len() >= count {
226            Ok(count)
227        } else {
228            Err(Needed::Unknown)
229        }
230    }
231}
232
233impl<'a> UnspecializedInput for Tokens<'a> { }
excel_lib/lexer/token.rs

excel_lib/lexer/
token.rs
