nano_parser_gen 0.2.1

A parser generator inspired by yacc (types and functions)
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

use crate::error::source_quote::SourceQuote;
use std::ops::Range;

#[derive(Debug, PartialEq, Eq, Clone)]
pub struct Location {
    pub line: usize,
    pub span: std::ops::Range<usize>,
}

impl Location {
    pub fn merge(&self, l2: &Location) -> Self {
        if self.line != l2.line {
            self.clone()
        } else {
            let min = self.span.start.min(l2.span.start);
            let max = self.span.end.max(l2.span.end);
            Location {
                line: self.line,
                span: min..max,
            }
        }
    }
}

impl std::fmt::Display for Location {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}:{}", self.line, self.span.start)
    }
}

#[derive(Debug, Clone)]
pub struct SourceFile {
    pub filename: String,
    pub content: String,
    line_sizes: Vec<usize>,
}

impl SourceFile {
    fn calculate_line_sizes(content: &str) -> Vec<usize> {
        content.split('\n').map(|s| s.len() + 1).collect()
    }

    pub fn open(filename: &str) -> Result<Self, std::io::Error> {
        let content = std::fs::read_to_string(filename)?;
        Ok(Self {
            filename: filename.to_string(),
            line_sizes: Self::calculate_line_sizes(&content),
            content,
        })
    }

    pub fn remaining(&self, pos: usize) -> &str {
        &self.content[pos..]
    }

    pub fn span(&self, range: std::ops::Range<usize>) -> &str {
        &self.content[range]
    }

    pub fn len(&self) -> usize {
        self.content.len()
    }

    pub fn range_to_location(&self, range: std::ops::Range<usize>) -> Location {
        let len = range.end - range.start;
        let mut pos = range.start;
        let mut line = 0;
        for l in &self.line_sizes {
            if pos >= *l {
                line += 1;
                pos -= *l;
            } else {
                break;
            }
        }
        Location {
            line,
            span: pos..pos + len,
        }
    }

    pub fn get_line(&self, i: usize) -> &str {
        if i > self.line_sizes.len() {
            panic!("Out of range line {i}");
        }
        let start = self.line_sizes[..i].iter().sum();
        let len = self.line_sizes[i] - 1;
        &self.content[start..start + len]
    }

    pub fn quote(&self, lines: Range<usize>) -> SourceQuote {
        let mut lines_vec = Vec::new();
        let first_line = lines.start;
        for l in lines {
            lines_vec.push(self.get_line(l));
        }
        SourceQuote::new(&self.filename, lines_vec, first_line)
    }

    pub fn quote_line(&self, line: usize) -> SourceQuote {
        SourceQuote::new(&self.filename, vec![self.get_line(line)], line)
    }
}

impl From<&str> for SourceFile {
    fn from(s: &str) -> SourceFile {
        SourceFile {
            filename: "dummy".to_owned(),
            content: s.to_owned(),
            line_sizes: Self::calculate_line_sizes(s),
        }
    }
}