bin_read! macro for declarative binary parsing (ReadBinary generation)

[zeonzip]

Hey! I saw the way allsorts currently writes ReadBinary implementations for tables are quite repetitive, very manual and has alot of boilerplate so I wanted to suggest a procedural macro which could help in generating less error prone, more readable implementations with a bin_read! macro.

Proposed syntax (example with SvgTable):

// SvgTable declaration over here

bin_read! {
    SvgTable<'b> {
        version: u16be, // field to be parsed to final SvgTable as next
        #(version == 0), // assertion with ctxt.check()
        $offset(u32be : usize), // local variable declaration to be read as next (local variables are not parsed to the final struct) and read as u32, and be parsed to usize
        @offset, // jump with a offset with the local variable "offset"
        $count(u16be : usize), // declare and read another local variable
        document_records: [count] // array dep to be used in final SvgTable with the length of the local var "count"
    }
}

The bin_read! macro would generate a ReadBinary implementation for the type and the HostType accordingly and would result in a roughly the same implementation:

impl<'b> ReadBinary for SvgTable<'b> {
    type HostType<'a> = SvgTable<'a>;

    fn read<'a>(ctxt: &mut ReadCtxt<'a>) -> Result<Self::HostType<'a>, ParseError> {
        let scope = ctxt.scope();

        let version = ctxt.read_u16be()?; // read u16be (to be used as final field)
        ctxt.check(version == 0)?; // perform the #() check assertion
        let offset = usize::try_from(ctxt.read_u32be()?)?; // store local variable offset, read as u32be and parse to usize

        let scope2 = scope.offset(offset); // scope offset jump
        let mut scope2_ctxt = scope2.ctxt(); // enter new scope offset

        let count = usize::try_from(scope2_ctxt.read_u16be()?)?; // stores the count as a local variable and parses to usize from u16be
        let document_records = scope2_ctxt.read_array_dep(count, scope2)?; // reads the array dep for final document_records with length of count

        Ok(SvgTable {
            version,
            document_records,
        }) // final parsed data
    }
}

Totally get if this isn't something that fits the project or is overkill, wanted to share it incase it was found interesting or sparked ideas!

[mikeday]

Thanks for the suggestion! We are always interested in exploring ideas for binary format parsing, which we are experimenting with here:

• https://github.com/yeslogic/fathom/
• https://github.com/yeslogic/fathom-experiments/
• https://github.com/yeslogic/doodle/

Most of these are focused on compilers and DSLs, but it is useful to consider what Rust macros can do!

[zeonzip]

Absolutely! Fathom absolutely looks like a powerful and well designed solution! - I only explored the bin_read! macro because I saw some inactivity on the Fathom repo, and was unsure of the status. Definitively excited to see where it goes! 👍