binator 0.3.0

Parser Combinator
Documentation 
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

use crate::{
  base::{
    octet,
    BaseAtom,
  },
  utils::Utils,
  Contexting,
  CoreAtom,
  Parse,
  Parsed,
  Streaming,
  Success,
};

fn raw<Stream, Context>(stream: Stream) -> Parsed<u32, Stream, Context>
where
  Stream: Streaming,
  Context: Contexting<CoreAtom<Stream>>,
  Context: Contexting<BaseAtom<u8>>,
  Stream::Item: Into<u8>,
{
  let Success { token: a, stream } = octet.parse(stream)?;
  if a & 0x80 == 0 {
    Parsed::Success {
      token: a as u32,
      stream,
    }
  } else if a & 0xE0 == 0xC0 {
    let Success { token: b, stream } = octet.parse(stream)?;

    Parsed::Success {
      token: (a as u32 & 0x1F) << 6 | (b as u32 & 0x3F),
      stream,
    }
  } else if a & 0xF0 == 0xE0 {
    let Success { token: b, stream } = octet.parse(stream)?;
    let Success { token: c, stream } = octet.parse(stream)?;

    Parsed::Success {
      token: (a as u32 & 0x0F) << 12 | (b as u32 & 0x3F) << 6 | (c as u32 & 0x3F),
      stream,
    }
  } else if a & 0xF8 == 0xF0 {
    let Success { token: b, stream } = octet.parse(stream)?;
    let Success { token: c, stream } = octet.parse(stream)?;
    let Success { token: d, stream } = octet.parse(stream)?;

    Parsed::Success {
      token: (a as u32 & 0x07) << 18
        | (b as u32 & 0x3F) << 12
        | (c as u32 & 0x3F) << 6
        | (d as u32 & 0x3F),
      stream,
    }
  } else {
    Parsed::Failure(Contexting::new(BaseAtom::Utf8 {}))
  }
}

/// Parser that will read stream and return valid utf8 char
/// If you are expecting utf8 you MUST use this Parser, and not character
/// Parser.
#[cfg_attr(
  feature = "tracing",
  tracing::instrument(level = "trace", skip_all, ret(Display))
)]
pub fn utf8<Stream, Context>(stream: Stream) -> Parsed<char, Stream, Context>
where
  Stream: Streaming,
  Context: Contexting<CoreAtom<Stream>>,
  Context: Contexting<BaseAtom<u8>>,
  Stream::Item: Into<u8>,
{
  raw
    .try_map(|raw| char::from_u32(raw).ok_or_else(|| Contexting::new(BaseAtom::Utf8 {})))
    .parse(stream)
}

#[cfg(test)]
mod tests {
  use crate::{
    context::Ignore,
    Parsed,
  };

  #[test]
  fn utf8() {
    println!("{}", "❤".len());
    assert_eq!(
      super::utf8::<_, Ignore>("❤".as_bytes()),
      Parsed::Success {
        token: '❤',
        stream: "".as_bytes(),
      }
    );
  }
}