ntex-httparse 2.2.0

//! Utility macros

macro_rules! next {
    ($bytes:ident) => {{
        match $bytes.next() {
            Some(b) => b,
            None => return Ok(Status::Partial),
        }
    }};
}

macro_rules! expect {
    ($bytes:ident.next() == $pat:pat_param => $ret:expr) => {
        expect!(next!($bytes) => $pat |? $ret)
    };
    ($e:expr => $pat:pat_param |? $ret:expr) => {
        match $e {
            v@$pat => v,
            _ => return $ret
        }
    };
}

// Expects `\n` after an already consumed `\r`. If the input ends after `\r`,
// rewinds to it, so a resumed parse must see `\r\n` again.
macro_rules! expect_lf {
    ($bytes:ident => $ret:expr) => {
        match $bytes.next() {
            Some(b'\n') => {}
            Some(_) => return $ret,
            None => {
                $bytes.rewind(1);
                return Ok(Status::Partial);
            }
        }
    };
}

macro_rules! complete {
    ($e:expr) => {
        match $e? {
            Status::Complete(v) => v,
            Status::Partial => return Ok(Status::Partial),
        }
    };
}

macro_rules! byte_map {
    ($($p:pat_param)|+) => {{
        const fn make_map() -> [bool; 256] {
            let mut ret = [false; 256];
            let mut i = 0;
            while i < 256 {
                ret[i] = matches!(i as u8, $($p)|+);
                i += 1;
            }
            ret
        }
        make_map()
    }}
}

macro_rules! newline {
    ($bytes:ident) => ({
        match next!($bytes) {
            b'\r' => {
                expect_lf!($bytes => Err(Error::NewLine));
                $bytes.commit();
            },
            b'\n' => {
                $bytes.commit();
            },
            _ => return Err(Error::NewLine)
        }
    })
}