neyuki 0.6.1

A small Lua-like scripting language implemented in Rust
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

//! Number literals.

use super::scanner::Scanner;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum NumberFormat {
    Decimal,
    Hexadecimal,
    Binary,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum NumberType {
    Integer,
    Float,
}

pub struct NumberResult<'a> {
    pub raw: &'a str,
    pub format: NumberFormat,
    pub num_type: NumberType,
}

pub struct NumberEngine;

impl NumberEngine {
    #[inline(always)]
    pub fn is_number_start(scanner: &Scanner<'_>) -> bool {
        let ch = scanner.peek();
        ch.is_ascii_digit()
            || (ch == '.' && scanner.peek_next().is_some_and(|c| c.is_ascii_digit()))
    }

    pub fn scan_number<'a>(scanner: &mut Scanner<'a>) -> NumberResult<'a> {
        let start = scanner.pos();
        let mut is_float = false;

        // Check hex prefix 0x / 0X
        if scanner.peek() == '0' && matches!(scanner.peek_next(), Some('x' | 'X')) {
            scanner.advance();
            scanner.advance();
            while !scanner.is_at_end()
                && (scanner.peek().is_ascii_hexdigit() || scanner.peek() == '_')
            {
                scanner.advance();
            }
            if scanner.peek() == '.' {
                is_float = true;
                scanner.advance();
                while !scanner.is_at_end()
                    && (scanner.peek().is_ascii_hexdigit() || scanner.peek() == '_')
                {
                    scanner.advance();
                }
            }
            if matches!(scanner.peek(), 'p' | 'P') {
                is_float = true;
                scanner.advance();
                if matches!(scanner.peek(), '+' | '-') {
                    scanner.advance();
                }
                while !scanner.is_at_end() && scanner.peek().is_ascii_digit() {
                    scanner.advance();
                }
            }
            return NumberResult {
                raw: scanner.slice_from(start),
                format: NumberFormat::Hexadecimal,
                num_type: if is_float {
                    NumberType::Float
                } else {
                    NumberType::Integer
                },
            };
        }

        // Check binary prefix 0b / 0B
        if scanner.peek() == '0' && matches!(scanner.peek_next(), Some('b' | 'B')) {
            scanner.advance();
            scanner.advance();
            while !scanner.is_at_end() && matches!(scanner.peek(), '0' | '1' | '_') {
                scanner.advance();
            }
            return NumberResult {
                raw: scanner.slice_from(start),
                format: NumberFormat::Binary,
                num_type: NumberType::Integer,
            };
        }

        // Decimal digits
        while !scanner.is_at_end() && (scanner.peek().is_ascii_digit() || scanner.peek() == '_') {
            scanner.advance();
        }

        // Fractional part
        if scanner.peek() == '.' && scanner.peek_next() != Some('.') {
            is_float = true;
            scanner.advance();
            while !scanner.is_at_end() && (scanner.peek().is_ascii_digit() || scanner.peek() == '_')
            {
                scanner.advance();
            }
        }

        // Exponent part
        if matches!(scanner.peek(), 'e' | 'E') {
            is_float = true;
            scanner.advance();
            if matches!(scanner.peek(), '+' | '-') {
                scanner.advance();
            }
            while !scanner.is_at_end() && scanner.peek().is_ascii_digit() {
                scanner.advance();
            }
        }

        NumberResult {
            raw: scanner.slice_from(start),
            format: NumberFormat::Decimal,
            num_type: if is_float {
                NumberType::Float
            } else {
                NumberType::Integer
            },
        }
    }
}