pointer.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Jarosław Pelczar <jarek@jpelczar.com>
//
// SPDX-License-Identifier: BSD-2-Clause
 
#pragma once
 
#include "../microfmt.hpp"
#include <cstddef>
#include <cstdint>
#include <limits>
#include <string_view>
#include <type_traits>
 
namespace microfmt {
 
enum class ptr_width_mode : uint8_t {
  native = 0, // 8 hex digits on 32-bit arch, 16 on 64-bit arch
  compat32,   // Always 8 hex digits (32-bit address space, e.g. ARM Cortex-M /
              // RISC-V 32)
  compat64    // Always 16 hex digits
};
 
struct MICROFMT_API_CLASS raw_ptr_view {
  uintptr_t address{0};
  bool is_null{false};
  ptr_width_mode width_mode{ptr_width_mode::native};
};
 
// low-level formatting: raw character pointers and integer width conversions bounded by the buffer sizes checked here.
RELOCO_BEGIN_UNSAFE_CODE
template <typename T>
[[nodiscard]] constexpr raw_ptr_view raw_ptr(const T *ptr, ptr_width_mode mode = ptr_width_mode::native) noexcept {
  return raw_ptr_view{reinterpret_cast<uintptr_t>(ptr), ptr == nullptr, mode};
}
RELOCO_END_UNSAFE_CODE
 
[[nodiscard]] constexpr raw_ptr_view raw_ptr(std::nullptr_t, ptr_width_mode mode = ptr_width_mode::native) noexcept {
  return raw_ptr_view{0, true, mode};
}
 
[[nodiscard]] constexpr raw_ptr_view raw_ptr(uintptr_t addr, ptr_width_mode mode = ptr_width_mode::native) noexcept {
  return raw_ptr_view{addr, addr == 0, mode};
}
 
template <typename T> [[nodiscard]] constexpr raw_ptr_view raw_ptr32(const T *ptr) noexcept {
  return raw_ptr(ptr, ptr_width_mode::compat32);
}
 
[[nodiscard]] constexpr raw_ptr_view raw_ptr32(std::nullptr_t) noexcept {
  return raw_ptr(nullptr, ptr_width_mode::compat32);
}
 
[[nodiscard]] constexpr raw_ptr_view raw_ptr32(uintptr_t addr) noexcept {
  return raw_ptr(addr, ptr_width_mode::compat32);
}
 
template <typename T> struct RELOCO_POINTER raw_range_view {
  const T *begin_ptr{nullptr};
  const T *end_ptr{nullptr};
  microfmt::string_view separator{", "};
  char open_delim{'['};
  char close_delim{']'};
 
  [[nodiscard]] constexpr size_t size() const noexcept {
    if (begin_ptr == nullptr || end_ptr == nullptr || end_ptr < begin_ptr) {
      return 0;
    }
    return static_cast<size_t>(end_ptr - begin_ptr);
  }
};
 
template <typename T> [[nodiscard]] constexpr raw_range_view<T> raw_range(const T *first, const T *last) noexcept {
  return raw_range_view<T>{first, last};
}
 
template <typename T> [[nodiscard]] constexpr raw_range_view<T> raw_range(const T *first, size_t count) noexcept {
  RELOCO_BEGIN_UNSAFE_BUFFER_USAGE;
 
  return raw_range_view<T>{first, first ? first + count : nullptr};
 
  RELOCO_END_UNSAFE_BUFFER_USAGE;
}
 
template <> struct formatter<raw_ptr_view> {
  static constexpr size_t native_hex_width = sizeof(uintptr_t) * 2;
 
  bool uppercase_hex{false};
  bool show_prefix{true};
  ptr_width_mode mode{ptr_width_mode::native};
  size_t custom_width{0};
  microfmt::string_view null_representation{"(nil)"};
 
  MICROFMT_API_CONSTEXPR void parse(format_parse_context &ctx) noexcept;
 
  MICROFMT_API void format(const raw_ptr_view &ptr, const sink &out) const noexcept;
};
 
#if MICROFMT_SHARED_PROVIDE_DEFINITIONS
#include "pointer.ipp"
#endif
 
template <typename T> struct formatter<raw_range_view<T>> {
  char open_c{'['};
  char close_c{']'};
  microfmt::string_view forwarded_spec{""};
 
  constexpr void parse(format_parse_context &ctx) noexcept {
    auto spec = ctx.spec();
    if (spec.empty())
      return;
 
    size_t i = 0;
    if (spec[0] == 'b' || spec[0] == 'B') {
      open_c = '[';
      close_c = ']';
      i = 1;
    } else if (spec[0] == 'c' || spec[0] == 'C') {
      open_c = '{';
      close_c = '}';
      i = 1;
    } else if (spec[0] == 'n' || spec[0] == 'N') {
      open_c = '\0';
      close_c = '\0';
      i = 1;
    }
 
    forwarded_spec = spec.substr(i);
  }
 
  void format(const raw_range_view<T> &range, const sink &out) const noexcept {
    if (open_c != '\0') {
      out.put(open_c);
    }
 
    formatter<T> elem_fmt;
    format_parse_context elem_ctx(forwarded_spec);
    elem_fmt.parse(elem_ctx);
 
    const size_t count = range.size();
    for (size_t idx = 0; idx < count; ++idx) {
      if (idx > 0) {
        out.write(range.separator);
      }
      RELOCO_BEGIN_UNSAFE_BUFFER_USAGE;
      RELOCO_DEBUG_ASSERT(range.begin_ptr + idx < range.end_ptr, "Index out of range");
      elem_fmt.format(range.begin_ptr[idx], out);
      RELOCO_END_UNSAFE_BUFFER_USAGE;
    }
 
    if (close_c != '\0') {
      out.put(close_c);
    }
  }
};
 
} // namespace microfmt