Enum dbin::Spec

pub enum Spec {
    Int {
        little_endian: bool,
        signed: bool,
        nbytes: usize,
        expected: Option<i64>,
    },
    Array {
        size: Expr,
        member: Box<Spec>,
    },
    Enum(Vec<(Key, Spec)>),
    Struct(Vec<Spec>),
    Scope {
        args: Vec<(Key, Expr)>,
        body: Box<Spec>,
    },
    Store(Key, Box<Spec>),
}

Dead simple, quick and dirty binary data parser combinator

Variants

Int

Fields of Int

little_endian: boolsigned: boolnbytes: usizeexpected: Option<i64>

Expected value for the parse to succeed (e.g. for magic)

Array

Fields of Array

size: Exprmember: Box<Spec>

Enum(Vec<(Key, Spec)>)

Struct(Vec<Spec>)

Scope

Fields of Scope

args: Vec<(Key, Expr)>body: Box<Spec>

Store(Key, Box<Spec>)

Implementations

impl Spec

pub fn parse(&self, bytes: &[u8]) -> Result<Data, String>

impl Spec

pub fn args() -> SpecArgs

pub fn pairs() -> SpecPairs

pub fn le_magic_u64(value: u64) -> Spec

pub fn be_magic_u64(value: u64) -> Spec

pub fn magic_u64(little_endian: bool, value: u64) -> Spec

pub fn magic(little_endian: bool, nbytes: usize, value: i64) -> Spec

pub fn le_magic(nbytes: usize, value: i64) -> Spec

pub fn be_magic(nbytes: usize, value: i64) -> Spec

pub fn int(little_endian: bool, signed: bool, nbytes: usize) -> Spec

pub fn le_int(signed: bool, nbytes: usize) -> Spec

pub fn be_int(signed: bool, nbytes: usize) -> Spec

pub fn le_sint(nbytes: usize) -> Spec

pub fn le_uint(nbytes: usize) -> Spec

pub fn be_sint(nbytes: usize) -> Spec

pub fn be_uint(nbytes: usize) -> Spec

pub fn arr<E: Into<Expr>>(p: Spec, e: E) -> Spec

pub fn en<K: Into<Key>>(vec: Vec<(K, Spec)>) -> Spec

Enum -- will try each of the alternatives in order, and return the first successful variant The variant will be tagged in the resulting Data (as a Data::Enum)

pub fn st(vec: Vec<Spec>) -> Spec

Struct -- all alternatives must succeed in order

pub fn scope<K: Into<Key>, E: Into<Expr>>(args: Vec<(K, E)>, p: Spec) -> Spec

pub fn store<K: Into<Key>>(key: K, p: Spec) -> Spec

Stores the result of a parse into a key for later use (e.g. as length of an array)