-#![allow(unused_variables)]
-use endian::{Endian, Parse};
+use endian::{Endian, Parse, ToBytes};
+use flate2::read::ZlibDecoder;
use num::Integer;
use num_derive::FromPrimitive;
-use std::io::{BufReader, Error as IoError, ErrorKind, Read, Seek};
+use std::{
+ collections::VecDeque,
+ io::{Error as IoError, Read, Seek, SeekFrom},
+ iter::FusedIterator,
+};
use thiserror::Error;
pub mod endian;
+pub mod sack;
#[derive(Error, Debug)]
pub enum Error {
BadMagic([u8; 4]),
#[error("I/O error ({0})")]
- Io(
- #[from]
- IoError,
- ),
+ Io(#[from] IoError),
#[error("Invalid SAV compression code {0}")]
InvalidSavCompression(u32),
#[error("At offset {offset:#x}, impossible ZLIB trailer length {ztrailer_len}.")]
BadZlibTrailerLen { offset: u64, ztrailer_len: u64 },
+
+ #[error("Unexpected end of file at offset {offset:#x}, {case_ofs} bytes into a {case_len}-byte case.")]
+ EofInCase {
+ offset: u64,
+ case_ofs: u64,
+ case_len: usize,
+ },
+
+ #[error(
+ "Unexpected end of file at offset {offset:#x}, {case_ofs} bytes into a compressed case."
+ )]
+ EofInCompressedCase { offset: u64, case_ofs: u64 },
+
+ #[error("Data ends at offset {offset:#x}, {case_ofs} bytes into a compressed case.")]
+ PartialCompressedCase { offset: u64, case_ofs: u64 },
+
+ #[error("At {case_ofs} bytes into compressed case starting at offset {offset:#x}, a string was found where a number was expected.")]
+ CompressedNumberExpected { offset: u64, case_ofs: u64 },
+
+ #[error("At {case_ofs} bytes into compressed case starting at offset {offset:#x}, a number was found where a string was expected.")]
+ CompressedStringExpected { offset: u64, case_ofs: u64 },
+
+ #[error("Block count {n_blocks} in ZLIB trailer at offset {offset:#x} differs from expected block count {expected_n_blocks} calculated from trailer length {ztrailer_len}.")]
+ BadZlibTrailerNBlocks {
+ offset: u64,
+ n_blocks: u32,
+ expected_n_blocks: u64,
+ ztrailer_len: u64,
+ },
}
#[derive(Error, Debug)]
VarIndexes(VarIndexes),
Extension(Extension),
EndOfHeaders,
+ ZHeader(ZHeader),
+ ZTrailer(ZTrailer),
Case(Vec<Value>),
}
pub file_label: [u8; 64],
/// Endianness of the data in the file header.
- pub endianness: Endian,
+ pub endian: Endian,
}
#[derive(Copy, Clone, PartialEq, Eq, Hash)]
}
}
-pub struct Reader<R: Read> {
- r: BufReader<R>,
+trait State {
+ #[allow(clippy::type_complexity)]
+ fn read(self: Box<Self>) -> Result<Option<(Record, Box<dyn State>)>, Error>;
+}
+
+struct Start<R: Read + Seek> {
+ reader: R,
+}
+
+struct CommonState<R: Read + Seek> {
+ reader: R,
+ endian: Endian,
+ bias: f64,
+ compression: Option<Compression>,
var_types: Vec<VarType>,
- state: ReaderState,
}
-enum ReaderState {
- Start,
- Headers(Endian, Option<Compression>),
- Data(Endian),
- End,
+impl<R: Read + Seek + 'static> State for Start<R> {
+ fn read(mut self: Box<Self>) -> Result<Option<(Record, Box<dyn State>)>, Error> {
+ let header = read_header(&mut self.reader)?;
+ let next_state = Headers(CommonState {
+ reader: self.reader,
+ endian: header.endian,
+ bias: header.bias,
+ compression: header.compression,
+ var_types: Vec::new(),
+ });
+ Ok(Some((Record::Header(header), Box::new(next_state))))
+ }
+}
+
+struct Headers<R: Read + Seek>(CommonState<R>);
+
+impl<R: Read + Seek + 'static> State for Headers<R> {
+ fn read(mut self: Box<Self>) -> Result<Option<(Record, Box<dyn State>)>, Error> {
+ let endian = self.0.endian;
+ let rec_type: u32 = endian.parse(read_bytes(&mut self.0.reader)?);
+ let record = match rec_type {
+ 2 => {
+ let variable = read_variable_record(&mut self.0.reader, endian)?;
+ self.0.var_types.push(VarType::from_width(variable.width));
+ Record::Variable(variable)
+ }
+ 3 => Record::ValueLabel(read_value_label_record(&mut self.0.reader, endian)?),
+ 4 => Record::VarIndexes(read_var_indexes_record(&mut self.0.reader, endian)?),
+ 6 => Record::Document(read_document_record(&mut self.0.reader, endian)?),
+ 7 => Record::Extension(read_extension_record(&mut self.0.reader, endian)?),
+ 999 => {
+ let _: [u8; 4] = read_bytes(&mut self.0.reader)?;
+ let next_state: Box<dyn State> = match self.0.compression {
+ None => Box::new(Data(self.0)),
+ Some(Compression::Simple) => Box::new(CompressedData::new(self.0)),
+ Some(Compression::ZLib) => Box::new(ZlibHeader(self.0)),
+ };
+ return Ok(Some((Record::EndOfHeaders, next_state)));
+ }
+ _ => {
+ return Err(Error::BadRecordType {
+ offset: self.0.reader.stream_position()?,
+ rec_type,
+ })
+ }
+ };
+ Ok(Some((record, self)))
+ }
+}
+
+struct ZlibHeader<R: Read + Seek>(CommonState<R>);
+
+impl<R: Read + Seek + 'static> State for ZlibHeader<R> {
+ fn read(mut self: Box<Self>) -> Result<Option<(Record, Box<dyn State>)>, Error> {
+ let zheader = read_zheader(&mut self.0.reader, self.0.endian)?;
+ Ok(Some((Record::ZHeader(zheader), self)))
+ }
+}
+
+struct ZlibTrailer<R: Read + Seek>(CommonState<R>, ZHeader);
+
+impl<R: Read + Seek + 'static> State for ZlibTrailer<R> {
+ fn read(mut self: Box<Self>) -> Result<Option<(Record, Box<dyn State>)>, Error> {
+ let retval = read_ztrailer(&mut self.0.reader, self.0.endian, self.1.ztrailer_offset, self.1.ztrailer_len)?;
+ let next_state = Box::new(CompressedData::new(CommonState {
+ reader: ZlibDecodeMultiple::new(self.0.reader),
+ endian: self.0.endian,
+ bias: self.0.bias,
+ compression: self.0.compression,
+ var_types: self.0.var_types
+ }));
+ match retval {
+ None => next_state.read(),
+ Some(ztrailer) => Ok(Some((Record::ZTrailer(ztrailer), next_state)))
+ }
+ }
+}
+
+struct Data<R: Read + Seek>(CommonState<R>);
+
+impl<R: Read + Seek + 'static> State for Data<R> {
+ fn read(mut self: Box<Self>) -> Result<Option<(Record, Box<dyn State>)>, Error> {
+ let case_start = self.0.reader.stream_position()?;
+ let mut values = Vec::with_capacity(self.0.var_types.len());
+ for (i, &var_type) in self.0.var_types.iter().enumerate() {
+ let Some(raw) = try_read_bytes(&mut self.0.reader)? else {
+ if i == 0 {
+ return Ok(None);
+ } else {
+ let offset = self.0.reader.stream_position()?;
+ return Err(Error::EofInCase {
+ offset,
+ case_ofs: offset - case_start,
+ case_len: self.0.var_types.len() * 8,
+ });
+ }
+ };
+ values.push(Value::from_raw(var_type, raw, self.0.endian));
+ }
+ Ok(Some((Record::Case(values), self)))
+ }
+}
+
+struct CompressedData<R: Read + Seek> {
+ common: CommonState<R>,
+ codes: VecDeque<u8>,
+}
+
+impl<R: Read + Seek + 'static> CompressedData<R> {
+ fn new(common: CommonState<R>) -> CompressedData<R> {
+ CompressedData { common, codes: VecDeque::new() }
+ }
+}
+
+impl<R: Read + Seek + 'static> State for CompressedData<R> {
+ fn read(mut self: Box<Self>) -> Result<Option<(Record, Box<dyn State>)>, Error> {
+ let case_start = self.common.reader.stream_position()?;
+ let mut values = Vec::with_capacity(self.common.var_types.len());
+ for (i, &var_type) in self.common.var_types.iter().enumerate() {
+ let value = loop {
+ let Some(code) = self.codes.pop_front() else {
+ let Some(new_codes): Option<[u8; 8]> = try_read_bytes(&mut self.common.reader)?
+ else {
+ if i == 0 {
+ return Ok(None);
+ } else {
+ let offset = self.common.reader.stream_position()?;
+ return Err(Error::EofInCompressedCase {
+ offset,
+ case_ofs: offset - case_start,
+ });
+ }
+ };
+ self.codes.extend(new_codes.into_iter());
+ continue;
+ };
+ match code {
+ 0 => (),
+ 1..=251 => match var_type {
+ VarType::Number => break Value::Number(Some(code as f64 - self.common.bias)),
+ VarType::String => {
+ break Value::String(self.common.endian.to_bytes(code as f64 - self.common.bias))
+ }
+ },
+ 252 => {
+ if i == 0 {
+ return Ok(None);
+ } else {
+ let offset = self.common.reader.stream_position()?;
+ return Err(Error::PartialCompressedCase {
+ offset,
+ case_ofs: offset - case_start,
+ });
+ }
+ }
+ 253 => {
+ break Value::from_raw(
+ var_type,
+ read_bytes(&mut self.common.reader)?,
+ self.common.endian,
+ )
+ }
+ 254 => match var_type {
+ VarType::String => break Value::String(*b" "), // XXX EBCDIC
+ VarType::Number => {
+ return Err(Error::CompressedStringExpected {
+ offset: case_start,
+ case_ofs: self.common.reader.stream_position()? - case_start,
+ })
+ }
+ },
+ 255 => match var_type {
+ VarType::Number => break Value::Number(None),
+ VarType::String => {
+ return Err(Error::CompressedNumberExpected {
+ offset: case_start,
+ case_ofs: self.common.reader.stream_position()? - case_start,
+ })
+ }
+ },
+ }
+ };
+ values.push(value);
+ }
+ Ok(Some((Record::Case(values), self)))
+ }
+}
+
+struct ZlibDecodeMultiple<R>
+where
+ R: Read + Seek,
+{
+ reader: Option<ZlibDecoder<R>>,
+}
+
+impl<R> ZlibDecodeMultiple<R>
+where
+ R: Read + Seek,
+{
+ fn new(reader: R) -> ZlibDecodeMultiple<R> {
+ ZlibDecodeMultiple {
+ reader: Some(ZlibDecoder::new(reader)),
+ }
+ }
+}
+
+impl<R> Read for ZlibDecodeMultiple<R>
+where
+ R: Read + Seek,
+{
+ fn read(&mut self, buf: &mut [u8]) -> Result<usize, IoError> {
+ loop {
+ match self.reader.as_mut().unwrap().read(buf)? {
+ 0 => {
+ let inner = self.reader.take().unwrap().into_inner();
+ self.reader = Some(ZlibDecoder::new(inner));
+ }
+ n => return Ok(n),
+ };
+ }
+ }
+}
+
+impl<R> Seek for ZlibDecodeMultiple<R>
+where
+ R: Read + Seek,
+{
+ fn seek(&mut self, pos: SeekFrom) -> Result<u64, IoError> {
+ self.reader.as_mut().unwrap().get_mut().seek(pos)
+ }
}
#[derive(Copy, Clone)]
}
}
-impl<R: Read + Seek> Reader<R> {
- pub fn new(r: R) -> Result<Reader<R>, Error> {
+pub struct Reader {
+ state: Option<Box<dyn State>>,
+}
+
+impl Reader {
+ pub fn new<R: Read + Seek + 'static>(reader: R) -> Result<Reader, Error> {
Ok(Reader {
- r: BufReader::new(r),
- var_types: Vec::new(),
- state: ReaderState::Start,
+ state: Some(Box::new(Start { reader })),
})
}
- fn _next(&mut self) -> Result<Option<(Record, ReaderState)>, Error> {
- match self.state {
- ReaderState::Start => {
- let header = read_header(&mut self.r)?;
- let next_state = ReaderState::Headers(header.endianness, header.compression);
- Ok(Some((Record::Header(header), next_state)))
- }
- ReaderState::Headers(endian, compression) => {
- let rec_type: u32 = endian.parse(read_bytes(&mut self.r)?);
- let record = match rec_type {
- 2 => {
- let variable = read_variable_record(&mut self.r, endian)?;
- self.var_types.push(VarType::from_width(variable.width));
- Record::Variable(variable)
- }
- 3 => Record::ValueLabel(read_value_label_record(&mut self.r, endian)?),
- 4 => Record::VarIndexes(read_var_indexes_record(&mut self.r, endian)?),
- 6 => Record::Document(read_document_record(&mut self.r, endian)?),
- 7 => Record::Extension(read_extension_record(&mut self.r, endian)?),
- 999 => {
- let _: [u8; 4] = read_bytes(&mut self.r)?;
- let next_state = match compression {
- None => ReaderState::Data(endian),
- _ => ReaderState::End,
- };
- return Ok(Some((Record::EndOfHeaders, next_state)));
- }
- _ => {
- return Err(Error::BadRecordType {
- offset: self.r.stream_position()?,
- rec_type,
- })
- }
- };
- Ok(Some((record, ReaderState::Headers(endian, compression))))
- }
- ReaderState::Data(endian) => {
- let mut values = Vec::with_capacity(self.var_types.len());
- for (i, &var_type) in self.var_types.iter().enumerate() {
- let raw = match read_bytes(&mut self.r) {
- Ok(raw) => raw,
- Err(err) => {
- if i == 0 && err.kind() == ErrorKind::UnexpectedEof {
- return Ok(None);
- } else {
- return Err(Error::Io(err));
- }
- }
- };
- values.push(Value::from_raw(var_type, raw, endian));
- }
- Ok(Some((Record::Case(values), ReaderState::Data(endian))))
- }
- ReaderState::End => Ok(None),
- }
- }
}
-impl<R: Read + Seek> Iterator for Reader<R> {
+impl Iterator for Reader {
type Item = Result<Record, Error>;
fn next(&mut self) -> Option<Self::Item> {
- let retval = self._next();
- match retval {
- Ok(None) => {
- self.state = ReaderState::End;
- None
- }
+ match self.state.take()?.read() {
Ok(Some((record, next_state))) => {
- self.state = next_state;
+ self.state = Some(next_state);
Some(Ok(record))
}
- Err(error) => {
- self.state = ReaderState::End;
- Some(Err(error))
- }
+ Ok(None) => None,
+ Err(error) => Some(Err(error)),
}
}
}
+impl FusedIterator for Reader {}
+
fn read_header<R: Read>(r: &mut R) -> Result<Header, Error> {
let magic: [u8; 4] = read_bytes(r)?;
let magic: Magic = magic.try_into().map_err(|_| Error::NotASystemFile)?;
let eye_catcher: [u8; 60] = read_bytes(r)?;
let layout_code: [u8; 4] = read_bytes(r)?;
- let endianness = Endian::identify_u32(2, layout_code)
+ let endian = Endian::identify_u32(2, layout_code)
.or_else(|| Endian::identify_u32(2, layout_code))
.ok_or_else(|| Error::NotASystemFile)?;
- let layout_code = endianness.parse(layout_code);
+ let layout_code = endian.parse(layout_code);
- let nominal_case_size: u32 = endianness.parse(read_bytes(r)?);
+ let nominal_case_size: u32 = endian.parse(read_bytes(r)?);
let nominal_case_size =
(nominal_case_size <= i32::MAX as u32 / 16).then_some(nominal_case_size);
- let compression_code: u32 = endianness.parse(read_bytes(r)?);
+ let compression_code: u32 = endian.parse(read_bytes(r)?);
let compression = match (magic, compression_code) {
(Magic::ZSAV, 2) => Some(Compression::ZLib),
(Magic::ZSAV, code) => return Err(Error::InvalidZsavCompression(code)),
(_, code) => return Err(Error::InvalidSavCompression(code)),
};
- let weight_index: u32 = endianness.parse(read_bytes(r)?);
+ let weight_index: u32 = endian.parse(read_bytes(r)?);
let weight_index = (weight_index > 0).then_some(weight_index - 1);
- let n_cases: u32 = endianness.parse(read_bytes(r)?);
+ let n_cases: u32 = endian.parse(read_bytes(r)?);
let n_cases = (n_cases < i32::MAX as u32 / 2).then_some(n_cases);
- let bias: f64 = endianness.parse(read_bytes(r)?);
+ let bias: f64 = endian.parse(read_bytes(r)?);
let creation_date: [u8; 9] = read_bytes(r)?;
let creation_time: [u8; 8] = read_bytes(r)?;
creation_time,
eye_catcher,
file_label,
- endianness,
+ endian,
})
}
pub label: Option<Vec<u8>>,
}
-fn read_variable_record<R: Read + Seek>(
- r: &mut BufReader<R>,
- e: Endian,
-) -> Result<Variable, Error> {
+fn read_variable_record<R: Read + Seek>(r: &mut R, endian: Endian) -> Result<Variable, Error> {
let offset = r.stream_position()?;
- let width: i32 = e.parse(read_bytes(r)?);
- let has_variable_label: u32 = e.parse(read_bytes(r)?);
- let missing_value_code: i32 = e.parse(read_bytes(r)?);
- let print_format: u32 = e.parse(read_bytes(r)?);
- let write_format: u32 = e.parse(read_bytes(r)?);
+ let width: i32 = endian.parse(read_bytes(r)?);
+ let has_variable_label: u32 = endian.parse(read_bytes(r)?);
+ let missing_value_code: i32 = endian.parse(read_bytes(r)?);
+ let print_format: u32 = endian.parse(read_bytes(r)?);
+ let write_format: u32 = endian.parse(read_bytes(r)?);
let name: [u8; 8] = read_bytes(r)?;
let label = match has_variable_label {
0 => None,
1 => {
- let len: u32 = e.parse(read_bytes(r)?);
+ let len: u32 = endian.parse(read_bytes(r)?);
let read_len = len.min(65535) as usize;
let label = Some(read_vec(r, read_len)?);
pub const MAX: u32 = u32::MAX / 8;
}
-fn read_value_label_record<R: Read + Seek>(
- r: &mut BufReader<R>,
- e: Endian,
-) -> Result<ValueLabel, Error> {
+fn read_value_label_record<R: Read + Seek>(r: &mut R, endian: Endian) -> Result<ValueLabel, Error> {
let offset = r.stream_position()?;
- let n: u32 = e.parse(read_bytes(r)?);
+ let n: u32 = endian.parse(read_bytes(r)?);
if n > ValueLabel::MAX {
return Err(Error::BadNumberOfValueLabels {
offset,
let mut labels = Vec::new();
for _ in 0..n {
let value: [u8; 8] = read_bytes(r)?;
- let label_len: u8 = e.parse(read_bytes(r)?);
+ let label_len: u8 = endian.parse(read_bytes(r)?);
let label_len = label_len as usize;
let padded_len = Integer::next_multiple_of(&(label_len + 1), &8);
pub const MAX: u32 = u32::MAX / 8;
}
-fn read_var_indexes_record<R: Read + Seek>(
- r: &mut BufReader<R>,
- e: Endian,
-) -> Result<VarIndexes, Error> {
+fn read_var_indexes_record<R: Read + Seek>(r: &mut R, endian: Endian) -> Result<VarIndexes, Error> {
let offset = r.stream_position()?;
- let n: u32 = e.parse(read_bytes(r)?);
+ let n: u32 = endian.parse(read_bytes(r)?);
if n > VarIndexes::MAX {
return Err(Error::BadNumberOfVarIndexes {
offset,
}
let mut var_indexes = Vec::with_capacity(n as usize);
for _ in 0..n {
- var_indexes.push(e.parse(read_bytes(r)?));
+ var_indexes.push(endian.parse(read_bytes(r)?));
}
Ok(VarIndexes {
pub lines: Vec<[u8; DOC_LINE_LEN as usize]>,
}
-fn read_document_record<R: Read + Seek>(
- r: &mut BufReader<R>,
- e: Endian,
-) -> Result<Document, Error> {
+fn read_document_record<R: Read + Seek>(r: &mut R, endian: Endian) -> Result<Document, Error> {
let offset = r.stream_position()?;
- let n: u32 = e.parse(read_bytes(r)?);
+ let n: u32 = endian.parse(read_bytes(r)?);
match n {
0..=DOC_MAX_LINES => {
let pos = r.stream_position()?;
}
}
-fn read_extension_record<R: Read + Seek>(
- r: &mut BufReader<R>,
- e: Endian,
-) -> Result<Extension, Error> {
- let subtype = e.parse(read_bytes(r)?);
+fn read_extension_record<R: Read + Seek>(r: &mut R, endian: Endian) -> Result<Extension, Error> {
+ let subtype = endian.parse(read_bytes(r)?);
let offset = r.stream_position()?;
- let size: u32 = e.parse(read_bytes(r)?);
- let count = e.parse(read_bytes(r)?);
+ let size: u32 = endian.parse(read_bytes(r)?);
+ let count = endian.parse(read_bytes(r)?);
let Some(product) = size.checked_mul(count) else {
return Err(Error::ExtensionRecordTooLarge {
offset,
})
}
-struct ZHeader {
+pub struct ZHeader {
/// File offset to the start of the record.
- offset: u64,
+ pub offset: u64,
/// File offset to the ZLIB data header.
- zheader_offset: u64,
+ pub zheader_offset: u64,
/// File offset to the ZLIB trailer.
- ztrailer_offset: u64,
+ pub ztrailer_offset: u64,
/// Length of the ZLIB trailer in bytes.
- ztrailer_len: u64,
+ pub ztrailer_len: u64,
}
-fn read_zheader<R: Read + Seek>(r: &mut BufReader<R>, e: Endian) -> Result<ZHeader, Error> {
+fn read_zheader<R: Read + Seek>(r: &mut R, endian: Endian) -> Result<ZHeader, Error> {
let offset = r.stream_position()?;
- let zheader_offset: u64 = e.parse(read_bytes(r)?);
- let ztrailer_offset: u64 = e.parse(read_bytes(r)?);
- let ztrailer_len: u64 = e.parse(read_bytes(r)?);
+ let zheader_offset: u64 = endian.parse(read_bytes(r)?);
+ let ztrailer_offset: u64 = endian.parse(read_bytes(r)?);
+ let ztrailer_len: u64 = endian.parse(read_bytes(r)?);
Ok(ZHeader {
offset,
})
}
+pub struct ZTrailer {
+ /// File offset to the start of the record.
+ pub offset: u64,
+
+ /// Compression bias as a negative integer, e.g. -100.
+ pub int_bias: i64,
+
+ /// Always observed as zero.
+ pub zero: u64,
+
+ /// Uncompressed size of each block, except possibly the last. Only
+ /// `0x3ff000` has been observed so far.
+ pub block_size: u32,
+
+ /// Block descriptors, always `(ztrailer_len - 24) / 24)` of them.
+ pub blocks: Vec<ZBlock>,
+}
+
+pub struct ZBlock {
+ /// Offset of block of data if simple compression were used.
+ pub uncompressed_ofs: u64,
+
+ /// Actual offset within the file of the compressed data block.
+ pub compressed_ofs: u64,
+
+ /// The number of bytes in this data block after decompression. This is
+ /// `block_size` in every data block but the last, which may be smaller.
+ pub uncompressed_size: u32,
+
+ /// The number of bytes in this data block, as stored compressed in this
+ /// file.
+ pub compressed_size: u32,
+}
+
+fn read_ztrailer<R: Read + Seek>(
+ r: &mut R,
+ endian: Endian,
+ ztrailer_ofs: u64,
+ ztrailer_len: u64,
+) -> Result<Option<ZTrailer>, Error> {
+ let start_offset = r.stream_position()?;
+ if r.seek(SeekFrom::Start(ztrailer_ofs)).is_err() {
+ return Ok(None);
+ }
+ let int_bias = endian.parse(read_bytes(r)?);
+ let zero = endian.parse(read_bytes(r)?);
+ let block_size = endian.parse(read_bytes(r)?);
+ let n_blocks: u32 = endian.parse(read_bytes(r)?);
+ let expected_n_blocks = (ztrailer_len - 24) / 24;
+ if n_blocks as u64 != expected_n_blocks {
+ return Err(Error::BadZlibTrailerNBlocks {
+ offset: ztrailer_ofs,
+ n_blocks,
+ expected_n_blocks,
+ ztrailer_len,
+ });
+ }
+ let mut blocks = Vec::with_capacity(n_blocks as usize);
+ for _ in 0..n_blocks {
+ let uncompressed_ofs = endian.parse(read_bytes(r)?);
+ let compressed_ofs = endian.parse(read_bytes(r)?);
+ let uncompressed_size = endian.parse(read_bytes(r)?);
+ let compressed_size = endian.parse(read_bytes(r)?);
+ blocks.push(ZBlock {
+ uncompressed_ofs,
+ compressed_ofs,
+ uncompressed_size,
+ compressed_size,
+ });
+ }
+ r.seek(SeekFrom::Start(start_offset))?;
+ Ok(Some(ZTrailer {
+ offset: ztrailer_ofs,
+ int_bias,
+ zero,
+ block_size,
+ blocks,
+ }))
+}
+
+fn try_read_bytes<const N: usize, R: Read>(r: &mut R) -> Result<Option<[u8; N]>, IoError> {
+ let mut buf = [0; N];
+ let n = r.read(&mut buf)?;
+ if n > 0 {
+ if n < N {
+ r.read_exact(&mut buf[n..])?;
+ }
+ Ok(Some(buf))
+ } else {
+ Ok(None)
+ }
+}
+
fn read_bytes<const N: usize, R: Read>(r: &mut R) -> Result<[u8; N], IoError> {
let mut buf = [0; N];
r.read_exact(&mut buf)?;
Ok(buf)
}
-fn read_vec<R: Read>(r: &mut BufReader<R>, n: usize) -> Result<Vec<u8>, IoError> {
+fn read_vec<R: Read>(r: &mut R, n: usize) -> Result<Vec<u8>, IoError> {
let mut vec = vec![0; n];
r.read_exact(&mut vec)?;
Ok(vec)
projects / pspp / blobdiff