     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59

    ///! 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 => $ret:expr) => {
            expect!(next!($bytes) => $pat |? $ret)
        };
        ($e:expr => $pat:pat |? $ret:expr) => {
            match $e {
                v@$pat => v,
                _ => return $ret
            }
        };
    }

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

    macro_rules! byte_map {
        ($($flag:expr,)*) => ([
            $($flag != 0,)*
        ])
    }

    macro_rules! space {
        ($bytes:ident or $err:expr) => ({
            expect!($bytes.next() == b' ' => Err($err));
            $bytes.slice();
        })
    }

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