sdcx 0.1.0

SDC (Synopsys Design Constraints) toolkit
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

use codespan_reporting::files::{self, Files, SimpleFile};
use std::collections::HashMap;
use std::ops::Range;
use std::path::PathBuf;
use std::sync::Arc;

/// FileDb
#[derive(Clone, Debug)]
pub struct FileDb<Name, Source> {
    files: Vec<SimpleFile<Name, Source>>,
    ids: HashMap<Name, usize>,
}

impl<Name, Source> Default for FileDb<Name, Source> {
    fn default() -> Self {
        Self {
            files: Vec::new(),
            ids: HashMap::new(),
        }
    }
}

impl<Name, Source> FileDb<Name, Source>
where
    Name: std::fmt::Display + Clone + PartialEq + Eq + std::hash::Hash,
    Source: AsRef<str>,
{
    /// Create a new files database.
    pub fn new() -> Self {
        Self::default()
    }

    /// Add a file to the database, returning the handle that can be used to
    /// refer to it again.
    pub fn add(&mut self, name: Name, source: Source) -> usize {
        let file_id = self.files.len();
        self.files.push(SimpleFile::new(name.clone(), source));
        self.ids.insert(name, file_id);
        file_id
    }

    /// Get the file corresponding to the given id.
    pub fn get(&self, file_id: usize) -> Result<&SimpleFile<Name, Source>, files::Error> {
        self.files.get(file_id).ok_or(files::Error::FileMissing)
    }

    pub fn get_id(&self, name: &Name) -> Option<usize> {
        self.ids.get(name).copied()
    }
}

impl<'a, Name, Source> Files<'a> for FileDb<Name, Source>
where
    Name: 'a + std::fmt::Display + Clone + PartialEq + Eq + std::hash::Hash,
    Source: 'a + AsRef<str>,
{
    type FileId = usize;
    type Name = Name;
    type Source = &'a str;

    fn name(&self, file_id: usize) -> Result<Name, files::Error> {
        Ok(self.get(file_id)?.name().clone())
    }

    fn source(&self, file_id: usize) -> Result<&str, files::Error> {
        Ok(self.get(file_id)?.source().as_ref())
    }

    fn line_index(&self, file_id: usize, byte_index: usize) -> Result<usize, files::Error> {
        self.get(file_id)?.line_index((), byte_index)
    }

    fn line_range(&self, file_id: usize, line_index: usize) -> Result<Range<usize>, files::Error> {
        self.get(file_id)?.line_range((), line_index)
    }
}

/// Location
#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
pub struct Location {
    pub start_byte: u32,
    pub start_line: u32,
    pub start_column: u32,
    pub end_line: u32,
    pub end_column: u32,
    pub length: u32,
    pub file_name: Arc<PathBuf>,
}

impl Location {
    pub(crate) fn from_to(from: &Location, to: &Location) -> Location {
        Location {
            start_byte: from.start_byte,
            start_line: from.start_line,
            start_column: to.start_column,
            end_line: to.end_line,
            end_column: to.end_column,
            length: to.start_byte - from.start_byte + to.length,
            file_name: from.file_name.clone(),
        }
    }

    pub(crate) fn range_file(&self, files: &FileDb<String, &str>) -> (Range<usize>, usize) {
        let range: Range<usize> = self.into();
        let file_id = files.get_id(&self.file_name.display().to_string()).unwrap();
        (range, file_id)
    }
}

impl From<&Location> for Range<usize> {
    fn from(value: &Location) -> Self {
        Range {
            start: value.start_byte as usize,
            end: (value.start_byte + value.length) as usize,
        }
    }
}

impl From<&parol_runtime::Location> for Location {
    fn from(value: &parol_runtime::Location) -> Self {
        let start_byte = value.scanner_switch_pos as u32 + value.offset as u32 - value.length;
        Location {
            start_byte,
            start_line: value.start_line,
            start_column: value.start_column,
            end_line: value.end_line,
            end_column: value.end_column,
            length: value.length,
            file_name: value.file_name.clone(),
        }
    }
}