]>
Commit | Line | Data |
---|---|---|
9fa01778 XL |
1 | use crate::leb128::{self, read_signed_leb128, write_signed_leb128}; |
2 | use crate::serialize; | |
c30ab7b3 | 3 | use std::borrow::Cow; |
9cc50fc6 SL |
4 | |
5 | // ----------------------------------------------------------------------------- | |
6 | // Encoder | |
7 | // ----------------------------------------------------------------------------- | |
8 | ||
8faf50e0 | 9 | pub type EncodeResult = Result<(), !>; |
9e0c209e | 10 | |
8faf50e0 XL |
11 | pub struct Encoder { |
12 | pub data: Vec<u8>, | |
9cc50fc6 SL |
13 | } |
14 | ||
8faf50e0 XL |
15 | impl Encoder { |
16 | pub fn new(data: Vec<u8>) -> Encoder { | |
17 | Encoder { data } | |
9cc50fc6 | 18 | } |
2c00a5a8 | 19 | |
8faf50e0 XL |
20 | pub fn into_inner(self) -> Vec<u8> { |
21 | self.data | |
2c00a5a8 | 22 | } |
9cc50fc6 | 23 | |
b7449926 | 24 | #[inline] |
8faf50e0 XL |
25 | pub fn emit_raw_bytes(&mut self, s: &[u8]) { |
26 | self.data.extend_from_slice(s); | |
27 | } | |
28 | } | |
9cc50fc6 SL |
29 | |
30 | macro_rules! write_uleb128 { | |
2c00a5a8 | 31 | ($enc:expr, $value:expr, $fun:ident) => {{ |
8faf50e0 | 32 | leb128::$fun(&mut $enc.data, $value); |
9cc50fc6 SL |
33 | Ok(()) |
34 | }} | |
35 | } | |
36 | ||
37 | macro_rules! write_sleb128 { | |
38 | ($enc:expr, $value:expr) => {{ | |
8faf50e0 | 39 | write_signed_leb128(&mut $enc.data, $value as i128); |
9cc50fc6 SL |
40 | Ok(()) |
41 | }} | |
42 | } | |
43 | ||
8faf50e0 XL |
44 | impl serialize::Encoder for Encoder { |
45 | type Error = !; | |
9cc50fc6 | 46 | |
2c00a5a8 | 47 | #[inline] |
b7449926 | 48 | fn emit_unit(&mut self) -> EncodeResult { |
9cc50fc6 SL |
49 | Ok(()) |
50 | } | |
51 | ||
2c00a5a8 | 52 | #[inline] |
9e0c209e | 53 | fn emit_usize(&mut self, v: usize) -> EncodeResult { |
2c00a5a8 | 54 | write_uleb128!(self, v, write_usize_leb128) |
9cc50fc6 SL |
55 | } |
56 | ||
2c00a5a8 | 57 | #[inline] |
32a655c1 | 58 | fn emit_u128(&mut self, v: u128) -> EncodeResult { |
2c00a5a8 | 59 | write_uleb128!(self, v, write_u128_leb128) |
32a655c1 SL |
60 | } |
61 | ||
2c00a5a8 | 62 | #[inline] |
9cc50fc6 | 63 | fn emit_u64(&mut self, v: u64) -> EncodeResult { |
2c00a5a8 | 64 | write_uleb128!(self, v, write_u64_leb128) |
9cc50fc6 SL |
65 | } |
66 | ||
2c00a5a8 | 67 | #[inline] |
9cc50fc6 | 68 | fn emit_u32(&mut self, v: u32) -> EncodeResult { |
2c00a5a8 | 69 | write_uleb128!(self, v, write_u32_leb128) |
9cc50fc6 SL |
70 | } |
71 | ||
2c00a5a8 | 72 | #[inline] |
9cc50fc6 | 73 | fn emit_u16(&mut self, v: u16) -> EncodeResult { |
2c00a5a8 | 74 | write_uleb128!(self, v, write_u16_leb128) |
9cc50fc6 SL |
75 | } |
76 | ||
2c00a5a8 | 77 | #[inline] |
9cc50fc6 | 78 | fn emit_u8(&mut self, v: u8) -> EncodeResult { |
8faf50e0 | 79 | self.data.push(v); |
9cc50fc6 SL |
80 | Ok(()) |
81 | } | |
82 | ||
2c00a5a8 | 83 | #[inline] |
9e0c209e | 84 | fn emit_isize(&mut self, v: isize) -> EncodeResult { |
9cc50fc6 SL |
85 | write_sleb128!(self, v) |
86 | } | |
87 | ||
2c00a5a8 | 88 | #[inline] |
32a655c1 SL |
89 | fn emit_i128(&mut self, v: i128) -> EncodeResult { |
90 | write_sleb128!(self, v) | |
91 | } | |
92 | ||
2c00a5a8 | 93 | #[inline] |
9cc50fc6 SL |
94 | fn emit_i64(&mut self, v: i64) -> EncodeResult { |
95 | write_sleb128!(self, v) | |
96 | } | |
97 | ||
2c00a5a8 | 98 | #[inline] |
9cc50fc6 SL |
99 | fn emit_i32(&mut self, v: i32) -> EncodeResult { |
100 | write_sleb128!(self, v) | |
101 | } | |
102 | ||
2c00a5a8 | 103 | #[inline] |
9cc50fc6 SL |
104 | fn emit_i16(&mut self, v: i16) -> EncodeResult { |
105 | write_sleb128!(self, v) | |
106 | } | |
107 | ||
2c00a5a8 | 108 | #[inline] |
9cc50fc6 SL |
109 | fn emit_i8(&mut self, v: i8) -> EncodeResult { |
110 | let as_u8: u8 = unsafe { ::std::mem::transmute(v) }; | |
2c00a5a8 | 111 | self.emit_u8(as_u8) |
9cc50fc6 SL |
112 | } |
113 | ||
2c00a5a8 | 114 | #[inline] |
9cc50fc6 SL |
115 | fn emit_bool(&mut self, v: bool) -> EncodeResult { |
116 | self.emit_u8(if v { | |
117 | 1 | |
118 | } else { | |
119 | 0 | |
120 | }) | |
121 | } | |
122 | ||
2c00a5a8 | 123 | #[inline] |
9cc50fc6 SL |
124 | fn emit_f64(&mut self, v: f64) -> EncodeResult { |
125 | let as_u64: u64 = unsafe { ::std::mem::transmute(v) }; | |
126 | self.emit_u64(as_u64) | |
127 | } | |
128 | ||
2c00a5a8 | 129 | #[inline] |
9cc50fc6 SL |
130 | fn emit_f32(&mut self, v: f32) -> EncodeResult { |
131 | let as_u32: u32 = unsafe { ::std::mem::transmute(v) }; | |
132 | self.emit_u32(as_u32) | |
133 | } | |
134 | ||
2c00a5a8 | 135 | #[inline] |
9cc50fc6 SL |
136 | fn emit_char(&mut self, v: char) -> EncodeResult { |
137 | self.emit_u32(v as u32) | |
138 | } | |
139 | ||
2c00a5a8 | 140 | #[inline] |
9cc50fc6 | 141 | fn emit_str(&mut self, v: &str) -> EncodeResult { |
9e0c209e | 142 | self.emit_usize(v.len())?; |
8faf50e0 | 143 | self.emit_raw_bytes(v.as_bytes()); |
9cc50fc6 SL |
144 | Ok(()) |
145 | } | |
9cc50fc6 SL |
146 | } |
147 | ||
8faf50e0 | 148 | impl Encoder { |
2c00a5a8 | 149 | #[inline] |
9cc50fc6 | 150 | pub fn position(&self) -> usize { |
8faf50e0 | 151 | self.data.len() |
9cc50fc6 | 152 | } |
9cc50fc6 SL |
153 | } |
154 | ||
155 | // ----------------------------------------------------------------------------- | |
156 | // Decoder | |
157 | // ----------------------------------------------------------------------------- | |
158 | ||
159 | pub struct Decoder<'a> { | |
160 | pub data: &'a [u8], | |
161 | position: usize, | |
162 | } | |
163 | ||
164 | impl<'a> Decoder<'a> { | |
0731742a | 165 | #[inline] |
9cc50fc6 SL |
166 | pub fn new(data: &'a [u8], position: usize) -> Decoder<'a> { |
167 | Decoder { | |
3b2f2976 XL |
168 | data, |
169 | position, | |
9cc50fc6 SL |
170 | } |
171 | } | |
172 | ||
2c00a5a8 | 173 | #[inline] |
9cc50fc6 SL |
174 | pub fn position(&self) -> usize { |
175 | self.position | |
176 | } | |
177 | ||
2c00a5a8 | 178 | #[inline] |
ff7c6d11 XL |
179 | pub fn set_position(&mut self, pos: usize) { |
180 | self.position = pos | |
181 | } | |
182 | ||
2c00a5a8 | 183 | #[inline] |
9cc50fc6 SL |
184 | pub fn advance(&mut self, bytes: usize) { |
185 | self.position += bytes; | |
186 | } | |
2c00a5a8 | 187 | |
b7449926 | 188 | #[inline] |
2c00a5a8 XL |
189 | pub fn read_raw_bytes(&mut self, s: &mut [u8]) -> Result<(), String> { |
190 | let start = self.position; | |
191 | let end = start + s.len(); | |
192 | ||
193 | s.copy_from_slice(&self.data[start..end]); | |
194 | ||
195 | self.position = end; | |
196 | ||
197 | Ok(()) | |
198 | } | |
9cc50fc6 SL |
199 | } |
200 | ||
201 | macro_rules! read_uleb128 { | |
2c00a5a8 XL |
202 | ($dec:expr, $t:ty, $fun:ident) => ({ |
203 | let (value, bytes_read) = leb128::$fun(&$dec.data[$dec.position ..]); | |
9cc50fc6 | 204 | $dec.position += bytes_read; |
2c00a5a8 | 205 | Ok(value) |
9cc50fc6 SL |
206 | }) |
207 | } | |
208 | ||
209 | macro_rules! read_sleb128 { | |
210 | ($dec:expr, $t:ty) => ({ | |
211 | let (value, bytes_read) = read_signed_leb128($dec.data, $dec.position); | |
212 | $dec.position += bytes_read; | |
213 | Ok(value as $t) | |
214 | }) | |
215 | } | |
216 | ||
217 | ||
218 | impl<'a> serialize::Decoder for Decoder<'a> { | |
9e0c209e | 219 | type Error = String; |
9cc50fc6 | 220 | |
c30ab7b3 | 221 | #[inline] |
9cc50fc6 SL |
222 | fn read_nil(&mut self) -> Result<(), Self::Error> { |
223 | Ok(()) | |
224 | } | |
225 | ||
32a655c1 SL |
226 | #[inline] |
227 | fn read_u128(&mut self) -> Result<u128, Self::Error> { | |
2c00a5a8 | 228 | read_uleb128!(self, u128, read_u128_leb128) |
32a655c1 SL |
229 | } |
230 | ||
c30ab7b3 | 231 | #[inline] |
9cc50fc6 | 232 | fn read_u64(&mut self) -> Result<u64, Self::Error> { |
2c00a5a8 | 233 | read_uleb128!(self, u64, read_u64_leb128) |
9cc50fc6 SL |
234 | } |
235 | ||
c30ab7b3 | 236 | #[inline] |
9cc50fc6 | 237 | fn read_u32(&mut self) -> Result<u32, Self::Error> { |
2c00a5a8 | 238 | read_uleb128!(self, u32, read_u32_leb128) |
9cc50fc6 SL |
239 | } |
240 | ||
c30ab7b3 | 241 | #[inline] |
9cc50fc6 | 242 | fn read_u16(&mut self) -> Result<u16, Self::Error> { |
2c00a5a8 | 243 | read_uleb128!(self, u16, read_u16_leb128) |
9cc50fc6 SL |
244 | } |
245 | ||
c30ab7b3 | 246 | #[inline] |
9cc50fc6 SL |
247 | fn read_u8(&mut self) -> Result<u8, Self::Error> { |
248 | let value = self.data[self.position]; | |
249 | self.position += 1; | |
250 | Ok(value) | |
251 | } | |
252 | ||
c30ab7b3 | 253 | #[inline] |
9e0c209e | 254 | fn read_usize(&mut self) -> Result<usize, Self::Error> { |
2c00a5a8 | 255 | read_uleb128!(self, usize, read_usize_leb128) |
9cc50fc6 SL |
256 | } |
257 | ||
32a655c1 SL |
258 | #[inline] |
259 | fn read_i128(&mut self) -> Result<i128, Self::Error> { | |
260 | read_sleb128!(self, i128) | |
261 | } | |
262 | ||
c30ab7b3 | 263 | #[inline] |
9cc50fc6 SL |
264 | fn read_i64(&mut self) -> Result<i64, Self::Error> { |
265 | read_sleb128!(self, i64) | |
266 | } | |
267 | ||
c30ab7b3 | 268 | #[inline] |
9cc50fc6 SL |
269 | fn read_i32(&mut self) -> Result<i32, Self::Error> { |
270 | read_sleb128!(self, i32) | |
271 | } | |
272 | ||
c30ab7b3 | 273 | #[inline] |
9cc50fc6 SL |
274 | fn read_i16(&mut self) -> Result<i16, Self::Error> { |
275 | read_sleb128!(self, i16) | |
276 | } | |
277 | ||
c30ab7b3 | 278 | #[inline] |
9cc50fc6 SL |
279 | fn read_i8(&mut self) -> Result<i8, Self::Error> { |
280 | let as_u8 = self.data[self.position]; | |
281 | self.position += 1; | |
282 | unsafe { Ok(::std::mem::transmute(as_u8)) } | |
283 | } | |
284 | ||
c30ab7b3 | 285 | #[inline] |
9e0c209e | 286 | fn read_isize(&mut self) -> Result<isize, Self::Error> { |
9cc50fc6 SL |
287 | read_sleb128!(self, isize) |
288 | } | |
289 | ||
c30ab7b3 | 290 | #[inline] |
9cc50fc6 | 291 | fn read_bool(&mut self) -> Result<bool, Self::Error> { |
54a0048b | 292 | let value = self.read_u8()?; |
9cc50fc6 SL |
293 | Ok(value != 0) |
294 | } | |
295 | ||
c30ab7b3 | 296 | #[inline] |
9cc50fc6 | 297 | fn read_f64(&mut self) -> Result<f64, Self::Error> { |
54a0048b | 298 | let bits = self.read_u64()?; |
9cc50fc6 SL |
299 | Ok(unsafe { ::std::mem::transmute(bits) }) |
300 | } | |
301 | ||
c30ab7b3 | 302 | #[inline] |
9cc50fc6 | 303 | fn read_f32(&mut self) -> Result<f32, Self::Error> { |
54a0048b | 304 | let bits = self.read_u32()?; |
9cc50fc6 SL |
305 | Ok(unsafe { ::std::mem::transmute(bits) }) |
306 | } | |
307 | ||
c30ab7b3 | 308 | #[inline] |
9cc50fc6 | 309 | fn read_char(&mut self) -> Result<char, Self::Error> { |
54a0048b | 310 | let bits = self.read_u32()?; |
9cc50fc6 SL |
311 | Ok(::std::char::from_u32(bits).unwrap()) |
312 | } | |
313 | ||
c30ab7b3 | 314 | #[inline] |
9fa01778 | 315 | fn read_str(&mut self) -> Result<Cow<'_, str>, Self::Error> { |
9e0c209e | 316 | let len = self.read_usize()?; |
9cc50fc6 SL |
317 | let s = ::std::str::from_utf8(&self.data[self.position..self.position + len]).unwrap(); |
318 | self.position += len; | |
c30ab7b3 | 319 | Ok(Cow::Borrowed(s)) |
9cc50fc6 SL |
320 | } |
321 | ||
b7449926 | 322 | #[inline] |
9cc50fc6 | 323 | fn error(&mut self, err: &str) -> Self::Error { |
9e0c209e | 324 | err.to_string() |
9cc50fc6 SL |
325 | } |
326 | } |