native.memory.ccm

module;
// SPDX-FileCopyrightText: 2024 Edward Kmett <ekmett@gmail.com>
// SPDX-License-Identifier: BSD-2-Clause OR Apache-2.0
#include <type_traits>
#include <cstdlib>
#include <cstring>
#include <memory>
#include "native/attributes.h"
 
#if defined(__unix__) || defined(__APPLE__)
#include <sys/mman.h>
#endif
 
export module native.memory;

export namespace native {

  template<typename T>
  concept trivially_destructible = std::is_trivially_destructible_v<std::remove_extent_t<T>>;

  struct c_free {
    template <trivially_destructible T>
    native_inline native_artificial
    static void operator()(T * p) noexcept {
      std::free(const_cast<std::remove_const_t<T>*>(p));
    }
  };

  template<trivially_destructible T>
  using unique_c_ptr = std::unique_ptr<T, c_free>;
 
  static_assert(sizeof(char *)== sizeof(unique_c_ptr<char>),"");

  using unique_str = unique_c_ptr<char const>;

  native_nodiscard native_inline native_artificial
  native_nonnull(1) native_null_terminated_string_arg(1)
  unique_str dup(
    native_noescape char const * str
  ) noexcept {
    auto const size = std::strlen(str) + 1;
    auto * copy = static_cast<char *>(std::malloc(size));
    if (copy == nullptr) return {};
    std::memcpy(copy, str, size);
    return unique_str{copy};
  }
 
} // native
 
#if defined(__unix__) || defined(__APPLE__)
export namespace native {

  struct c_munmap {
    std::size_t size;
    native_inline native_artificial
    void operator()(void * p) const noexcept {
      if (p != nullptr)
        munmap(p, size);
    }
  };

  using mmap_ptr = std::unique_ptr<void,c_munmap>;

  native_inline native_artificial native_nonnull(1)
  mmap_ptr make_mmap_ptr(void * p, std::size_t size) noexcept {
    return mmap_ptr(p,c_munmap(size));
  }
 
} // native
#endif