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

use crate::{ExpectTree, Token, TokenKind, TokenVec};

#[derive(Debug, Eq, PartialEq)]
pub enum DeserError {
    EndOfTokenList,
    NumberTooLarge,
    NumberTooSmall,
    UnexpectedToken,
    Unbuildable,
}

pub struct Tracker<'a, 'b> {
    expect: &'b mut ExpectTree<Token<'static>>,
    tokenvec: &'b mut TokenVec<'a>,
    steps: usize,
}

pub type Result<T> = std::result::Result<T, DeserError>;

impl<'a, 'b> Tracker<'a, 'b> {
    pub fn new(expect: &'b mut ExpectTree<Token<'static>>, tokenvec: &'b mut TokenVec<'a>) -> Self {
        Self {
            expect,
            tokenvec,
            steps: 0,
        }
    }

    pub fn possible_token(&mut self, token: Token<'static>) {
        self.expect.advance(token);
        self.expect.retract_one();
    }

    pub fn try_token(&mut self, token: &Token<'static>) -> Result<bool> {
        if !self.tokenvec.has_remaining() {
            let mut token = token.clone();
            if let Some(last) = self.expect.last() {
                if let TokenKind::Comma = &last.kind {
                    if last.space_suffix() == 0 {
                        token.space_diff += 1;
                    }
                }
            } else if self.steps == 0 {
                token.space_diff += 1;
            }
            self.expect.advance(token);
            Ok(false)
        } else if self.tokenvec.top().similar(token) {
            self.step();
            Ok(true)
        } else if self.tokenvec.top().is_prefix_of(token) {
            self.expect.advance(token.clone());
            Ok(false)
        } else {
            Err(DeserError::UnexpectedToken)
        }
    }

    pub fn has_remaining(&self) -> bool {
        self.tokenvec.has_remaining()
    }

    pub fn top(&self) -> &Token<'a> {
        self.tokenvec.top()
    }

    pub fn top_kind(&self) -> &TokenKind {
        &self.top().kind
    }

    pub fn step(&mut self) {
        *self.expect = ExpectTree::new();
        self.tokenvec.step();
        self.steps += 1;
    }
}

pub trait Deser: Sized {
    fn deser<'a, 'b>(_tracker: &mut Tracker<'a, 'b>) -> Result<Self> {
        return Err(DeserError::Unbuildable);
    }
}

mod basic;
mod btreemap;
mod derefs;
mod hashmap;
mod hashset;
mod instant;
mod mutex;
mod refcell;
mod tuple;
mod vec;