Oregami
Repositories/oxedyne/fe2o3

oxedyne/fe2o3/fe2o3_jdat/src/bdat/load.rs

25.7 KiB, 30 runs

created by r1870400018:451, which is this file's identity for as long as the history lasts, whatever it is later renamed to

download · who wrote it · its history

1use crate::{
2 prelude::*,
3 usr::UsrKindId,
4};
5
6use oxedyne_fe2o3_core::prelude::*;
7
8use std::{
9 convert::TryFrom,
10 io,
11};
12
13
14impl Dat {
15
16 /// Used to read the `Dat::C64` bytes into the provided `byts` buffer, returning the
17 /// actual value of the `C64` as a `usize`.
18 fn load_c64<R: io::Read>(
19 r: &mut R,
20 code: u8,
21 byts: &mut Vec<u8>,
22 )
23 -> Outcome<usize>
24 {
25 match code - Self::C64_CODE_START {
26 1 => {
27 let mut v = [0;1];
28 res!(r.read_exact(&mut v));
29 byts.extend_from_slice(&v[..]);
30 Ok(Self::read_c64_as_usize(&v))
31 },
32 2 => {
33 let mut v = [0;2];
34 res!(r.read_exact(&mut v));
35 byts.extend_from_slice(&v[..]);
36 Ok(Self::read_c64_as_usize(&v))
37 },
38 3 => {
39 let mut v = [0;3];
40 res!(r.read_exact(&mut v));
41 byts.extend_from_slice(&v[..]);
42 Ok(Self::read_c64_as_usize(&v))
43 },
44 4 => {
45 let mut v = [0;4];
46 res!(r.read_exact(&mut v));
47 byts.extend_from_slice(&v[..]);
48 Ok(Self::read_c64_as_usize(&v))
49 },
50 5 => {
51 let mut v = [0;5];
52 res!(r.read_exact(&mut v));
53 byts.extend_from_slice(&v[..]);
54 Ok(Self::read_c64_as_usize(&v))
55 },
56 6 => {
57 let mut v = [0;6];
58 res!(r.read_exact(&mut v));
59 byts.extend_from_slice(&v[..]);
60 Ok(Self::read_c64_as_usize(&v))
61 },
62 7 => {
63 let mut v = [0;7];
64 res!(r.read_exact(&mut v));
65 byts.extend_from_slice(&v[..]);
66 Ok(Self::read_c64_as_usize(&v))
67 },
68 8 => {
69 let mut v = [0;8];
70 res!(r.read_exact(&mut v));
71 byts.extend_from_slice(&v[..]);
72 Ok(Self::read_c64_as_usize(&v))
73 },
74 _ => unreachable!(),
75 }
76 }
77
78 pub fn load_bytes<R: io::Read>(r: &mut R) -> Outcome<Vec<u8>> {
79 let mut byts = Vec::new();
80 res!(Self::load_bytes_muncher(r, &mut byts));
81 Ok(byts)
82 }
83
84 /// Reads a variable payload of `vlen` bytes onto `byts` without trusting
85 /// `vlen` enough to pre-allocate it. A torn or corrupt length header (the
86 /// crash tail of an append-only store, say) can name a payload far larger
87 /// than the reader holds, and `vec![0; vlen]` on such a value aborts the
88 /// whole process before the caller can treat it as the decode error it is:
89 /// a capacity overflow when `vlen` exceeds `isize::MAX`, a failed
90 /// multi-exabyte allocation otherwise. Growing the buffer only as real bytes
91 /// arrive caps the allocation at what the reader actually yields, so an
92 /// implausible length becomes a catchable error instead of a panic.
93 fn load_payload<R: io::Read>(
94 mut r: &mut R,
95 vlen: usize,
96 byts: &mut Vec<u8>,
97 )
98 -> Outcome<()>
99 {
100 let start = byts.len();
101 let mut take = io::Read::take(&mut r, vlen as u64);
102 let got = res!(io::Read::read_to_end(&mut take, byts), Decode, Bytes);
103 if got != vlen {
104 byts.truncate(start);
105 return Err(err!(
106 "A byte payload declared a length of {} but only {} byte(s) were \
107 available before the end of the reader: a torn or corrupt length \
108 header.", vlen, got;
109 Decode, Bytes, Input));
110 }
111 Ok(())
112 }
113
114 /// This method returns the raw bytes for an encoded `Dat`.
115 pub fn load_bytes_muncher<R: io::Read>(
116 mut r: &mut R,
117 mut byts: &mut Vec<u8>,
118 )
119 -> Outcome<()>
120 {
121 let mut dcode = [0;1];
122 match r.read_exact(&mut dcode) {
123 Err(e) => match e.kind() {
124 std::io::ErrorKind::UnexpectedEof => return Ok(()),
125 _ => return Err(err!(e,
126 "While trying to read Dat code from reader.";
127 Decode, Bytes)),
128 },
129 Ok(()) => (),
130 }
131 byts.push(dcode[0]);
132 match dcode[0] {
133 // Atomic Kinds ===========================
134 // Logic
135 Self::EMPTY_CODE |
136 Self::TRUE_CODE |
137 Self::FALSE_CODE |
138 Self::OPT_NONE_CODE => return Ok(()),
139 // Fixed
140 Self::U8_CODE => {
141 // +---+---+
142 // | c | |
143 // +---+---+
144 // \___/
145 // |
146 // u8
147 //
148 let mut v = [0;1];
149 res!(r.read_exact(&mut v));
150 byts.extend_from_slice(&v[..]);
151 return Ok(());
152 },
153 Self::U16_CODE => {
154 // MSB LSB
155 // +---+---+---+
156 // | c | | |
157 // +---+---+---+
158 // \_______/
159 // |
160 // u16
161 //
162 let mut v = [0;2];
163 res!(r.read_exact(&mut v));
164 byts.extend_from_slice(&v[..]);
165 return Ok(());
166 },
167 Self::U32_CODE => {
168 // MSB LSB
169 // +---+---+---+---+---+
170 // | c | | | | |
171 // +---+---+---+---+---+
172 // \_______________/
173 // |
174 // u32
175 //
176 let mut v = [0;4];
177 res!(r.read_exact(&mut v));
178 byts.extend_from_slice(&v[..]);
179 return Ok(());
180 },
181 Self::U64_CODE => {
182 // MSB LSB
183 // +---+---+---+---+---+---+---+---+---+
184 // | c | | | | | | | | |
185 // +---+---+---+---+---+---+---+---+---+
186 // \_______________________________/
187 // |
188 // u64
189 //
190 let mut v = [0;8];
191 res!(r.read_exact(&mut v));
192 byts.extend_from_slice(&v[..]);
193 return Ok(());
194 },
195 Self::U128_CODE => {
196 // MSB LSB
197 // +---+---+---+---+---+---+---+---+---+
198 // | c | | | | | | | | |
199 // +---+---+---+---+---+---+---+---+---+
200 // \_______________________________/
201 // |
202 // u128
203 //
204 let mut v = [0;16];
205 res!(r.read_exact(&mut v));
206 byts.extend_from_slice(&v[..]);
207 return Ok(());
208 },
209 Self::I8_CODE => {
210 // +---+---+
211 // | c | |
212 // +---+---+
213 // \___/
214 // |
215 // i8
216 //
217 let mut v = [0;1];
218 res!(r.read_exact(&mut v));
219 byts.extend_from_slice(&v[..]);
220 return Ok(());
221 },
222 Self::I16_CODE => {
223 // MSB LSB
224 // +---+---+---+
225 // | c | | |
226 // +---+---+---+
227 // \_______/
228 // |
229 // i16
230 //
231 let mut v = [0;2];
232 res!(r.read_exact(&mut v));
233 byts.extend_from_slice(&v[..]);
234 return Ok(());
235 },
236 Self::I32_CODE => {
237 // MSB LSB
238 // +---+---+---+---+---+
239 // | c | | | | |
240 // +---+---+---+---+---+
241 // \_______________/
242 // |
243 // i32
244 //
245 let mut v = [0;4];
246 res!(r.read_exact(&mut v));
247 byts.extend_from_slice(&v[..]);
248 return Ok(());
249 },
250 Self::I64_CODE => {
251 // MSB LSB
252 // +---+---+---+---+---+---+---+---+---+
253 // | c | | | | | | | | |
254 // +---+---+---+---+---+---+---+---+---+
255 // \_______________________________/
256 // |
257 // i64
258 //
259 let mut v = [0;8];
260 res!(r.read_exact(&mut v));
261 byts.extend_from_slice(&v[..]);
262 return Ok(());
263 },
264 Self::I128_CODE => {
265 // MSB LSB
266 // +---+---+---+---+---+---+---+---+---+
267 // | c | | | | | | | | |
268 // +---+---+---+---+---+---+---+---+---+
269 // \_______________________________/
270 // |
271 // i128
272 //
273 let mut v = [0;16];
274 res!(r.read_exact(&mut v));
275 byts.extend_from_slice(&v[..]);
276 return Ok(());
277 },
278 Self::F32_CODE => {
279 // MSB LSB
280 // +---+---+---+---+---+
281 // | c | | | | |
282 // +---+---+---+---+---+
283 // \_______________/
284 // |
285 // f32
286 //
287 let mut v = [0;4];
288 res!(r.read_exact(&mut v));
289 byts.extend_from_slice(&v[..]);
290 return Ok(());
291 },
292 Self::F64_CODE => {
293 // MSB LSB
294 // +---+---+---+---+---+---+---+---+---+
295 // | c | | | | | | | | |
296 // +---+---+---+---+---+---+---+---+---+
297 // \_______________________________/
298 // |
299 // f64
300 //
301 let mut v = [0;8];
302 res!(r.read_exact(&mut v));
303 byts.extend_from_slice(&v[..]);
304 return Ok(());
305 },
306 // Variable
307 Self::BC64_CODE |
308 Self::STR_CODE |
309 Self::AINT_CODE |
310 Self::ADEC_CODE |
311 Self::LIST_CODE |
312 Self::VEK_CODE |
313 Self::MAP_CODE |
314 Self::OMAP_CODE => {
315 //
316 // 0 1 2 ... n 1 2 ... v
317 // +---+---+---+---+---+---+---+---+---+
318 // | c | | | | | | ... | |
319 // +---+---+---+---+---+---+---+---+---+
320 // \______________/\______________/
321 // | |
322 // c64 payload bytes
323 //
324 let mut c64code = [0;1];
325 res!(r.read_exact(&mut c64code));
326 byts.extend_from_slice(&c64code[..]);
327 if c64code[0] < Self::C64_CODE_START || c64code[0] > Self::C64_CODE_START + 8 {
328 return Err(err!(
329 "Expected a valid Dat::C64 code between {} and {} inclusive, \
330 instead found {}.", Self::C64_CODE_START, Self::C64_CODE_START + 8,
331 c64code[0];
332 Invalid, Input, Decode, Bytes));
333 }
334 if c64code[0] == Self::C64_CODE_START {
335 return Ok(());
336 }
337 // Avoid the use of the heap for the C64, for what it's worth.
338 let vlen = res!(Self::load_c64(&mut r, c64code[0], &mut byts));
339 res!(Self::load_payload(&mut r, vlen, byts));
340 return Ok(())
341 },
342 Self::C64_CODE_START..=Self::C64_CODE_END => { // C64
343 //
344 // MSB big endian LSB
345 // +---+---+---+---+---+---+---+---+
346 // | 0 | 0 | 0 | 0 | 0 | 0 | 0 |128|
347 // +---+---+---+---+---+---+---+---+
348 // \_______________________________/
349 // |
350 // u64
351 //
352 // Potential encoding for: Dat::C64
353 // +---+---+---+
354 // | c | n |128| n = 1
355 // +---+---+---+
356 // \___________/
357 // |
358 // c64
359 //
360 // Actual encoding for: Dat::C64
361 // +---+---+
362 // | c |128| c -> c + 1 (n = 1 incorporated into prefix code)
363 // +---+---+
364 // \_______/
365 // |
366 // c64
367 //
368 if dcode[0] < Self::C64_CODE_START || dcode[0] > Self::C64_CODE_START + 8 {
369 return Err(err!(
370 "Expected a valid Dat::C64 code between {} and {} inclusive, \
371 instead found {}.", Self::C64_CODE_START, Self::C64_CODE_START + 8,
372 dcode[0];
373 Invalid, Input, Decode, Bytes));
374 }
375 if dcode[0] == Self::C64_CODE_START {
376 return Ok(());
377 }
378 // Avoid the use of the heap for the C64, for what it's worth.
379 match dcode[0] - Self::C64_CODE_START {
380 1 => {
381 let mut v = [0;1];
382 res!(r.read_exact(&mut v));
383 byts.extend_from_slice(&v[..]);
384 },
385 2 => {
386 let mut v = [0;2];
387 res!(r.read_exact(&mut v));
388 byts.extend_from_slice(&v[..]);
389 },
390 3 => {
391 let mut v = [0;3];
392 res!(r.read_exact(&mut v));
393 byts.extend_from_slice(&v[..]);
394 },
395 4 => {
396 let mut v = [0;4];
397 res!(r.read_exact(&mut v));
398 byts.extend_from_slice(&v[..]);
399 },
400 5 => {
401 let mut v = [0;5];
402 res!(r.read_exact(&mut v));
403 byts.extend_from_slice(&v[..]);
404 },
405 6 => {
406 let mut v = [0;6];
407 res!(r.read_exact(&mut v));
408 byts.extend_from_slice(&v[..]);
409 },
410 7 => {
411 let mut v = [0;7];
412 res!(r.read_exact(&mut v));
413 byts.extend_from_slice(&v[..]);
414 },
415 8 => {
416 let mut v = [0;8];
417 res!(r.read_exact(&mut v));
418 byts.extend_from_slice(&v[..]);
419 },
420 _ => unreachable!(),
421 }
422 return Ok(());
423 },
424 // Molecule Kinds =========================
425 // Unitary
426 Self::USR_CODE => {
427 //
428 // +---+---+---+---+---+---+---+---+---+
429 // | c | u16 | | | | | | |
430 // +---+---+---+---+---+---+---+---+---+
431 // ^ ^ ^ \___________________/
432 // | | | |
433 // | | opt code inner Dat
434 // | ukid_code (if some)
435 // daticle
436 // code
437 //
438 const CODE_LEN: usize = UsrKindId::CODE_BYTE_LEN;
439 let mut v = [0; CODE_LEN];
440 res!(r.read_exact(&mut v));
441 byts.extend_from_slice(&v[..]);
442 let mut v = [0; 1];
443 res!(r.read_exact(&mut v));
444 let opt_code = v[0];
445 byts.push(opt_code);
446 if opt_code == Self::OPT_SOME_CODE {
447 res!(Self::load_bytes_muncher(r, byts));
448 }
449 return Ok(());
450 },
451 Self::BOX_CODE => {
452 //
453 // +---+---+---+---+---+---+---+---+---+
454 // | c | | | | | | | | |
455 // +---+---+---+---+---+---+---+---+---+
456 // \_______________________________/
457 // |
458 // inner Dat
459 //
460 // Dat::Box(k) byte encoding does nothing more than prepend Dat k with
461 // Dat::BOX_CODE
462 //
463 res!(Self::load_bytes_muncher(r, byts));
464 return Ok(());
465 },
466 Self::OPT_SOME_CODE => {
467 //
468 // +---+---+---+---+---+---+---+---+---+
469 // | c | | | | | | | | |
470 // +---+---+---+---+---+---+---+---+---+
471 // \_______________________________/
472 // |
473 // inner Dat
474 //
475 // Dat::Opt(Some(k)) byte encoding does nothing more than prepend Dat k
476 // with Dat::OPT_SOME_CODE
477 //
478 res!(Self::load_bytes_muncher(r, byts));
479 return Ok(());
480 },
481 // Heterogenous
482 Self::TUP2_CODE |
483 Self::TUP3_CODE |
484 Self::TUP4_CODE |
485 Self::TUP5_CODE |
486 Self::TUP6_CODE |
487 Self::TUP7_CODE |
488 Self::TUP8_CODE |
489 Self::TUP9_CODE |
490 Self::TUP10_CODE => {
491 //
492 // 0 1 ...
493 // +---+---+---+---+---+---+---+---+---+---+---+---+---+---+
494 // | c | c | | | c | | | c | | | | ... | |
495 // +---+---+---+---+---+---+---+---+---+---+---+---+---+---+
496 // \__________/\__________/\______________/ ...
497 // | | |
498 // item item item
499 //
500 let n = dcode[0] - Self::TUP_SERIES_START + 2;
501 for _ in 0..n {
502 res!(Self::load_bytes_muncher(r, byts));
503 }
504 return Ok(())
505 },
506 // Homogenous
507 // Variable length bytes
508 Self::BU8_CODE => {
509 //
510 // 0 1 1 2 ... v
511 // +---+---+---+---+---+---+ Fixed size, raw u8 for payload length
512 // | c | | | ... | |
513 // +---+---+---+---+---+---+
514 // \__/\______________/
515 // | |
516 // raw u8 payload bytes
517 //
518 let mut v = [0;1];
519 res!(r.read_exact(&mut v));
520 byts.extend_from_slice(&v[..]);
521 let vlen = u8::from_be_bytes(
522 res!(<[u8; 1]>::try_from(&v[..]), Decode, Bytes)
523 ) as usize;
524 res!(Self::load_payload(&mut r, vlen, byts));
525 return Ok(())
526 },
527 Self::BU16_CODE => {
528 //
529 // 0 1 2 1 2 ... v
530 // +---+---+---+---+---+---+---+ Fixed size, raw u16 for payload length
531 // | c | | | | ... | |
532 // +---+---+---+---+---+---+---+
533 // \______/\______________/
534 // | |
535 // raw u16 payload bytes
536 //
537 let mut v = [0;2];
538 res!(r.read_exact(&mut v));
539 byts.extend_from_slice(&v[..]);
540 let vlen = u16::from_be_bytes(
541 res!(<[u8; 2]>::try_from(&v[..]), Decode, Bytes)
542 ) as usize;
543 res!(Self::load_payload(&mut r, vlen, byts));
544 return Ok(())
545 },
546 Self::BU32_CODE => {
547 //
548 // 0 1 2 ... 4 1 2 ... v
549 // +---+---+---+---+---+---+---+---+---+ Fixed size, raw u32 for payload length
550 // | c | | | | | | ... | |
551 // +---+---+---+---+---+---+---+---+---+
552 // \______________/\______________/
553 // | |
554 // raw u32 payload bytes
555 //
556 let mut v = [0;4];
557 res!(r.read_exact(&mut v));
558 byts.extend_from_slice(&v[..]);
559 let vlen = u32::from_be_bytes(
560 res!(<[u8; 4]>::try_from(&v[..]), Decode, Bytes)
561 ) as usize;
562 res!(Self::load_payload(&mut r, vlen, byts));
563 return Ok(())
564 },
565 Self::BU64_CODE => {
566 //
567 // 0 1 2 ... 8 1 2 ... v
568 // +---+---+---+---+---+---+---+---+---+ Fixed size, raw u64 for payload length
569 // | c | | | | | | ... | |
570 // +---+---+---+---+---+---+---+---+---+
571 // \______________/\______________/
572 // | |
573 // raw u64 payload bytes
574 //
575 let mut v = [0;8];
576 res!(r.read_exact(&mut v));
577 byts.extend_from_slice(&v[..]);
578 let vlen = u64::from_be_bytes(
579 res!(<[u8; 8]>::try_from(&v[..]), Decode, Bytes)
580 ) as usize;
581 res!(Self::load_payload(&mut r, vlen, byts));
582 return Ok(())
583 },
584 // Fixed length bytes
585 Self::B2_CODE => binary_load_byte_tuple! { B2, u8, 2, r, byts },
586 Self::B3_CODE => binary_load_byte_tuple! { B3, u8, 3, r, byts },
587 Self::B4_CODE => binary_load_byte_tuple! { B4, u8, 4, r, byts },
588 Self::B5_CODE => binary_load_byte_tuple! { B5, u8, 5, r, byts },
589 Self::B6_CODE => binary_load_byte_tuple! { B6, u8, 6, r, byts },
590 Self::B7_CODE => binary_load_byte_tuple! { B7, u8, 7, r, byts },
591 Self::B8_CODE => binary_load_byte_tuple! { B8, u8, 8, r, byts },
592 Self::B9_CODE => binary_load_byte_tuple! { B9, u8, 9, r, byts },
593 Self::B10_CODE => binary_load_byte_tuple! { B10, u8, 10, r, byts },
594 Self::B16_CODE => binary_load_byte_tuple! { B16, u8, 16, r, byts },
595 Self::B32_CODE => binary_load_byte_tuple! { B32, u8, 32, r, byts },
596 // Fixed length numbers
597 Self::TUP2_U16_CODE => binary_load_byte_tuple! { Tup2u16, u16, 2, r, byts },
598 Self::TUP3_U16_CODE => binary_load_byte_tuple! { Tup3u16, u16, 3, r, byts },
599 Self::TUP4_U16_CODE => binary_load_byte_tuple! { Tup4u16, u16, 4, r, byts },
600 Self::TUP5_U16_CODE => binary_load_byte_tuple! { Tup5u16, u16, 5, r, byts },
601 Self::TUP6_U16_CODE => binary_load_byte_tuple! { Tup6u16, u16, 6, r, byts },
602 Self::TUP7_U16_CODE => binary_load_byte_tuple! { Tup7u16, u16, 7, r, byts },
603 Self::TUP8_U16_CODE => binary_load_byte_tuple! { Tup8u16, u16, 8, r, byts },
604 Self::TUP9_U16_CODE => binary_load_byte_tuple! { Tup9u16, u16, 9, r, byts },
605 Self::TUP10_U16_CODE => binary_load_byte_tuple! { Tup10u16, u16, 10, r, byts },
606
607 Self::TUP2_U32_CODE => binary_load_byte_tuple! { Tup2u32, u32, 2, r, byts },
608 Self::TUP3_U32_CODE => binary_load_byte_tuple! { Tup3u32, u32, 3, r, byts },
609 Self::TUP4_U32_CODE => binary_load_byte_tuple! { Tup4u32, u32, 4, r, byts },
610 Self::TUP5_U32_CODE => binary_load_byte_tuple! { Tup5u32, u32, 5, r, byts },
611 Self::TUP6_U32_CODE => binary_load_byte_tuple! { Tup6u32, u32, 6, r, byts },
612 Self::TUP7_U32_CODE => binary_load_byte_tuple! { Tup7u32, u32, 7, r, byts },
613 Self::TUP8_U32_CODE => binary_load_byte_tuple! { Tup8u32, u32, 8, r, byts },
614 Self::TUP9_U32_CODE => binary_load_byte_tuple! { Tup9u32, u32, 9, r, byts },
615 Self::TUP10_U32_CODE => binary_load_byte_tuple! { Tup10u32, u32, 10, r, byts },
616
617 Self::TUP2_U64_CODE => binary_load_byte_tuple! { Tup2u64, u64, 2, r, byts },
618 Self::TUP3_U64_CODE => binary_load_byte_tuple! { Tup3u64, u64, 3, r, byts },
619 Self::TUP4_U64_CODE => binary_load_byte_tuple! { Tup4u64, u64, 4, r, byts },
620 Self::TUP5_U64_CODE => binary_load_byte_tuple! { Tup5u64, u64, 5, r, byts },
621 Self::TUP6_U64_CODE => binary_load_byte_tuple! { Tup6u64, u64, 6, r, byts },
622 Self::TUP7_U64_CODE => binary_load_byte_tuple! { Tup7u64, u64, 7, r, byts },
623 Self::TUP8_U64_CODE => binary_load_byte_tuple! { Tup8u64, u64, 8, r, byts },
624 Self::TUP9_U64_CODE => binary_load_byte_tuple! { Tup9u64, u64, 9, r, byts },
625 Self::TUP10_U64_CODE => binary_load_byte_tuple! { Tup10u64, u64, 10, r, byts },
626
627 code => return Err(err!(
628 "Dat identification code {} not recognised.", code;
629 Invalid, Input)),
630 }
631 }
632}