Improve read macros

Author: friendlymatthew

src/font/grammar.rs

@@ -1,13 +1,4 @@
-use crate::util::read_bytes::{
-    U16_BYTES,
-    U8_BYTES,
-};
-use anyhow::{
-    anyhow,
-    bail,
-    ensure,
-    Result,
-};
+use anyhow::{anyhow, bail, ensure, Result};
 use std::collections::BTreeMap;
 
 pub type ShortFrac = i16;
@@ -50,10 +41,10 @@ pub enum ScalarType {
     OpenType,
 }
 
-impl TryFrom<&[u8; 4]> for ScalarType {
+impl TryFrom<&[u8]> for ScalarType {
     type Error = anyhow::Error;
 
-    fn try_from(value: &[u8; 4]) -> Result<Self, Self::Error> {
+    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
         let scalar_type = match value {
             b"true" | b"\x00\x01\x00\x00" => Self::TrueType,
             b"typ1" => Self::PostScript,
@@ -94,13 +85,13 @@ pub enum TableTag<'a> {
     OS2,
     Prep,
 
-    Foreign(&'a [u8; 4]),
+    Foreign(&'a [u8]),
 }
 
-impl<'a> TryFrom<&'a [u8; 4]> for TableTag<'a> {
+impl<'a> TryFrom<&'a [u8]> for TableTag<'a> {
     type Error = anyhow::Error;
 
-    fn try_from(value: &'a [u8; 4]) -> Result<Self, Self::Error> {
+    fn try_from(value: &'a [u8]) -> Result<Self, Self::Error> {
         let tag = match value {
             b"cmap" => Self::CMap,
             b"glyf" => Self::Glyf,
@@ -383,8 +374,8 @@ impl TryFrom<i16> for IndexToLocFormat {
 impl IndexToLocFormat {
     pub const fn size(&self) -> usize {
         match self {
-            Self::Short => U16_BYTES,
-            Self::Long => U8_BYTES,
+            Self::Short => std::mem::size_of::<u16>(),
+            Self::Long => std::mem::size_of::<u8>(),
         }
     }
 }

src/font/parser.rs

@@ -1,58 +1,16 @@
 use super::grammar::{
-    CMapFormat0,
-    CMapFormat12,
-    CMapFormat4,
-    CMapIndividualGroup,
-    CMapSubtable,
-    CMapTable,
-    ComponentGlyph,
-    ComponentGlyphArgument,
-    ComponentGlyphFlag,
-    ComponentGlyphTransformation,
-    CompoundGlyph,
-    F2Dot14,
-    FWord,
-    Fixed,
-    FontDirectory,
-    Glyph,
-    GlyphData,
-    GlyphDescription,
-    GlyphTable,
-    HHeaTable,
-    HMtxTable,
-    HeadTable,
-    LongDateTime,
-    LongHorizontalMetric,
-    MaxPTable,
-    OffsetSubTable,
-    ScalarType,
-    SimpleGlyph,
-    SimpleGlyphFlag,
-    TableRecord,
-    TableTag,
-    TrueTypeFontFile,
-    UnsignedFWord,
+    CMapFormat0, CMapFormat12, CMapFormat4, CMapIndividualGroup, CMapSubtable, CMapTable,
+    ComponentGlyph, ComponentGlyphArgument, ComponentGlyphFlag, ComponentGlyphTransformation,
+    CompoundGlyph, F2Dot14, FWord, Fixed, FontDirectory, Glyph, GlyphData, GlyphDescription,
+    GlyphTable, HHeaTable, HMtxTable, HeadTable, LongDateTime, LongHorizontalMetric, MaxPTable,
+    OffsetSubTable, ScalarType, SimpleGlyph, SimpleGlyphFlag, TableRecord, TableTag,
+    TrueTypeFontFile, UnsignedFWord,
 };
 use crate::{
-    eof,
-    font::grammar::{
-        IndexToLocFormat,
-        Platform,
-        PlatformDouble,
-    },
-    read,
-    util::read_bytes::{
-        U16_BYTES,
-        U32_BYTES,
-        U64_BYTES,
-        U8_BYTES,
-    },
-};
-use anyhow::{
-    bail,
-    ensure,
-    Result,
+    font::grammar::{IndexToLocFormat, Platform, PlatformDouble},
+    impl_read_for_datatype, read_slice,
 };
+use anyhow::{bail, ensure, Result};
 use std::collections::BTreeMap;
 
 #[derive(Debug)]
@@ -157,7 +115,7 @@ impl<'a> TrueTypeFontParser<'a> {
 
     fn parse_font_directory(&mut self) -> Result<FontDirectory<'a>> {
         let offset_sub_table = OffsetSubTable {
-            scalar_type: ScalarType::try_from(self.read_slice::<U32_BYTES>()?)?,
+            scalar_type: ScalarType::try_from(self.read_slice(4)?)?,
             num_tables: self.read_u16()?,
             search_range: self.read_u16()?,
             entry_selector: self.read_u16()?,
@@ -168,7 +126,7 @@ impl<'a> TrueTypeFontParser<'a> {
 
         for _ in 0..offset_sub_table.num_tables as usize {
             // todo: what does a checksum validation look like?
-            let table_tag = TableTag::try_from(self.read_slice::<U32_BYTES>()?)?;
+            let table_tag = TableTag::try_from(self.read_slice(4)?)?;
 
             ensure!(
                 !table_directory.contains_key(&table_tag),
@@ -653,55 +611,32 @@ impl<'a> TrueTypeFontParser<'a> {
         Ok(CompoundGlyph { components })
     }
 
-    eof!();
-
     fn jump_to_table_record(&mut self, table_record: &TableRecord) -> Result<()> {
         let (offset, length) = (table_record.offset as usize, table_record.length as usize);
         self.jump(offset, length)
     }
 
     fn jump(&mut self, offset: usize, length: usize) -> Result<()> {
-        ensure!(offset < self.data.len(), "Offset is out of bounds.");
         self.cursor = offset;
-        self.eof(length)?;
+        ensure!(self.cursor + length < self.data.len(), "oob");
 
         Ok(())
     }
 
-    fn read_vec<T>(
-        &mut self,
-        capacity: usize,
-        read_fn: impl Fn(&mut Self) -> Result<T>,
-    ) -> Result<Vec<T>> {
-        let mut list = Vec::with_capacity(capacity);
-
-        for _ in 0..capacity {
-            list.push(read_fn(self)?)
-        }
-
-        Ok(list)
-    }
-
-    fn read_slice<const N: usize>(&mut self) -> Result<&'a [u8; N]> {
-        self.eof(N)?;
-        let bs = &self.data[self.cursor..self.cursor + N];
-        self.cursor += N;
-
-        Ok(bs.try_into()?)
-    }
-
-    // read!(read_short_frac, ShortFrac, U16_BYTES);
-    read!(read_fixed, Fixed, U32_BYTES);
-    read!(read_fword, FWord, U16_BYTES);
-    read!(read_unsigned_fword, UnsignedFWord, U16_BYTES);
-    read!(read_f2dot14, F2Dot14, U16_BYTES);
-    read!(read_long_date_time, LongDateTime, U64_BYTES);
-    read!(read_i8, i8, U8_BYTES);
-    read!(read_u8, u8, U8_BYTES);
-    read!(read_u16, u16, U16_BYTES);
-    read!(read_u32, u32, U32_BYTES);
-    read!(read_i16, i16, U16_BYTES);
-    read!(read_i64, i64, U64_BYTES);
+    // impl_read_for_datatype!(read_short_frac, ShortFrac, U16_BYTES);
+
+    read_slice!();
+    impl_read_for_datatype!(read_fixed, Fixed);
+    impl_read_for_datatype!(read_fword, FWord);
+    impl_read_for_datatype!(read_unsigned_fword, UnsignedFWord);
+    impl_read_for_datatype!(read_f2dot14, F2Dot14);
+    impl_read_for_datatype!(read_long_date_time, LongDateTime);
+    impl_read_for_datatype!(read_i8, i8);
+    impl_read_for_datatype!(read_u8, u8);
+    impl_read_for_datatype!(read_u16, u16);
+    impl_read_for_datatype!(read_u32, u32);
+    impl_read_for_datatype!(read_i16, i16);
+    impl_read_for_datatype!(read_i64, i64);
 }
 
 #[cfg(test)]

src/jpeg/decoder.rs

@@ -1,11 +1,12 @@
 use crate::{
+    impl_read_for_datatype,
     jpeg::grammar::{
         Component, EncodingProcess, HuffmanTable, Jpeg, Marker, QuantizationTable, StartOfFrame,
         StartOfScan, JFIF,
     },
-    read, read_slice,
-    util::read_bytes::{U16_BYTES, U8_BYTES},
+    read_slice,
 };
+
 use anyhow::{anyhow, ensure, Result};
 use std::ops::{Range, RangeInclusive};
 
@@ -79,7 +80,7 @@ impl<'a> JpegDecoder<'a> {
         let offset = self.cursor;
         let length = self.read_u16()?;
 
-        ensure!(self.read_fixed::<5>()? == b"JFIF\0");
+        ensure!(self.read_slice(5)? == b"JFIF\0");
 
         self.cursor = offset + length as usize;
 
@@ -188,7 +189,7 @@ impl<'a> JpegDecoder<'a> {
         let range = Range {
             start: self.cursor,
             end: {
-                while self.data[self.cursor..self.cursor + U16_BYTES] != [0xFF, 0xD9] {
+                while self.peek_slice(2)? != &[0xFF, 0xD9] {
                     self.cursor += 1;
                 }
 
@@ -199,8 +200,8 @@ impl<'a> JpegDecoder<'a> {
         Ok(range)
     }
 
-    read!(read_u8, u8, U8_BYTES);
-    read!(read_u16, u16, U16_BYTES);
-    read!(read_marker, Marker, U16_BYTES);
+    impl_read_for_datatype!(read_u8, u8);
+    impl_read_for_datatype!(read_u16, u16);
+    impl_read_for_datatype!(read_marker, Marker);
     read_slice!();
 }

src/lib.rs

@@ -7,6 +7,5 @@ pub mod font;
 pub mod image;
 pub mod jpeg;
 pub mod png;
-pub mod qoi;
 pub mod renderer;
 pub mod util;

src/png/decoder.rs

@@ -1,15 +1,14 @@
 #[cfg(feature = "time")]
 use crate::util::event_log::{log_event, Event};
 use crate::{
-    eof,
     image::grammar::ColorType,
+    impl_read_for_datatype,
     png::{
         crc32::compute_crc,
         grammar::{Chunk, ImageHeader, Png},
         scanline_reader::ScanlineReader,
     },
-    read, read_slice,
-    util::read_bytes::{U32_BYTES, U8_BYTES},
+    read_slice,
 };
 use anyhow::{bail, ensure, Result};
 use flate2::read::ZlibDecoder;
@@ -224,15 +223,13 @@ impl<'a> PngDecoder<'a> {
     }
 
     fn skip_crc(&mut self) -> Result<()> {
-        self.eof(4)?;
-        self.cursor += 4;
+        let _ = self.read_slice(4)?;
 
         Ok(())
     }
 
-    eof!();
-    read!(read_u8, u8, U8_BYTES);
-    read!(read_u32, u32, U32_BYTES);
+    impl_read_for_datatype!(read_u8, u8);
+    impl_read_for_datatype!(read_u32, u32);
     read_slice!();
 
     fn read_slice_until(&mut self, stop: u8) -> Result<&'a [u8]> {