pharos-corefile 0.1.0

Corefile lexer and parser for Pharos
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

/// A Corefile token and its source location.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Token {
    pub file: String,
    pub line: usize,
    pub text: String,
}

pub(crate) fn decode(mut bytes: &[u8]) -> String {
    let mut text = String::new();
    loop {
        match std::str::from_utf8(bytes) {
            Ok(valid) => {
                text.push_str(valid);
                break;
            }
            Err(error) => {
                let end = error.valid_up_to();
                text.push_str(std::str::from_utf8(&bytes[..end]).expect("valid UTF-8 prefix"));
                text.push('\u{fffd}');
                bytes = &bytes[end + 1..];
            }
        }
    }
    text
}

/// Split a Corefile into tokens using the CoreDNS lexer rules.
pub fn lex(file: &str, input: &str) -> Vec<Token> {
    let mut chars = input.strip_prefix('\u{feff}').unwrap_or(input).chars();
    let mut tokens = Vec::new();
    let mut line = 1;
    let mut start = 1;
    let mut text = String::new();
    let mut quoted = false;
    let mut escaped = false;
    let mut comment = false;
    for ch in chars.by_ref() {
        if quoted {
            if !escaped && ch == '\\' {
                escaped = true;
                continue;
            }
            if !escaped && ch == '"' {
                tokens.push(Token {
                    file: file.into(),
                    line: start,
                    text: std::mem::take(&mut text),
                });
                quoted = false;
                continue;
            }
            if ch == '\n' {
                line += 1;
            }
            if escaped && ch != '"' {
                text.push('\\');
            }
            text.push(ch);
            escaped = false;
            continue;
        }
        if ch.is_whitespace() {
            if ch == '\r' {
                continue;
            }
            if ch == '\n' {
                line += 1;
                comment = false;
            }
            if !text.is_empty() {
                tokens.push(Token {
                    file: file.into(),
                    line: start,
                    text: std::mem::take(&mut text),
                });
            }
            continue;
        }
        if ch == '#' {
            comment = true;
        }
        if comment {
            continue;
        }
        if text.is_empty() {
            start = line;
            if ch == '"' {
                quoted = true;
                continue;
            }
        }
        text.push(ch);
    }
    if !text.is_empty() {
        tokens.push(Token {
            file: file.into(),
            line: start,
            text,
        });
    }
    tokens
}