bits.cpp
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
#include "crucible/parsing/bits.inl"
#include <algorithm>
#include <climits>
namespace crucible::parsing::bits {
ParseState::ParseState(std::span<std::byte const> const &input) :
my_input(input) {
}
ParseState::ParseState(std::span<std::byte const> const &input, std::size_t const byte_offset, std::size_t const bit_offset) :
my_input(input),
my_byte_offset(byte_offset),
my_bit_offset(bit_offset) {
}
auto ParseState::is_finished() const -> bool {
return my_byte_offset >= my_input.size();
}
auto ParseState::get_remaining_bytes_in_input() const -> std::span<std::byte const> {
return my_input.subspan(my_byte_offset);
}
auto ParseState::get_remaining_bits_in_byte() const -> std::byte {
constexpr std::byte ALL_ONES { 0xff };
std::byte const next_byte = my_input[my_byte_offset];
std::byte const mask = ALL_ONES >> my_bit_offset;
return next_byte & mask;
}
auto ParseState::advance_by_bytes(std::size_t const byte_count) const -> ParseState {
return ParseState { my_input, my_byte_offset + byte_count, my_bit_offset };
}
auto ParseState::advance_by_bits(std::size_t const bit_count) const -> ParseState {
std::size_t const total_bit_offset = my_byte_offset * CHAR_BIT + my_bit_offset + bit_count;
std::size_t const new_byte_offset = total_bit_offset / CHAR_BIT;
std::size_t const new_bit_offset = total_bit_offset % CHAR_BIT;
return ParseState { my_input, new_byte_offset, new_bit_offset };
}
ByteSequence::ByteSequence(std::span<std::byte const> byte_sequence) :
my_byte_sequence(byte_sequence) {
}
auto ByteSequence::operator()(ParseState const &state) const -> ParseResult<core::none::None> {
auto const &remaining_bytes = state.get_remaining_bytes_in_input();
if (remaining_bytes.size() < my_byte_sequence.size()) {
return outcomes::reject(state, ParseError { UnexpectedEndOfInput {} });
}
auto const sequence_begin = my_byte_sequence.begin();
auto const sequence_end = my_byte_sequence.end();
auto const input_begin = remaining_bytes.begin();
bool const is_equal = std::equal(sequence_begin, sequence_end, input_begin);
if (is_equal) {
auto const next_state = state.advance_by_bytes(my_byte_sequence.size());
return outcomes::accept(next_state, core::none::None {});
} else {
return outcomes::reject(state, ParseError { ByteSequenceMismatch {} });
}
}
}