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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
|
use super::*;
use std::cmp::Ordering;
use std::ffi::OsString;
#[cfg(target_family = "unix")]
use std::os::unix::ffi::OsStringExt;
#[cfg(target_family = "windows")]
use std::os::windows::ffi::OsStringExt;
#[derive(Clone)]
pub struct BedrockFilePath {
base: PathBuf,
relative: PathBuf,
bytes: Vec<u8>,
}
impl BedrockFilePath {
pub fn from_buffer(buffer: [u8; 256], base: &Path) -> Option<Self> {
let base = base.to_path_buf();
let relative = buffer_to_path(buffer)?;
let bytes = path_to_bytes(&relative)?;
assert_path_is_safe(&relative)?;
Some(Self { base, relative, bytes })
}
/// Construct an instance from an absolute path and a prefix of that path.
pub fn from_path(path: &Path, base: &Path) -> Option<Self> {
let base = base.to_path_buf();
let relative = path.strip_prefix(&base).ok()?.to_path_buf();
let bytes = path_to_bytes(&relative)?;
assert_path_is_safe(&relative)?;
Some( Self { base, relative, bytes } )
}
/// Get the base path used by this path.
pub fn base(&self) -> &Path {
&self.base
}
/// Get this path as a Bedrock-style path, which can be passed to
/// a Bedrock program.
pub fn as_bytes(&self) -> &[u8] {
&self.bytes
}
/// Get this path as a byte buffer, from which a CircularPathBuffer
/// can be populated.
pub fn as_buffer(&self) -> [u8; 256] {
let mut buffer: [u8; 256] = [0; 256];
buffer[..self.bytes.len()].copy_from_slice(&self.bytes);
return buffer;
}
/// Get this path as an absolute operating-system path, which can
/// be used to open a file or directory.
pub fn as_path(&self) -> PathBuf {
self.base.join(&self.relative)
}
/// Get a path which represents the parent of this path.
pub fn parent(&self) -> Option<Self> {
let relative = self.relative.parent()?.to_path_buf();
let base = self.base.clone();
let bytes = path_to_bytes(&relative)?;
Some( Self { base, relative, bytes } )
}
pub fn directory_listing(&self) -> Option<DirectoryListing> {
DirectoryListing::from_path(&self)
}
/// Returns true if a dot character directly follows the final
/// forward-slash character in the relative path.
pub fn filename_is_dot_prefixed(&self) -> bool {
let bytes = self.as_bytes();
let mut dot_i = 0;
for (i, b) in bytes.iter().enumerate() {
if *b == b'/' {
// Guaranteed to be a valid index, bytes is null-terminated.
dot_i = i + 1;
} else if *b == 0x00 {
break;
}
}
return bytes[dot_i] == b'.';
}
}
/// Converts the contents of a CircularPathBuffer to a relative path.
fn buffer_to_path(bytes: [u8; 256]) -> Option<PathBuf> {
// The buffer must be non-empty and slash-prefixed.
if bytes[0] != ('/' as u8) {
return None;
}
// Find the index of the first null byte.
let mut null_i = None;
for (i, b) in bytes.iter().enumerate() {
if *b == 0x00 {
null_i = Some(i);
break;
}
}
// Take a slice, excluding the leading slash, up to the trailing null.
let slice = &bytes[1..null_i?];
#[cfg(target_family = "unix")] {
let vec = Vec::from(slice);
return Some(OsString::from_vec(vec).into())
}
#[cfg(target_family = "windows")] {
let string = String::from_utf8_lossy(slice);
let utf16: Vec<u16> = string.replace(r"/", r"\").encode_utf16().collect();
return Some(OsString::from_wide(&utf16).into())
}
}
/// Convert an operating system path to a Bedrock-style byte path.
///
/// A byte path contains at most 255 bytes, and is not null-terminated.
fn path_to_bytes(path: &Path) -> Option<Vec<u8>> {
let mut string = String::from("/");
#[cfg(target_family = "unix")]
string.push_str(path.as_os_str().to_str()?);
#[cfg(target_family = "windows")]
string.push_str(&path.as_os_str().to_str()?.replace(r"\", r"/"));
// Remove all trailing forward-slash characters.
let slice = string.trim_end_matches('/').as_bytes();
// Error if bytes does not fit into a CircularPathBuffer.
if slice.len() > 255 { return None; }
Some(Vec::from(slice))
}
/// Returns true if a path contains only normal components.
fn assert_path_is_safe(relative: &Path) -> Option<()> {
// Error if path contains special components.
for component in relative.components() {
match component {
Component::Normal(_) => continue,
_ => return None,
}
}
return Some(());
}
// ---------------------------------------------------------------------------
impl PartialEq for BedrockFilePath {
fn eq(&self, other: &Self) -> bool {
self.bytes == other.bytes
}
}
impl Eq for BedrockFilePath {}
impl PartialOrd for BedrockFilePath {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(self.cmp(other))
}
}
impl Ord for BedrockFilePath {
fn cmp(&self, other: &Self) -> Ordering {
compare_ascii_slices(&self.bytes, &other.bytes)
}
}
// Compare two ASCII byte-slices in case-agnostic alphabetic order.
fn compare_ascii_slices(left: &[u8], right: &[u8]) -> Ordering {
let l = std::cmp::min(left.len(), right.len());
let lhs = &left[..l];
let rhs = &right[..l];
for i in 0..l {
let a = remap_ascii(lhs[i]);
let b = remap_ascii(rhs[i]);
match a.cmp(&b) {
Ordering::Equal => (),
non_eq => return non_eq,
}
}
left.len().cmp(&right.len())
}
// Remap ASCII values so that they sort in case-agnostic alphabetic order:
// !"#$%&'()*+,-./0123456789:;<=>?
// @`AaBbCcDdEeFfGgHhIiJjKkLlMmNnOo
// PpQqRrSsTtUuVvWwXxYyZz[{\|]}^~_
fn remap_ascii(c: u8) -> u8 {
if 0x40 <= c && c <= 0x5F {
(c - 0x40) * 2 + 0x40
} else if 0x60 <= c && c <= 0x7F {
(c - 0x60) * 2 + 0x41
} else {
c
}
}
|
