kamo 0.6.0

A library to assist in the creation of an interpreter or compiler and its associated runtime.
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
127
128
129
130
131
132
133
134
135
136
137

use crate::parser::{code, prelude::*, Input, ParseError, ParseResult};

use super::{LiteralError, Radix};

/// Recognizes an integer literal with the given radix.
///
/// If `signed` is `true` the literal can have an optional sign `[+\-]`.
///
/// # Grammar:
///
/// The grammar does not include a prefix for the radix. This is because the
/// radix is already known when parsing the integer literal. You must implement
/// the prefix yourself.
///
/// The rules for `<Digit R>` are generic over `R` which expands to the radix
/// of the integer literal. The radix can be one of the following:
///
/// ```text
/// Integer     = Sign? <Digit R>+
/// Sign        = [+\-]
/// <Digit 2>   = [0-1]
/// <Digit 8>   = [0-7]
/// <Digit 10>  = [0-9]
/// <Digit 16>  = [0-9A-Fa-f]
///
/// R = 2 | 8 | 10 | 16
/// ```
pub fn recognize_integer(
    radix: Radix,
    signed: bool,
) -> impl for<'a> Fn(Input<'a>) -> ParseResult<'a, &str> {
    move |input| {
        match signed {
            true => recognize(tuple((opt(any((char('+'), char('-')))), radix.digit1())))(input),
            false => recognize(radix.digit1())(input),
        }
        .map_err(|mut err| {
            err.push(input, code::ERR_INTEGER_FORMAT, LiteralError::IntegerFormat);
            err
        })
    }
}

/// Parses an integer literal with the given radix.
///
/// If `signed` is `true` the literal can have an optional sign `[+\-]`.
///
/// The grammar is the same as the one for `recognize_integer` except that it
/// parses the value instead of recognizing it. Returns the value as a `i64`.
///
/// The grammar does not include a prefix for the radix. This is because the
/// radix is already known when parsing the integer literal. You must implement
/// the prefix yourself.
pub fn integer(radix: Radix, signed: bool) -> impl for<'a> Fn(Input<'a>) -> ParseResult<'a, i64> {
    move |input| {
        let (output, input) = recognize_integer(radix, signed)(input)?;
        let value = i64::from_str_radix(output, radix.base()).map_err(|_| {
            ParseError::new(input, code::ERR_INTEGER, LiteralError::Integer).and_semantic()
        })?;

        Ok((value, input))
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    const INTEGERS: [(&str, Radix); 42] = [
        ("0", Radix::Binary),
        ("0", Radix::Octal),
        ("0", Radix::Decimal),
        ("0", Radix::Hexadecimal),
        ("1", Radix::Binary),
        ("1", Radix::Octal),
        ("1", Radix::Decimal),
        ("1", Radix::Hexadecimal),
        ("0101010", Radix::Binary),
        ("01234567", Radix::Octal),
        ("0123456789", Radix::Decimal),
        ("0123456789", Radix::Hexadecimal),
        ("abcdef", Radix::Hexadecimal),
        ("ABCDEF", Radix::Hexadecimal),
        ("+0", Radix::Binary),
        ("+0", Radix::Octal),
        ("+0", Radix::Decimal),
        ("+0", Radix::Hexadecimal),
        ("+1", Radix::Binary),
        ("+1", Radix::Octal),
        ("+1", Radix::Decimal),
        ("+1", Radix::Hexadecimal),
        ("+0101010", Radix::Binary),
        ("+01234567", Radix::Octal),
        ("+0123456789", Radix::Decimal),
        ("+0123456789", Radix::Hexadecimal),
        ("+abcdef", Radix::Hexadecimal),
        ("+ABCDEF", Radix::Hexadecimal),
        ("-0", Radix::Binary),
        ("-0", Radix::Octal),
        ("-0", Radix::Decimal),
        ("-0", Radix::Hexadecimal),
        ("-1", Radix::Binary),
        ("-1", Radix::Octal),
        ("-1", Radix::Decimal),
        ("-1", Radix::Hexadecimal),
        ("-0101010", Radix::Binary),
        ("-01234567", Radix::Octal),
        ("-0123456789", Radix::Decimal),
        ("-0123456789", Radix::Hexadecimal),
        ("-abcdef", Radix::Hexadecimal),
        ("-ABCDEF", Radix::Hexadecimal),
    ];

    #[test]
    fn recognize_integer_success() {
        for (value, radix) in INTEGERS.iter() {
            let input = Input::new(value);
            let result = recognize_integer(*radix, true)(input);
            assert_eq!(result, Ok((*value, Input::new(""))));
        }
    }

    #[test]
    fn integer_success() {
        for (value, radix) in INTEGERS.iter() {
            let input = Input::new(value);
            let result = integer(*radix, true)(input);
            assert_eq!(
                result,
                Ok((
                    i64::from_str_radix(value, radix.base()).unwrap(),
                    Input::new("")
                ))
            );
        }
    }
}