211 lines
6.7 KiB
C++

#include "affinity.hpp"
#include <algorithm>
#include <array>
namespace affinity {
namespace detail {
bool normalize_set(const CoreSet &input, CoreSet &output)
{
output.ids.clear();
std::array<bool, 256> seen{};
for (std::uint16_t id : input.ids) {
if (id > 255 || seen[id]) return false;
seen[id] = true;
}
for (std::uint16_t id = 0; id < 256; ++id) {
if (seen[id]) output.ids.push_back(id);
}
return true;
}
}
namespace {
bool decimal(const std::string &text, std::size_t &cursor,
unsigned maximum, unsigned &result)
{
const std::size_t first = cursor;
unsigned value = 0;
while (cursor < text.size() && text[cursor] >= '0' && text[cursor] <= '9') {
const unsigned digit = static_cast<unsigned>(text[cursor] - '0');
if (value > (maximum - digit) / 10) return false;
value = value * 10 + digit;
++cursor;
}
if (cursor == first) return false;
result = value;
return true;
}
bool separator(const std::string &text, std::size_t &cursor, char wanted)
{
if (cursor == text.size() || text[cursor] != wanted) return false;
++cursor;
return true;
}
bool list_item(const std::string &item, std::array<bool, 256> &present)
{
std::size_t at = 0;
unsigned first = 0;
if (!decimal(item, at, 255, first)) return false;
if (at == item.size()) {
present[first] = true;
return true;
}
if (!separator(item, at, '-')) return false;
unsigned last = 0;
if (!decimal(item, at, 255, last) || first > last) return false;
unsigned used = 1;
unsigned group = 1;
if (at != item.size()) {
if (!separator(item, at, ':') || !decimal(item, at, 256, used) ||
!separator(item, at, '/') || !decimal(item, at, 256, group) ||
used == 0 || group == 0 || used > group) return false;
}
if (at != item.size()) return false;
for (unsigned id = first; id <= last; ++id) {
if ((id - first) % used == 0) present[id] = true;
}
return true;
}
int hex_digit(unsigned char byte)
{
if (byte >= '0' && byte <= '9') return byte - '0';
if (byte >= 'a' && byte <= 'f') return byte - 'a' + 10;
if (byte >= 'A' && byte <= 'F') return byte - 'A' + 10;
return -1;
}
bool mask_word(const std::string &text, std::uint32_t &value)
{
if (text.empty() || text.size() > 8) return false;
value = 0;
for (unsigned char byte : text) {
const int digit = hex_digit(byte);
if (digit < 0) return false;
value = value * 16 + static_cast<unsigned>(digit);
}
return true;
}
std::string word_text(std::uint32_t value, bool full_width)
{
constexpr char digits[] = "0123456789abcdef";
std::string text;
do {
text.push_back(digits[value & 15]);
value >>= 4;
} while (value != 0);
while (full_width && text.size() < 8) text.push_back('0');
std::reverse(text.begin(), text.end());
return text;
}
}
Error parse_list(const std::string &text, CoreSet &output)
{
output.ids.clear();
if (text.size() > 4096) return Error::invalid;
if (text.empty()) return Error::none;
std::array<bool, 256> present{};
std::size_t begin = 0;
for (;;) {
const auto comma = text.find(',', begin);
const auto end = comma == std::string::npos ? text.size() : comma;
if (!list_item(text.substr(begin, end - begin), present)) return Error::invalid;
if (comma == std::string::npos) break;
begin = comma + 1;
}
for (std::uint16_t id = 0; id < 256; ++id) {
if (present[id]) output.ids.push_back(id);
}
return Error::none;
}
Error format_list(const CoreSet &input, std::string &output)
{
output.clear();
CoreSet normalized;
if (!detail::normalize_set(input, normalized)) return Error::invalid;
std::size_t first = 0;
while (first < normalized.ids.size()) {
std::size_t last = first;
while (last + 1 < normalized.ids.size() &&
normalized.ids[last + 1] == normalized.ids[last] + 1) ++last;
if (!output.empty()) output.push_back(',');
output += std::to_string(normalized.ids[first]);
if (last != first) output += "-" + std::to_string(normalized.ids[last]);
first = last + 1;
}
return Error::none;
}
Error parse_mask(const std::string &text, CoreSet &output)
{
output.ids.clear();
if (text.empty() || text.size() > 4096) return Error::invalid;
std::vector<std::uint32_t> words;
std::size_t begin = 0;
for (;;) {
const auto comma = text.find(',', begin);
const auto end = comma == std::string::npos ? text.size() : comma;
std::uint32_t word = 0;
if (words.size() == 8 || !mask_word(text.substr(begin, end - begin), word))
return Error::invalid;
words.push_back(word);
if (comma == std::string::npos) break;
begin = comma + 1;
}
std::array<bool, 256> present{};
for (std::size_t index = 0; index < words.size(); ++index) {
const auto offset = index * 32;
for (unsigned bit = 0; bit < 32; ++bit) {
if ((words[index] >> bit) & 1u) present[offset + bit] = true;
}
}
for (std::uint16_t id = 0; id < 256; ++id) {
if (present[id]) output.ids.push_back(id);
}
return Error::none;
}
Error format_mask(const CoreSet &input, std::string &output)
{
output.clear();
CoreSet normalized;
if (!detail::normalize_set(input, normalized)) return Error::invalid;
std::array<std::uint32_t, 8> words{};
for (std::uint16_t id : normalized.ids) words[id / 32] |= std::uint32_t(1) << (id % 32);
std::size_t count = words.size();
while (count > 1 && words[count - 1] == 0) --count;
output = word_text(words[count - 1], false);
while (--count != 0) output += "," + word_text(words[count - 1], true);
return Error::none;
}
Error combine(const CoreSet &left, const CoreSet &right,
SetOperation operation, CoreSet &output)
{
output.ids.clear();
CoreSet a;
CoreSet b;
if (!detail::normalize_set(left, a) || !detail::normalize_set(right, b))
return Error::invalid;
if (operation != SetOperation::unite && operation != SetOperation::intersect &&
operation != SetOperation::subtract) return Error::invalid;
for (std::uint16_t id = 0; id < 256; ++id) {
const bool in_a = std::binary_search(a.ids.begin(), a.ids.end(), id);
const bool in_b = std::binary_search(b.ids.begin(), b.ids.end(), id);
const bool keep = operation == SetOperation::unite ? in_a || in_b :
operation == SetOperation::intersect ? in_a && in_b : in_a && !in_b;
if (keep) output.ids.push_back(id);
}
return Error::none;
}
}