simple_json 0.2.3

A simple runtime JSON parser.
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

use std::iter::Peekable;
use std::str::Chars;

use error::Error;
use json::Json;
use number::Number;

pub fn number(slice: &mut Peekable<&mut Chars>) -> Result<Json, Error>
{
    let mut token = String::new();

    #[derive(Debug, PartialEq)]
    enum Stages {
        Sign,
        AfterSign,
        AfterZero,
        Integer,
        AfterDot,
        Fraction,
        AfterExp,
        AfterExpSign,
        Exponent,
        End,
    }

    let mut stage       = Stages::Sign;
    let mut is_unsigned = true;

    'tokenizer: loop {
        let current = match slice.peek() {
            Some(chr) => *chr,
            None      => { break 'tokenizer },
        };

        match stage {
            // Waiting for sign or number.
            Stages::Sign => match current {
                '-'       => { stage = Stages::AfterSign; is_unsigned = false; token.push(current); slice.next(); },
                '0'       => { stage = Stages::AfterZero; token.push(current); slice.next(); },
                '1'...'9' => { stage = Stages::Integer;   token.push(current); slice.next(); },

                // Waiting for a number.
                _ => {
                    return Err(Error::InvalidCharacter(current.to_string()));
                },
            },
            Stages::AfterSign => match current {
                '0'       => { stage = Stages::AfterZero; token.push(current); slice.next(); },
                '1'...'9' => { stage = Stages::Integer;   token.push(current); slice.next(); },
                '.'       => { stage = Stages::AfterDot;  token.push(current); slice.next(); },
                'e' | 'E' => { stage = Stages::AfterExp;  token.push(current); slice.next(); },

                // Waiting for a number.
                _ => {
                    return Err(Error::InvalidCharacter(current.to_string()));
                },
            },
            Stages::AfterZero => match current {
                '.'       => { stage = Stages::AfterDot; token.push(current); slice.next(); },
                'e' | 'E' => { stage = Stages::AfterExp; token.push(current); slice.next(); },
                _         => { break 'tokenizer; },
            },
            Stages::Integer => match current {
                '0'...'9' => { stage = Stages::Integer;   token.push(current); slice.next(); },
                '.'       => { stage = Stages::AfterDot;  token.push(current); slice.next(); },
                'e' | 'E' => { stage = Stages::AfterExp;  token.push(current); slice.next(); },
                _         => { break 'tokenizer; },
            },
            Stages::AfterDot => match current {
                '0'...'9' => { stage = Stages::Fraction; token.push(current); slice.next(); },
                'e' | 'E' => { stage = Stages::AfterExp; token.push(current); slice.next(); },

                // Waiting for a number.
                _ => {
                    return Err(Error::InvalidCharacter(current.to_string()));
                },
            },
            Stages::Fraction => match current {
                '0'...'9' => { stage = Stages::Fraction; token.push(current); slice.next(); },
                'e' | 'E' => { stage = Stages::AfterExp; token.push(current); slice.next(); },
                _         => { break 'tokenizer; },
            },
            Stages::AfterExp => match current {
                '+' | '-' => { stage = Stages::AfterExpSign; token.push(current); slice.next(); },
                '0'       => { stage = Stages::End;          token.push(current); slice.next(); },
                '1'...'9' => { stage = Stages::Exponent;     token.push(current); slice.next(); },

                // Waiting for a number.
                _ => {
                    return Err(Error::InvalidCharacter(current.to_string()));
                },
            },
            Stages::AfterExpSign => match current {
                '1'...'9' => { stage = Stages::Exponent; token.push(current); slice.next(); },

                // Waiting for a number.
                _ => {
                    return Err(Error::InvalidCharacter(current.to_string()));
                },
            },
            Stages::Exponent => match current {
                '0'...'9' => { token.push(current); slice.next(); },
                _         => { break 'tokenizer; },
            },
            Stages::End => match current {
                _         => { break 'tokenizer; },
            },
        }
    }

    Ok(Json::Number(
        match stage {
            Stages::Integer | Stages::AfterZero => {
                if is_unsigned {
                    Number::Unsigned(token.parse::<u64>().unwrap())
                } else {
                    Number::Integer(token.parse::<i64>().unwrap())
                }
            },
            _ => {
                Number::Float(token.parse::<f64>().unwrap())
            },
        }
    ))
}