flexar 1.2.6

An extremely flexible lexer/parser (get it?) for writing your own programming language
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

use std::{rc::Rc, fmt::Display};

use crate::{flext::Flext, token_node::Token, cursor::Position};

/// Parser context for parsing
#[derive(Debug, Clone, Copy)]
pub struct Parxt<'a, TT: Display> {
    pub tokens: &'a [Token<TT>],
    pub idx: u16,
    pub done: bool,
}

impl<'a, TT: Display> Parxt<'a, TT> {
    #[inline]
    pub fn new(tokens: &'a [Token<TT>]) -> Self {
        Self {
            tokens,
            idx: 0,
            done: tokens.is_empty(),
        }
    }

    #[inline]
    pub fn current_token(&self) -> Option<&'a Token<TT>> {
        self.tokens.get(self.idx as usize)
    }

    #[inline]
    pub fn current(&self) -> Option<&'a TT> {
        self.current_token().map(|x| &x.token_type)
    }

    #[inline]
    fn get_last_pos(&self) -> Position {
        if self.tokens.is_empty() { panic!("file's empty, gonna add code to handle that later") }
        let mut position = self.tokens[self.tokens.len() -1].position.clone();
        let mut end = (*position.1).clone();
        end.ln_idx += 1;
        let end = Rc::new(end);
        (position.0, position.1) = (end.clone(), end);
        position
    }
}

impl<'a, TT: Display> Flext for Parxt<'a, TT> {
    /// Advances to the next token
    #[inline]
    fn advance(&mut self) {
        self.idx += 1;
    }

    /// Un-Advances
    #[inline]
    fn revance(&mut self) {
        if self.idx != 0 {
            self.idx -= 1;
        }
    }

    /// Spawns a child flext
    #[inline]
    fn spawn(&self) -> Self {
        Self { tokens: self.tokens, idx: self.idx, done: self.done, }
    }

    /// Gets the current position of the cursor
    #[inline]
    fn position(&self) -> Position {
        self.current_token().map(|x| x.position.clone())
            .unwrap_or_else(|| self.get_last_pos())
    }
}