zjson 0.1.5

Parse JSON with zero allocation.
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

use crate::status::Status;

use super::ParseNumberError;

pub enum Machine {
    Start { signed: bool },
    InInteger,
    PostInteger,
    PreFraction,
    Fraction,
    PreExponent { signed: bool },
    Exponent,
}

impl Machine {
    pub const fn apply(self, c: char) -> Result<Status<Self, ()>, ParseNumberError> {
        match self {
            Self::Start { signed } => Ok(Status::Parsing(match c {
                '-' if !signed => Self::Start { signed: true },
                '1'..='9' => Self::InInteger,
                '0' => Self::PostInteger,

                _ => return Err(ParseNumberError::ExpectedMinusOrDigit(c)),
            })),

            Self::InInteger => Ok(Status::Parsing(match c {
                '0'..='9' => Self::InInteger,
                '.' => Self::PreFraction,
                'e' | 'E' => Self::PreExponent { signed: false },

                _ => return Ok(Status::Done(())),
            })),

            Self::PostInteger => Ok(Status::Parsing(match c {
                '.' => Self::PreFraction,
                'e' | 'E' => Self::PreExponent { signed: false },

                _ => return Ok(Status::Done(())),
            })),

            Self::PreFraction => {
                if c.is_ascii_digit() {
                    Ok(Status::Parsing(Self::Fraction))
                } else {
                    Err(ParseNumberError::ExpectedDigit(c))
                }
            }

            Self::Fraction => Ok(Status::Parsing(match c {
                '0'..='9' => Self::Fraction,
                'e' | 'E' => Self::PreExponent { signed: false },

                _ => return Ok(Status::Done(())),
            })),

            Self::PreExponent { signed } => Ok(Status::Parsing(match c {
                '-' | '+' if !signed => Self::PreExponent { signed: true },
                '0'..='9' => Self::Exponent,

                _ => return Err(ParseNumberError::ExpectedSignOrDigit(c)),
            })),

            Self::Exponent => Ok(if c.is_ascii_digit() {
                Status::Parsing(Self::Exponent)
            } else {
                Status::Done(())
            }),
        }
    }

    pub const fn valid_end(self) -> Result<(), ParseNumberError> {
        match self {
            Self::InInteger | Self::PostInteger | Self::Fraction | Self::Exponent => Ok(()),

            Self::Start { signed } => Err(ParseNumberError::UnexpectedEnd { or_sign: !signed }),
            Self::PreFraction => Err(ParseNumberError::UnexpectedEnd { or_sign: false }),
            Self::PreExponent { signed } => {
                Err(ParseNumberError::UnexpectedEndAfterExponent { or_sign: !signed })
            }
        }
    }
}