hex.hpp

// EVMC: Ethereum Client-VM Connector API.
// Copyright 2021 The EVMC Authors.
// Licensed under the Apache License, Version 2.0.
#pragma once
 
#include <evmc/bytes.hpp>
#include <evmc/filter_iterator.hpp>
#include <cstdint>
#include <optional>
#include <string>
#include <string_view>
 
namespace evmc
{
inline std::string hex(uint8_t b) noexcept
{
    static constexpr auto hex_digits = "0123456789abcdef";
    return {hex_digits[b >> 4], hex_digits[b & 0xf]};
}
 
inline std::string hex(bytes_view bs)
{
    std::string str;
    str.reserve(bs.size() * 2);
    for (const auto b : bs)
        str += hex(b);
    return str;
}
 
namespace internal
{
inline constexpr int from_hex_digit(char h) noexcept
{
    if (h >= '0' && h <= '9')
        return h - '0';
    else if (h >= 'a' && h <= 'f')
        return h - 'a' + 10;
    else if (h >= 'A' && h <= 'F')
        return h - 'A' + 10;
    else
        return -1;
}
}  // namespace internal
 
template <typename InputIt, typename OutputIt>
inline constexpr bool from_hex(InputIt begin, InputIt end, OutputIt out) noexcept
{
    int hi_nibble = -1;  // Init with invalid value, should never be used.
    size_t i = 0;
    for (auto it = begin; it != end; ++it, ++i)
    {
        const auto h = *it;
        const int v = evmc::internal::from_hex_digit(h);
        if (v < 0)
        {
            if (i == 1 && hi_nibble == 0 && h == 'x')  // 0x prefix
                continue;
            return false;
        }
 
        if (i % 2 == 0)
            hi_nibble = v << 4;
        else
            *out++ = static_cast<uint8_t>(hi_nibble | v);
    }
 
    return i % 2 == 0;
}
 
inline bool validate_hex(std::string_view hex) noexcept
{
    struct noop_output_iterator
    {
        uint8_t sink = {};
        uint8_t& operator*() noexcept { return sink; }
        noop_output_iterator operator++(int) noexcept { return *this; }  // NOLINT(cert-dcl21-cpp)
    };
 
    return from_hex(hex.begin(), hex.end(), noop_output_iterator{});
}
 
inline std::optional<bytes> from_hex(std::string_view hex)
{
    bytes bs;
    bs.reserve(hex.size() / 2);
    if (!from_hex(hex.begin(), hex.end(), std::back_inserter(bs)))
        return {};
    return bs;
}
 
template <typename T>
constexpr std::optional<T> from_hex(std::string_view s) noexcept
{
    // Omit the optional 0x prefix.
    if (s.size() >= 2 && s[0] == '0' && s[1] == 'x')
        s.remove_prefix(2);
 
    T r{};  // The T must have .bytes array. This may be lifted if std::bit_cast is available.
    constexpr auto num_out_bytes = std::size(r.bytes);
    const auto num_in_bytes = s.length() / 2;
    if (num_in_bytes > num_out_bytes)
        return {};
    if (!from_hex(s.begin(), s.end(), &r.bytes[num_out_bytes - num_in_bytes]))
        return {};
    return r;
}
 
template <typename InputIterator>
std::optional<bytes> from_spaced_hex(InputIterator begin, InputIterator end) noexcept
{
    bytes bs;
    if (!from_hex(skip_space_iterator{begin, end}, skip_space_iterator{end, end},
                  std::back_inserter(bs)))
        return {};
    return bs;
}
 
inline std::optional<bytes> from_spaced_hex(std::string_view hex) noexcept
{
    return from_spaced_hex(hex.begin(), hex.end());
}
}  // namespace evmc